C#输出窗口信息显示完全指南从Console WriteLine到Debug调试技巧详解

威震华夏关云长

在C#开发过程中，输出信息显示是开发者与程序交互的重要方式。无论是简单的控制台应用程序还是复杂的企业级系统，有效地输出和显示信息都是调试、监控和维护程序的关键环节。本文将全面介绍C#中从基础的Console.WriteLine到高级的Debug调试技巧，帮助开发者掌握各种输出窗口信息显示的方法，提高开发效率和程序调试能力。

基础输出方法：Console.WriteLine及其相关方法

Console.WriteLine基础用法

Console.WriteLine是C#中最基本也是最常用的输出方法，它将指定的文本或数据输出到控制台窗口，并在末尾添加一个换行符。

2. // 输出简单文本
3. Console.WriteLine("Hello, World!");
5. // 输出变量的值
6. int number = 42;
7. Console.WriteLine(number);
9. // 使用格式化字符串输出
10. string name = "Alice";
11. int age = 30;
12. Console.WriteLine("Name: {0}, Age: {1}", name, age);
14. // 使用字符串插值（C# 6.0及以上版本）
15. Console.WriteLine($"Name: {name}, Age: {age}");

复制代码

Console.Write方法

与Console.WriteLine不同，Console.Write方法在输出后不添加换行符。

2. Console.Write("This is on the same line. ");
3. Console.Write("This continues the same line.");
4. // 输出: This is on the same line. This continues the same line.

复制代码

格式化输出

C#提供了多种格式化输出的方式，使开发者能够控制数据的显示格式。

2. // 数值格式化
3. double price = 19.99;
4. Console.WriteLine("Price: {0:C}", price); // 货币格式
5. Console.WriteLine("Price: {0:F2}", price); // 固定小数点格式
6. Console.WriteLine("Percentage: {0:P}", 0.25); // 百分比格式
8. // 日期格式化
9. DateTime now = DateTime.Now;
10. Console.WriteLine("Date: {0:d}", now); // 短日期格式
11. Console.WriteLine("Date: {0:D}", now); // 长日期格式
12. Console.WriteLine("Time: {0:t}", now); // 短时间格式
13. Console.WriteLine("Time: {0:T}", now); // 长时间格式

复制代码

控制台颜色设置

开发者可以通过设置控制台的前景色和背景色来增强输出的可读性。

2. // 保存当前颜色
3. ConsoleColor originalForegroundColor = Console.ForegroundColor;
4. ConsoleColor originalBackgroundColor = Console.BackgroundColor;
6. // 设置新的颜色
7. Console.ForegroundColor = ConsoleColor.Yellow;
8. Console.BackgroundColor = ConsoleColor.Blue;
10. // 输出彩色文本
11. Console.WriteLine("This is a colored message.");
13. // 恢复原始颜色
14. Console.ForegroundColor = originalForegroundColor;
15. Console.BackgroundColor = originalBackgroundColor;

复制代码

控制台窗口操作

C#还提供了操作控制台窗口的方法，如设置窗口大小、标题等。

2. // 设置窗口标题
3. Console.Title = "My Console Application";
5. // 设置窗口大小
6. Console.WindowWidth = 100;
7. Console.WindowHeight = 40;
9. // 清除控制台窗口
10. Console.Clear();
12. // 获取光标位置并设置
13. int left = Console.CursorLeft;
14. int top = Console.CursorTop;
15. Console.SetCursorPosition(10, 5);
16. Console.WriteLine("Positioned text");
17. Console.SetCursorPosition(left, top);

复制代码

Console.ReadLine和Console.ReadKey

除了输出方法，Console类还提供了读取用户输入的方法。

2. // 读取一行文本
3. Console.WriteLine("Please enter your name:");
4. string name = Console.ReadLine();
5. Console.WriteLine($"Hello, {name}!");
7. // 读取单个按键
8. Console.WriteLine("Press any key to continue...");
9. ConsoleKeyInfo keyInfo = Console.ReadKey();
10. Console.WriteLine($"\nYou pressed: {keyInfo.Key}");

复制代码

调试输出：Debug类和Trace类的使用

Debug类基础用法

System.Diagnostics.Debug类提供了一组方法，用于在调试过程中输出信息。这些输出只在调试模式下可见，在发布版本中会被自动忽略。

2. using System.Diagnostics;
4. // 基本Debug输出
5. Debug.WriteLine("This is a debug message");
7. // 条件Debug输出
8. bool debugMode = true;
9. Debug.WriteLineIf(debugMode, "Debug mode is active");
11. // 断言
12. int value = 5;
13. Debug.Assert(value > 10, "Value should be greater than 10");

复制代码

Trace类基础用法

System.Diagnostics.Trace类与Debug类类似，但它的输出在调试和发布版本中都会保留。

2. using System.Diagnostics;
4. // 基本Trace输出
5. Trace.WriteLine("This is a trace message");
7. // 条件Trace输出
8. bool traceEnabled = true;
9. Trace.WriteLineIf(traceEnabled, "Trace is enabled");
11. // 警告和错误信息
12. Trace.TraceWarning("This is a warning");
13. Trace.TraceError("This is an error");

复制代码

Debug和Trace的配置

开发者可以通过配置文件或代码来配置Debug和Trace的输出目标。

2. using System.Diagnostics;
4. // 创建文本写入器作为Trace监听器
5. TextWriterTraceListener textListener = new TextWriterTraceListener("Output.log");
6. Trace.Listeners.Add(textListener);
8. // 创建控制台监听器
9. ConsoleTraceListener consoleListener = new ConsoleTraceListener();
10. Trace.Listeners.Add(consoleListener);
12. // 自动刷新输出
13. Trace.AutoFlush = true;
15. // 使用Trace输出
16. Trace.WriteLine("This message will appear in both console and log file");
18. // 关闭监听器
19. Trace.Close();

复制代码

在应用程序配置文件（app.config或web.config）中，可以配置Trace监听器：

2. <configuration>
3.   <system.diagnostics>
4.     <trace autoflush="true">
5.       <listeners>
6.         <add name="consoleListener" type="System.Diagnostics.ConsoleTraceListener" />
7.         <add name="textListener" type="System.Diagnostics.TextWriterTraceListener" initializeData="Output.log" />
8.         <add name="eventLogListener" type="System.Diagnostics.EventLogTraceListener" initializeData="MyApplication" />
9.       </listeners>
10.     </trace>
11.   </system.diagnostics>
12. </configuration>

复制代码

Debug和Trace的输出级别

可以通过设置TraceLevel来控制输出的详细程度。

2. using System.Diagnostics;
4. // 设置Trace级别
5. TraceSwitch traceSwitch = new TraceSwitch("General", "Entire Application");
6. traceSwitch.Level = TraceLevel.Verbose;
8. // 根据级别输出信息
9. Trace.WriteLineIf(traceSwitch.TraceError, "Error message");
10. Trace.WriteLineIf(traceSwitch.TraceWarning, "Warning message");
11. Trace.WriteLineIf(traceSwitch.TraceInfo, "Info message");
12. Trace.WriteLineIf(traceSwitch.TraceVerbose, "Verbose message");

复制代码

使用Debug和Trace进行性能分析

Debug和Trace类还可以用于简单的性能分析。

2. using System.Diagnostics;
4. // 开始计时
5. Debug.WriteLine("Starting operation");
6. Stopwatch stopwatch = Stopwatch.StartNew();
8. // 执行一些操作
9. Thread.Sleep(1000);
11. // 停止计时并输出结果
12. stopwatch.Stop();
13. Debug.WriteLine($"Operation completed in {stopwatch.ElapsedMilliseconds} ms");

复制代码

高级调试技巧：条件输出、格式化输出等

条件编译符号

使用条件编译符号，可以控制代码是否被编译到程序中。

2. #define DEBUG
3. #define TRACE
5. using System.Diagnostics;
7. public class Program
8. {
9.     public static void Main()
10.     {
11. #if DEBUG
12.         Console.WriteLine("Debug version");
13. #endif
15. #if TRACE
16.         Console.WriteLine("Trace enabled");
17. #endif
19. #if DEBUG && TRACE
20.         Console.WriteLine("Both DEBUG and TRACE are defined");
21. #endif
22.     }
23. }

复制代码

Conditional特性

Conditional特性允许根据条件编译符号来决定是否调用方法。

2. using System.Diagnostics;
4. public class Logger
5. {
6.     [Conditional("DEBUG")]
7.     public static void LogDebug(string message)
8.     {
9.         Console.WriteLine($"DEBUG: {message}");
10.     }
12.     [Conditional("TRACE")]
13.     public static void LogTrace(string message)
14.     {
15.         Console.WriteLine($"TRACE: {message}");
16.     }
17. }
19. public class Program
20. {
21.     public static void Main()
22.     {
23.         Logger.LogDebug("This is a debug message");
24.         Logger.LogTrace("This is a trace message");
25.     }
26. }

复制代码

Debugger类的高级用法

System.Diagnostics.Debugger类提供了与调试器交互的高级方法。

2. using System.Diagnostics;
4. public class Program
5. {
6.     public static void Main()
7.     {
8.         // 检查是否附加了调试器
9.         if (Debugger.IsAttached)
10.         {
11.             Console.WriteLine("Debugger is attached");
12.         }
14.         // 启动调试器并附加到当前进程
15.         if (!Debugger.IsAttached)
16.         {
17.             Debugger.Launch();
18.         }
20.         // 设置断点（仅在调试器中有效）
21.         Debugger.Break();
23.         // 输出调试信息
24.         Debug.WriteLine("This is a debug message");
25.     }
26. }

复制代码

使用DebuggerDisplay特性

DebuggerDisplay特性可以自定义对象在调试器中的显示方式。

2. using System.Diagnostics;
4. [DebuggerDisplay("Name = {Name}, Age = {Age}")]
5. public class Person
6. {
7.     public string Name { get; set; }
8.     public int Age { get; set; }
9. }
11. public class Program
12. {
13.     public static void Main()
14.     {
15.         var person = new Person { Name = "Alice", Age = 30 };
16.         // 在调试器中，person对象将显示为 "Name = Alice, Age = 30"
17.         Console.WriteLine(person.Name);
18.     }
19. }

复制代码

使用DebuggerStepThrough和DebuggerHidden特性

这些特性可以控制调试器如何处理特定方法。

2. using System.Diagnostics;
4. public class MathUtils
5. {
6.     [DebuggerStepThrough]
7.     public static int Add(int a, int b)
8.     {
9.         // 调试器将单步执行此方法，而不是进入方法内部
10.         return a + b;
11.     }
13.     [DebuggerHidden]
14.     public static int Multiply(int a, int b)
15.     {
16.         // 调试器将完全隐藏此方法
17.         return a * b;
18.     }
19. }

复制代码

使用TraceSource进行结构化跟踪

TraceSource类提供了更结构化的跟踪方式，允许定义不同的跟踪源和级别。

2. using System.Diagnostics;
4. public class Program
5. {
6.     private static TraceSource traceSource = new TraceSource("MyApp");
8.     public static void Main()
9.     {
10.         // 配置TraceSource
11.         traceSource.Switch = new SourceSwitch("SourceSwitch", "All");
12.         traceSource.Listeners.Add(new ConsoleTraceListener());
14.         // 输出不同级别的跟踪信息
15.         traceSource.TraceEvent(TraceEventType.Error, 0, "Error message");
16.         traceSource.TraceEvent(TraceEventType.Warning, 0, "Warning message");
17.         traceSource.TraceEvent(TraceEventType.Information, 0, "Information message");
18.         traceSource.TraceEvent(TraceEventType.Verbose, 0, "Verbose message");
20.         // 关闭TraceSource
21.         traceSource.Close();
22.     }
23. }

复制代码

使用CorrelationManager跟踪操作

CorrelationManager类可以帮助跟踪跨线程和跨活动的操作。

2. using System.Diagnostics;
4. public class Program
5. {
6.     public static void Main()
7.     {
8.         Trace.CorrelationManager.ActivityId = Guid.NewGuid();
9.         Trace.CorrelationManager.StartLogicalOperation("MainOperation");
11.         Trace.WriteLine("Starting main operation");
13.         // 模拟子操作
14.         Trace.CorrelationManager.StartLogicalOperation("SubOperation");
15.         Trace.WriteLine("Starting sub operation");
16.         Trace.CorrelationManager.StopLogicalOperation();
17.         Trace.WriteLine("Sub operation completed");
19.         Trace.CorrelationManager.StopLogicalOperation();
20.         Trace.WriteLine("Main operation completed");
21.     }
22. }

复制代码

日志记录框架：NLog、log4net、Serilog等

NLog使用指南

NLog是一个灵活且免费的日志记录平台，适用于各种.NET平台。

首先，通过NuGet安装NLog包：

2. Install-Package NLog

复制代码

可以通过代码或配置文件来配置NLog。

2. using NLog;
3. using NLog.Targets;
4. using NLog.Config;
6. public class Program
7. {
8.     public static void Main()
9.     {
10.         // 创建日志配置
11.         var config = new LoggingConfiguration();
13.         // 创建控制台目标
14.         var consoleTarget = new ColoredConsoleTarget("console")
15.         {
16.             Layout = "${longdate}|${level:uppercase=true}|${logger}|${message}"
17.         };
19.         // 创建文件目标
20.         var fileTarget = new FileTarget("file")
21.         {
22.             FileName = "${basedir}/logs/${shortdate}.log",
23.             Layout = "${longdate}|${level:uppercase=true}|${logger}|${message}"
24.         };
26.         // 添加目标到配置
27.         config.AddTarget(consoleTarget);
28.         config.AddTarget(fileTarget);
30.         // 创建规则
31.         config.AddRule(LogLevel.Debug, LogLevel.Fatal, consoleTarget);
32.         config.AddRule(LogLevel.Debug, LogLevel.Fatal, fileTarget);
34.         // 应用配置
35.         LogManager.Configuration = config;
37.         // 获取日志记录器并记录日志
38.         var logger = LogManager.GetCurrentClassLogger();
39.         logger.Debug("This is a debug message");
40.         logger.Info("This is an info message");
41.         logger.Warn("This is a warning message");
42.         logger.Error("This is an error message");
43.         logger.Fatal("This is a fatal error message");
44.     }
45. }

复制代码

在项目中添加NLog.config文件：

2. <?xml version="1.0" encoding="utf-8" ?>
3. <nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd"
4.       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
5.       autoReload="true"
6.       throwExceptions="false">
7.   <targets>
8.     <target name="console" xsi:type="ColoredConsole"
9.             layout="${longdate}|${level:uppercase=true}|${logger}|${message}" />
10.    
11.     <target name="file" xsi:type="File"
12.             fileName="${basedir}/logs/${shortdate}.log"
13.             layout="${longdate}|${level:uppercase=true}|${logger}|${message}" />
14.   </targets>
15.   
16.   <rules>
17.     <logger name="*" minlevel="Debug" writeTo="console" />
18.     <logger name="*" minlevel="Debug" writeTo="file" />
19.   </rules>
20. </nlog>

复制代码

然后在代码中使用：

2. using NLog;
4. public class Program
5. {
6.     private static readonly Logger Logger = LogManager.GetCurrentClassLogger();
8.     public static void Main()
9.     {
10.         Logger.Debug("This is a debug message");
11.         Logger.Info("This is an info message");
12.         Logger.Warn("This is a warning message");
13.         Logger.Error("This is an error message");
14.         Logger.Fatal("This is a fatal error message");
15.     }
16. }

复制代码

log4net使用指南

log4net是另一个流行的日志记录框架，是Apache log4j框架的.NET移植版本。

通过NuGet安装log4net包：

2. Install-Package log4net

复制代码

可以通过代码或配置文件来配置log4net。

在App.config或Web.config中添加log4net配置：

2. <configuration>
3.   <configSections>
4.     <section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler, log4net" />
5.   </configSections>
6.   
7.   <log4net>
8.     <appender name="ConsoleAppender" type="log4net.Appender.ConsoleAppender">
9.       <layout type="log4net.Layout.PatternLayout">
10.         <conversionPattern value="%date [%thread] %-5level %logger - %message%newline" />
11.       </layout>
12.     </appender>
13.    
14.     <appender name="FileAppender" type="log4net.Appender.FileAppender">
15.       <file value="logs/application.log" />
16.       <appendToFile value="true" />
17.       <layout type="log4net.Layout.PatternLayout">
18.         <conversionPattern value="%date [%thread] %-5level %logger - %message%newline" />
19.       </layout>
20.     </appender>
21.    
22.     <root>
23.       <level value="DEBUG" />
24.       <appender-ref ref="ConsoleAppender" />
25.       <appender-ref ref="FileAppender" />
26.     </root>
27.   </log4net>
28. </configuration>

复制代码

然后在代码中使用：

2. using log4net;
3. using log4net.Config;
5. public class Program
6. {
7.     private static readonly ILog Log = LogManager.GetLogger(typeof(Program));
9.     public static void Main()
10.     {
11.         // 配置log4net
12.         XmlConfigurator.Configure();
14.         // 记录日志
15.         Log.Debug("This is a debug message");
16.         Log.Info("This is an info message");
17.         Log.Warn("This is a warning message");
18.         Log.Error("This is an error message");
19.         Log.Fatal("This is a fatal error message");
20.     }
21. }

复制代码

Serilog使用指南

Serilog是一个结构化日志记录库，支持丰富的日志数据结构。

通过NuGet安装Serilog包：

2. Install-Package Serilog
3. Install-Package Serilog.Sinks.Console
4. Install-Package Serilog.Sinks.File

复制代码

2. using Serilog;
4. public class Program
5. {
6.     public static void Main()
7.     {
8.         // 配置Serilog
9.         Log.Logger = new LoggerConfiguration()
10.             .MinimumLevel.Debug()
11.             .WriteTo.Console()
12.             .WriteTo.File("logs/app-.txt", rollingInterval: RollingInterval.Day)
13.             .CreateLogger();
15.         // 记录结构化日志
16.         Log.Information("Hello, {Name}!", "World");
18.         // 记录带有属性的日志
19.         var position = new { Latitude = 25, Longitude = 134 };
20.         Log.Information("Processing {@Position}", position);
22.         // 记录不同级别的日志
23.         Log.Debug("This is a debug message");
24.         Log.Information("This is an info message");
25.         Log.Warning("This is a warning message");
26.         Log.Error("This is an error message");
27.         Log.Fatal("This is a fatal error message");
29.         // 关闭日志
30.         Log.CloseAndFlush();
31.     }
32. }

复制代码

日志框架比较与选择

实际应用案例：不同场景下的最佳实践

控制台应用程序中的输出

在控制台应用程序中，通常需要直接与用户交互，因此输出应该清晰、易读。

2. using System;
3. using System.Threading;
5. public class ConsoleApp
6. {
7.     public static void Main()
8.     {
9.         // 设置控制台标题
10.         Console.Title = "My Console Application";
12.         // 显示欢迎信息
13.         Console.WriteLine("======================================");
14.         Console.WriteLine("=    Welcome to My Application     =");
15.         Console.WriteLine("======================================");
16.         Console.WriteLine();
18.         // 模拟进度显示
19.         Console.Write("Processing: ");
20.         for (int i = 0; i <= 100; i += 10)
21.         {
22.             Console.Write($"{i}% ");
23.             Thread.Sleep(200);
24.         }
25.         Console.WriteLine("\n");
27.         // 彩色输出重要信息
28.         Console.ForegroundColor = ConsoleColor.Green;
29.         Console.WriteLine("Operation completed successfully!");
30.         Console.ResetColor();
32.         // 用户输入
33.         Console.Write("Press any key to exit...");
34.         Console.ReadKey();
35.     }
36. }

复制代码

ASP.NET Core应用程序中的日志记录

在ASP.NET Core应用程序中，日志记录对于监控和调试至关重要。

2. using Microsoft.AspNetCore.Builder;
3. using Microsoft.AspNetCore.Hosting;
4. using Microsoft.Extensions.DependencyInjection;
5. using Microsoft.Extensions.Hosting;
6. using Microsoft.Extensions.Logging;
7. using Serilog;
9. public class Program
10. {
11.     public static void Main(string[] args)
12.     {
13.         // 配置Serilog
14.         Log.Logger = new LoggerConfiguration()
15.             .MinimumLevel.Information()
16.             .WriteTo.Console()
17.             .WriteTo.File("logs/webapp-.txt", rollingInterval: RollingInterval.Day)
18.             .CreateLogger();
20.         try
21.         {
22.             Log.Information("Starting web host");
23.             CreateHostBuilder(args).Build().Run();
24.         }
25.         catch (Exception ex)
26.         {
27.             Log.Fatal(ex, "Host terminated unexpectedly");
28.         }
29.         finally
30.         {
31.             Log.CloseAndFlush();
32.         }
33.     }
35.     public static IHostBuilder CreateHostBuilder(string[] args) =>
36.         Host.CreateDefaultBuilder(args)
37.             .UseSerilog() // 使用Serilog作为日志提供程序
38.             .ConfigureWebHostDefaults(webBuilder =>
39.             {
40.                 webBuilder.UseStartup<Startup>();
41.             });
42. }
44. public class Startup
45. {
46.     private readonly ILogger<Startup> _logger;
48.     public Startup(ILogger<Startup> logger)
49.     {
50.         _logger = logger;
51.     }
53.     public void ConfigureServices(IServiceCollection services)
54.     {
55.         _logger.LogInformation("Configuring services");
56.         // 配置服务
57.     }
59.     public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
60.     {
61.         _logger.LogInformation("Configuring middleware");
62.         
63.         if (env.IsDevelopment())
64.         {
65.             _logger.LogDebug("In development environment");
66.             app.UseDeveloperExceptionPage();
67.         }
69.         app.UseRouting();
70.         
71.         app.UseEndpoints(endpoints =>
72.         {
73.             endpoints.MapGet("/", async context =>
74.             {
75.                 _logger.LogInformation("Processing request to /");
76.                 await context.Response.WriteAsync("Hello World!");
77.             });
78.         });
79.     }
80. }

复制代码

桌面应用程序中的调试输出

在桌面应用程序（如WPF或WinForms）中，调试输出对于开发过程中的问题诊断非常重要。

2. using System;
3. using System.Diagnostics;
4. using System.Windows;
6. namespace WpfApp
7. {
8.     public partial class MainWindow : Window
9.     {
10.         public MainWindow()
11.         {
12.             InitializeComponent();
13.             Loaded += MainWindow_Loaded;
14.         }
16.         private void MainWindow_Loaded(object sender, RoutedEventArgs e)
17.         {
18.             // 使用Debug输出
19.             Debug.WriteLine("Application started");
21.             // 使用Trace输出
22.             Trace.WriteLine("Window loaded");
24.             // 条件输出
25.             bool debugMode = true;
26.             Debug.WriteLineIf(debugMode, "Debug mode is active");
28.             // 性能测量
29.             Stopwatch stopwatch = Stopwatch.StartNew();
30.             // 执行一些操作
31.             LoadData();
32.             stopwatch.Stop();
33.             Debug.WriteLine($"Data loaded in {stopwatch.ElapsedMilliseconds} ms");
34.         }
36.         private void LoadData()
37.         {
38.             // 模拟数据加载
39.             for (int i = 0; i < 100; i++)
40.             {
41.                 Debug.WriteLine($"Loading item {i}");
42.                 // 模拟工作
43.                 System.Threading.Thread.Sleep(10);
44.             }
45.         }
46.     }
47. }

复制代码

库和API中的日志记录

在开发库和API时，提供适当的日志记录可以帮助使用者更好地理解和使用你的代码。

2. using Microsoft.Extensions.Logging;
3. using System;
5. public class MyApiService
6. {
7.     private readonly ILogger<MyApiService> _logger;
9.     public MyApiService(ILogger<MyApiService> logger)
10.     {
11.         _logger = logger ?? throw new ArgumentNullException(nameof(logger));
12.     }
14.     public void ProcessData(string data)
15.     {
16.         try
17.         {
18.             _logger.LogInformation("Starting data processing");
19.             
20.             if (string.IsNullOrEmpty(data))
21.             {
22.                 _logger.LogWarning("Empty data received");
23.                 return;
24.             }
26.             // 模拟处理
27.             _logger.LogDebug("Processing data: {Data}", data);
28.             
29.             // 如果启用了详细日志，输出更多细节
30.             if (_logger.IsEnabled(LogLevel.Debug))
31.             {
32.                 _logger.LogDebug("Data length: {Length}", data.Length);
33.             }
35.             // 实际处理逻辑
36.             var result = data.ToUpper();
37.             
38.             _logger.LogInformation("Data processed successfully");
39.         }
40.         catch (Exception ex)
41.         {
42.             _logger.LogError(ex, "Error processing data");
43.             throw;
44.         }
45.     }
46. }

复制代码

多线程应用程序中的日志记录

在多线程应用程序中，日志记录需要考虑线程安全和上下文信息。

2. using System;
3. using System.Diagnostics;
4. using System.Threading;
5. using System.Threading.Tasks;
7. public class MultiThreadedApp
8. {
9.     private static readonly object _lock = new object();
10.    
11.     public static void Main()
12.     {
13.         // 配置Trace监听器
14.         Trace.Listeners.Add(new ConsoleTraceListener());
15.         Trace.AutoFlush = true;
17.         // 启动多个任务
18.         Task[] tasks = new Task[5];
19.         for (int i = 0; i < 5; i++)
20.         {
21.             int taskNum = i;
22.             tasks[i] = Task.Run(() => ProcessData(taskNum));
23.         }
25.         // 等待所有任务完成
26.         Task.WaitAll(tasks);
27.         Console.WriteLine("All tasks completed");
28.     }
30.     private static void ProcessData(int taskNum)
31.     {
32.         // 使用CorrelationManager跟踪活动
33.         Trace.CorrelationManager.ActivityId = Guid.NewGuid();
34.         Trace.CorrelationManager.StartLogicalOperation($"Task{taskNum}");
36.         try
37.         {
38.             Trace.WriteLine($"Task {taskNum} started on thread {Thread.CurrentThread.ManagedThreadId}");
40.             // 模拟工作
41.             for (int i = 0; i < 5; i++)
42.             {
43.                 // 线程安全的日志记录
44.                 lock (_lock)
45.                 {
46.                     Trace.WriteLine($"Task {taskNum}, Step {i}");
47.                 }
48.                 Thread.Sleep(100);
49.             }
51.             Trace.WriteLine($"Task {taskNum} completed");
52.         }
53.         finally
54.         {
55.             Trace.CorrelationManager.StopLogicalOperation();
56.         }
57.     }
58. }

复制代码

性能考虑和优化

日志记录的性能影响

日志记录可能会对应用程序性能产生影响，特别是在高负载或高频日志记录的情况下。以下是一些性能考虑因素：

使用异步日志记录可以减少I/O操作对主线程的影响。

2. using System.Threading.Tasks;
3. using NLog;
5. public class AsyncLoggingExample
6. {
7.     private static readonly Logger Logger = LogManager.GetCurrentClassLogger();
9.     public static async Task ProcessDataAsync()
10.     {
11.         Logger.Info("Starting async processing");
12.         
13.         // 模拟异步工作
14.         await Task.Delay(100);
15.         
16.         Logger.Info("Async processing completed");
17.     }
18. }

复制代码

在记录复杂或耗时的日志消息前，检查日志级别是否启用。

2. using Microsoft.Extensions.Logging;
4. public class ConditionalLoggingExample
5. {
6.     private readonly ILogger<ConditionalLoggingExample> _logger;
8.     public ConditionalLoggingExample(ILogger<ConditionalLoggingExample> logger)
9.     {
10.         _logger = logger;
11.     }
13.     public void ProcessLargeData(LargeDataObject data)
14.     {
15.         _logger.LogInformation("Processing large data");
16.         
17.         // 在记录复杂对象前检查日志级别
18.         if (_logger.IsEnabled(LogLevel.Debug))
19.         {
20.             // 序列化大型对象可能很耗时
21.             _logger.LogDebug("Data details: {@Data}", data);
22.         }
23.         
24.         // 处理数据...
25.     }
26. }
28. public class LargeDataObject
29. {
30.     // 大型数据对象的属性
31. }

复制代码

批量日志记录可以减少I/O操作次数，提高性能。

2. using System;
3. using System.Collections.Generic;
4. using System.IO;
5. using System.Text;
7. public class BatchLoggingExample
8. {
9.     private readonly string _logFilePath;
10.     private readonly Queue<string> _logQueue;
11.     private readonly object _lock;
12.     private readonly int _batchSize;
13.     private readonly TimeSpan _flushInterval;
14.     private DateTime _lastFlushTime;
16.     public BatchLoggingExample(string logFilePath, int batchSize = 100, TimeSpan? flushInterval = null)
17.     {
18.         _logFilePath = logFilePath;
19.         _batchSize = batchSize;
20.         _flushInterval = flushInterval ?? TimeSpan.FromSeconds(5);
21.         _logQueue = new Queue<string>();
22.         _lock = new object();
23.         _lastFlushTime = DateTime.Now;
24.     }
26.     public void Log(string message)
27.     {
28.         lock (_lock)
29.         {
30.             _logQueue.Enqueue($"{DateTime.Now:yyyy-MM-dd HH:mm:ss} - {message}");
32.             // 检查是否需要刷新
33.             if (_logQueue.Count >= _batchSize ||
34.                 (DateTime.Now - _lastFlushTime) > _flushInterval)
35.             {
36.                 Flush();
37.             }
38.         }
39.     }
41.     public void Flush()
42.     {
43.         if (_logQueue.Count == 0)
44.             return;
46.         var sb = new StringBuilder();
47.         while (_logQueue.Count > 0)
48.         {
49.             sb.AppendLine(_logQueue.Dequeue());
50.         }
52.         File.AppendAllText(_logFilePath, sb.ToString());
53.         _lastFlushTime = DateTime.Now;
54.     }
55. }

复制代码

日志级别管理

合理使用日志级别可以减少不必要的日志记录，提高性能。

2. using Microsoft.Extensions.Logging;
4. public class LogLevelManagementExample
5. {
6.     private readonly ILogger<LogLevelManagementExample> _logger;
8.     public LogLevelManagementExample(ILogger<LogLevelManagementExample> logger)
9.     {
10.         _logger = logger;
11.     }
13.     public void ProcessData(string data)
14.     {
15.         // 始终记录重要信息
16.         _logger.LogInformation("Processing data");
18.         // 仅在开发环境记录详细信息
19.         _logger.LogDebug("Data details: {Data}", data);
21.         try
22.         {
23.             // 处理数据...
24.             
25.             // 记录成功信息，但仅在Info级别启用时
26.             if (_logger.IsEnabled(LogLevel.Information))
27.             {
28.                 _logger.LogInformation("Data processed successfully. Length: {Length}", data.Length);
29.             }
30.         }
31.         catch (Exception ex)
32.         {
33.             // 始终记录错误
34.             _logger.LogError(ex, "Error processing data");
35.             throw;
36.         }
37.     }
38. }

复制代码

结构化日志 vs. 纯文本日志

结构化日志（如JSON格式）虽然可能占用更多空间，但提供了更好的查询和分析能力。

2. using Serilog;
3. using System;
4. using System.Collections.Generic;
6. public class StructuredLoggingExample
7. {
8.     public static void Main()
9.     {
10.         Log.Logger = new LoggerConfiguration()
11.             .WriteTo.Console()
12.             .WriteTo.File("logs/structured.json", formatter: new Serilog.Formatting.Json.JsonFormatter())
13.             .CreateLogger();
15.         // 记录结构化日志
16.         var order = new
17.         {
18.             Id = 12345,
19.             Customer = "John Doe",
20.             Items = new[] { "Item1", "Item2", "Item3" },
21.             Total = 99.99,
22.             Date = DateTime.Now
23.         };
25.         Log.Information("Order processed: {@Order}", order);
27.         // 记录带有上下文的信息
28.         Log.ForContext("Department", "Sales")
29.            .ForContext("UserId", "user123")
30.            .Information("User action: {Action} on {Target}", "Update", "Order");
32.         Log.CloseAndFlush();
33.     }
34. }

复制代码

日志轮转和清理

长时间运行的应用程序需要适当的日志轮转和清理机制，以防止日志文件占用过多磁盘空间。

2. using System;
3. using System.IO;
4. using System.Linq;
6. public class LogRotationExample
7. {
8.     private readonly string _logDirectory;
9.     private readonly string _logFilePrefix;
10.     private readonly int _maxLogFiles;
11.     private readonly long _maxLogFileSize;
13.     public LogRotationExample(string logDirectory, string logFilePrefix, int maxLogFiles = 10, long maxLogFileSize = 10 * 1024 * 1024)
14.     {
15.         _logDirectory = logDirectory;
16.         _logFilePrefix = logFilePrefix;
17.         _maxLogFiles = maxLogFiles;
18.         _maxLogFileSize = maxLogFileSize;
20.         // 确保日志目录存在
21.         Directory.CreateDirectory(logDirectory);
22.     }
24.     public void Log(string message)
25.     {
26.         // 获取当前日志文件路径
27.         string currentLogPath = GetCurrentLogFilePath();
29.         // 检查当前日志文件是否存在以及是否超过大小限制
30.         if (File.Exists(currentLogPath) && new FileInfo(currentLogPath).Length > _maxLogFileSize)
31.         {
32.             // 轮转日志文件
33.             RotateLogFiles();
34.             currentLogPath = GetCurrentLogFilePath();
35.         }
37.         // 写入日志
38.         File.AppendAllText(currentLogPath, $"{DateTime.Now:yyyy-MM-dd HH:mm:ss} - {message}{Environment.NewLine}");
39.     }
41.     private string GetCurrentLogFilePath()
42.     {
43.         return Path.Combine(_logDirectory, $"{_logFilePrefix}_current.log");
44.     }
46.     private void RotateLogFiles()
47.     {
48.         // 删除最旧的日志文件（如果超过最大数量）
49.         var logFiles = Directory.GetFiles(_logDirectory, $"{_logFilePrefix}_*.log")
50.                                .OrderBy(f => f)
51.                                .ToList();
53.         while (logFiles.Count >= _maxLogFiles)
54.         {
55.             File.Delete(logFiles[0]);
56.             logFiles.RemoveAt(0);
57.         }
59.         // 重命名当前日志文件
60.         string currentLogPath = GetCurrentLogFilePath();
61.         string timestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
62.         string archivedLogPath = Path.Combine(_logDirectory, $"{_logFilePrefix}_{timestamp}.log");
64.         if (File.Exists(currentLogPath))
65.         {
66.             File.Move(currentLogPath, archivedLogPath);
67.         }
68.     }
69. }

复制代码

总结

本文全面介绍了C#中输出窗口信息显示的各种方法，从基础的Console.WriteLine到高级的Debug调试技巧。我们探讨了以下关键内容：

1. 基础输出方法：详细介绍了Console.WriteLine及其相关方法，包括格式化输出、颜色设置和窗口操作。
2. 调试输出：深入讲解了Debug和Trace类的使用，包括配置、输出级别和性能分析。
3. 高级调试技巧：探讨了条件编译、Conditional特性、Debugger类的高级用法等。
4. 日志记录框架：比较和介绍了NLog、log4net和Serilog等流行日志框架的使用方法。
5. 实际应用案例：提供了不同场景下的最佳实践，包括控制台应用、ASP.NET Core应用、桌面应用、库和API以及多线程应用中的日志记录。
6. 性能考虑和优化：讨论了日志记录的性能影响，以及如何通过异步日志记录、条件日志记录、批量日志记录等技术优化性能。

基础输出方法：详细介绍了Console.WriteLine及其相关方法，包括格式化输出、颜色设置和窗口操作。

调试输出：深入讲解了Debug和Trace类的使用，包括配置、输出级别和性能分析。

高级调试技巧：探讨了条件编译、Conditional特性、Debugger类的高级用法等。

日志记录框架：比较和介绍了NLog、log4net和Serilog等流行日志框架的使用方法。

实际应用案例：提供了不同场景下的最佳实践，包括控制台应用、ASP.NET Core应用、桌面应用、库和API以及多线程应用中的日志记录。

性能考虑和优化：讨论了日志记录的性能影响，以及如何通过异步日志记录、条件日志记录、批量日志记录等技术优化性能。

通过掌握这些技术和方法，开发者可以更有效地输出和显示信息，提高调试效率，增强应用程序的可维护性和可监控性。无论是简单的控制台应用程序还是复杂的企业级系统，合理的输出和日志策略都是成功开发和维护软件的关键因素。

在实际开发中，应根据应用程序的需求、性能要求和运行环境选择合适的输出和日志记录方法。同时，始终记住日志记录的目的是为了帮助开发和运维人员更好地理解和维护系统，因此应保持日志信息的清晰、相关和可操作。