.NET日志框架核心原理与实战优化指南

1. .NET日志框架核心原理剖析

在.NET生态中，日志记录是系统可观测性的基石。现代日志框架通常由四大核心组件构成：

1. 日志记录器(Logger)：负责接收日志消息的入口点，提供不同日志级别（Debug、Info、Warning等）的API。以ILogger接口为例，其典型实现包含：

csharp复制public interface ILogger
{
    void Log<TState>(LogLevel logLevel, EventId eventId, TState state, 
                    Exception exception, Func<TState, Exception, string> formatter);
    bool IsEnabled(LogLevel logLevel);
    IDisposable BeginScope<TState>(TState state);
}

2. 日志提供程序(Provider)：将格式化后的日志输出到不同目标（控制台、文件、数据库等）。例如文件提供程序的核心逻辑包含：

csharp复制public class FileLoggerProvider : ILoggerProvider
{
    private readonly StreamWriter _writer;
    
    public FileLoggerProvider(string filePath) 
    {
        _writer = new StreamWriter(filePath, append: true);
    }
    
    public ILogger CreateLogger(string categoryName) => new FileLogger(_writer);
    
    public void Dispose() => _writer.Dispose();
}

3. 日志过滤器(Filter)：根据命名空间、日志级别等条件控制日志输出。过滤规则通常通过配置实现：

json复制{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "System": "Warning",
      "Microsoft": "Error"
    }
  }
}

4. 日志格式化器(Formatter)：将日志数据转换为特定格式（JSON、文本等）。例如简单文本格式化：

csharp复制string FormatLog(LogLevel level, string message, Exception ex)
{
    return $"[{DateTime.Now:yyyy-MM-dd HH:mm:ss}] [{level}] {message}" + 
           (ex != null ? $"\n{ex}" : "");
}

关键设计原则：通过接口抽象各组件，使日志记录、处理和输出解耦，这是所有现代日志框架的共通架构思想。

2. 手写简易日志框架实战

2.1 基础架构搭建

我们从零实现一个支持多输出的日志框架：

1. 定义核心接口：

csharp复制public interface ICustomLogger
{
    void Log(LogLevel level, string message, Exception ex = null);
    void AddProvider(ILogProvider provider);
}

public interface ILogProvider
{
    void WriteLog(LogEntry entry);
}

2. 实现内存日志提供程序：

csharp复制public class MemoryLogProvider : ILogProvider
{
    private readonly ConcurrentQueue<LogEntry> _logs = new();
    
    public void WriteLog(LogEntry entry)
    {
        _logs.Enqueue(entry);
        if (_logs.Count > 1000) _logs.TryDequeue(out _);
    }
    
    public IEnumerable<LogEntry> GetLogs() => _logs.ToArray();
}

2.2 实现异步批处理

为避免日志写入阻塞主线程，添加异步处理机制：

csharp复制public class AsyncLogProcessor : IDisposable
{
    private readonly BlockingCollection<LogEntry> _queue = new();
    private readonly CancellationTokenSource _cts = new();
    
    public AsyncLogProcessor()
    {
        Task.Run(() => ProcessLogs(_cts.Token));
    }
    
    private void ProcessLogs(CancellationToken token)
    {
        foreach (var entry in _queue.GetConsumingEnumerable(token))
        {
            foreach (var provider in entry.Providers)
            {
                try { provider.WriteLog(entry); }
                catch { /* 记录失败但不影响主流程 */ }
            }
        }
    }
    
    public void AddLog(LogEntry entry) => _queue.Add(entry);
    
    public void Dispose()
    {
        _cts.Cancel();
        _queue.CompleteAdding();
    }
}

2.3 实现日志作用域

模仿Serilog的LogContext，实现上下文信息传递：

csharp复制public class LogScope : IDisposable
{
    private static readonly AsyncLocal<Stack<LogScope>> _currentScope = new();
    
    public IDictionary<string, object> Properties { get; } = new Dictionary<string, object>();
    
    public LogScope() 
    {
        (_currentScope.Value ??= new Stack<LogScope>()).Push(this);
    }
    
    public static LogScope Current => _currentScope.Value?.Peek();
    
    public void Dispose() => _currentScope.Value?.Pop();
}

3. 性能优化关键技巧

3.1 结构化日志处理

传统字符串拼接方式存在性能瓶颈：

csharp复制// 不推荐：频繁字符串分配
logger.LogInfo($"User {userId} accessed {resource} at {DateTime.Now}");

改用结构化日志模板：

csharp复制// 推荐：预编译模板，运行时只传参数
logger.LogInfo("User {UserId} accessed {Resource} at {Timestamp}", 
              userId, resource, DateTime.Now);

实现原理：

csharp复制public class StructuredLogTemplate
{
    private readonly string _template;
    private readonly string[] _parameterNames;
    
    public StructuredLogTemplate(string messageTemplate)
    {
        // 解析类似 {UserId} 的占位符
        _parameterNames = ParseTemplate(messageTemplate, out _template);
    }
    
    public string Format(object[] parameters)
    {
        // 使用StringBuilder高效拼接
        var sb = new StringBuilder(_template);
        for (int i = 0; i < _parameterNames.Length; i++)
        {
            sb.Replace("{" + _parameterNames[i] + "}", parameters[i]?.ToString());
        }
        return sb.ToString();
    }
}

3.2 对象池技术应用

高频创建LogEntry对象会导致GC压力，采用对象池优化：

csharp复制public class LogEntryPool
{
    private readonly ConcurrentBag<LogEntry> _pool = new();
    
    public LogEntry Rent()
    {
        return _pool.TryTake(out var entry) ? entry : new LogEntry();
    }
    
    public void Return(LogEntry entry)
    {
        entry.Reset(); // 清理旧数据
        _pool.Add(entry);
    }
}

// 使用示例
var entry = _pool.Rent();
try
{
    entry.Level = LogLevel.Info;
    entry.Message = "Processing completed";
    _processor.AddLog(entry);
}
finally
{
    _pool.Return(entry);
}

4. 诊断与问题排查

4.1 常见问题速查表

4.2 高级诊断技巧

1. 使用Activity追踪日志链路：

csharp复制using var activity = new Activity("ProcessOrder");
activity.AddTag("OrderId", orderId);
logger.LogInfo("Starting order processing");

2. 动态日志级别调整：

csharp复制// 运行时动态提升日志级别
DiagnosticListener.AllListeners.Subscribe(new DynamicLogLevelObserver());

3. 关键日志采样：

csharp复制if (_sampler.ShouldSample()) // 基于随机或条件采样
{
    logger.LogDebug("Detailed trace data: {Data}", expensiveData);
}

5. 扩展设计模式

5.1 装饰器模式增强功能

在不修改核心代码情况下添加新功能：

csharp复制public class BufferedLoggerDecorator : ICustomLogger
{
    private readonly ICustomLogger _inner;
    private readonly List<LogEntry> _buffer = new();
    
    public BufferedLoggerDecorator(ICustomLogger inner) => _inner = inner;
    
    public void Log(LogLevel level, string message, Exception ex = null)
    {
        _buffer.Add(new LogEntry(level, message, ex));
        if (_buffer.Count >= 100) Flush();
    }
    
    public void Flush()
    {
        foreach (var entry in _buffer)
        {
            _inner.Log(entry.Level, entry.Message, entry.Exception);
        }
        _buffer.Clear();
    }
}

5.2 策略模式实现动态路由

根据日志内容动态选择输出目标：

csharp复制public class SmartRouter : ILogProvider
{
    private readonly Dictionary<Func<LogEntry, bool>, ILogProvider> _routes = new();
    
    public void AddRoute(Func<LogEntry, bool> predicate, ILogProvider provider)
    {
        _routes[predicate] = provider;
    }
    
    public void WriteLog(LogEntry entry)
    {
        foreach (var route in _routes)
        {
            if (route.Key(entry))
            {
                route.Value.WriteLog(entry);
                break;
            }
        }
    }
}

6. 生产环境最佳实践

1. 日志分级策略：

   • Debug：仅开发环境开启
   • Info：记录业务关键路径
   • Warning：预期内的异常情况
   • Error：需要干预的异常

2. 敏感信息过滤：

csharp复制public class SensitiveDataFilter : ILogProcessor
{
    private readonly string[] _patterns = { "password", "creditcard" };
    
    public LogEntry Process(LogEntry entry)
    {
        foreach (var pattern in _patterns)
        {
            entry.Message = Regex.Replace(entry.Message, $"{pattern}=[^&]+", $"{pattern}=***");
        }
        return entry;
    }
}

3. 日志切割方案：

csharp复制public class RollingFileProvider : ILogProvider
{
    private readonly string _basePath;
    private DateTime _currentDate;
    private StreamWriter _writer;
    
    public RollingFileProvider(string basePath)
    {
        _basePath = basePath;
        RollFile();
    }
    
    private void RollFile()
    {
        _writer?.Dispose();
        _currentDate = DateTime.Today;
        _writer = new StreamWriter($"{_basePath}-{_currentDate:yyyyMMdd}.log", append: true);
    }
    
    public void WriteLog(LogEntry entry)
    {
        if (DateTime.Today != _currentDate) RollFile();
        _writer.WriteLine(entry.ToString());
    }
}

在实现自定义日志框架时，建议先明确业务场景需求。对于中小型应用，直接使用成熟的Serilog或NLog可能是更经济的选择。但当需要深度定制日志处理流水线或学习框架设计原理时，从零开始构建无疑是最佳的学习路径。