.NET日志框架设计与实现：从基础到高性能优化

1. 日志框架的核心价值与设计哲学

日志系统是现代软件开发中不可或缺的基础设施，就像飞机的黑匣子记录着每一次飞行的关键数据。在.NET生态中，日志框架承担着三大核心职责：记录运行时状态、辅助问题诊断、提供审计追踪。一个好的日志系统应当像经验丰富的机务人员，既能快速定位故障点，又能通过历史数据分析潜在风险。

我见过太多团队在项目后期才匆忙引入日志系统，结果不得不面对海量代码的改造。实际上，日志设计应该与业务架构同步进行。主流日志框架如NLog、Serilog、log4net等都遵循着相似的设计范式：

1. 分层日志级别（Trace/Debug/Info/Warn/Error/Fatal）
2. 结构化日志模板
3. 可扩展的输出渠道（文件/数据库/ELK等）
4. 异步非阻塞写入
5. 上下文关联能力

这些设计理念背后是多年实践积累的最佳方案。比如异步写入机制，我在处理一个高并发电商系统时实测发现，同步写日志会使QPS下降30%，而采用内存队列+批量写入的方案几乎不影响主流程性能。

2. 手写日志框架的实战教学

2.1 基础架构设计

让我们从零开始构建一个轻量级日志框架。核心接口设计应该遵循SOLID原则，这是我的推荐方案：

csharp复制public interface ILogger
{
    void Log(LogLevel level, string message, Exception ex = null);
    bool IsEnabled(LogLevel level);
}

public abstract class LoggerBase : ILogger
{
    private readonly LogLevel _minLevel;
    
    protected LoggerBase(LogLevel minLevel) {
        _minLevel = minLevel;
    }
    
    public void Log(LogLevel level, string message, Exception ex = null) {
        if(!IsEnabled(level)) return;
        
        var entry = new LogEntry {
            Timestamp = DateTime.UtcNow,
            Level = level,
            Message = message,
            Exception = ex
        };
        
        WriteLog(entry);
    }
    
    protected abstract void WriteLog(LogEntry entry);
    
    public bool IsEnabled(LogLevel level) => level >= _minLevel;
}

这个基础架构实现了：

• 日志级别过滤
• 线程安全写入（由具体实现保证）
• 扩展点（WriteLog抽象方法）
• 时间戳标准化

2.2 核心功能实现

2.2.1 文件日志实现

文件存储是最常见的需求，这里有个生产可用的实现示例：

csharp复制public class FileLogger : LoggerBase
{
    private readonly string _filePath;
    private readonly object _lock = new object();
    
    public FileLogger(string filePath, LogLevel minLevel) 
        : base(minLevel) {
        _filePath = filePath;
        EnsureDirectoryExists();
    }
    
    protected override void WriteLog(LogEntry entry) {
        lock(_lock) {
            File.AppendAllText(_filePath, FormatEntry(entry) + Environment.NewLine);
        }
    }
    
    private string FormatEntry(LogEntry entry) {
        var sb = new StringBuilder();
        sb.Append($"[{entry.Timestamp:yyyy-MM-dd HH:mm:ss.fff}]");
        sb.Append($" [{entry.Level.ToString().ToUpper()}]");
        sb.Append($" {entry.Message}");
        
        if(entry.Exception != null) {
            sb.AppendLine();
            sb.Append($"EXCEPTION: {entry.Exception}");
        }
        
        return sb.ToString();
    }
    
    private void EnsureDirectoryExists() {
        var dir = Path.GetDirectoryName(_filePath);
        if(!Directory.Exists(dir)) {
            Directory.CreateDirectory(dir);
        }
    }
}

关键点说明：

1. 使用lock保证线程安全（实测比文件流方案性能更好）
2. 自动创建目录结构
3. 异常信息特殊处理
4. 时间格式包含毫秒级精度

2.2.2 性能优化技巧

在高并发场景下，我推荐采用生产者-消费者模式：

csharp复制public class AsyncLogger : LoggerBase
{
    private readonly BlockingCollection<LogEntry> _queue;
    private readonly Task _processingTask;
    
    public AsyncLogger(ILogger innerLogger, int maxQueueSize = 1000) 
        : base(innerLogger.MinLevel) {
        _queue = new BlockingCollection<LogEntry>(maxQueueSize);
        _processingTask = Task.Run(ProcessQueue);
        
        AppDomain.CurrentDomain.ProcessExit += (s, e) => {
            _queue.CompleteAdding();
            _processingTask.Wait(TimeSpan.FromSeconds(5));
        };
    }
    
    protected override void WriteLog(LogEntry entry) {
        if(!_queue.TryAdd(entry, millisecondsTimeout: 100)) {
            // 队列满时的降级策略
            Console.WriteLine($"Log queue full! Dropping: {entry.Message}");
        }
    }
    
    private void ProcessQueue() {
        foreach(var entry in _queue.GetConsumingEnumerable()) {
            try {
                _innerLogger.Log(entry);
            } catch {
                // 防止日志循环崩溃
            }
        }
    }
}

这个实现包含几个重要特性：

• 限制队列大小防止内存溢出
• 进程退出时优雅关闭
• 队列满时的降级处理
• 后台线程消费模式

3. 高级功能实现

3.1 结构化日志

现代日志系统越来越倾向于结构化数据，这是支持ELK等分析系统的关键：

csharp复制public void Log<TState>(LogLevel level, EventId eventId, TState state, 
    Exception exception, Func<TState, Exception, string> formatter)
{
    if(!IsEnabled(level)) return;
    
    var json = JsonSerializer.Serialize(new {
        Timestamp = DateTime.UtcNow,
        Level = level,
        Message = formatter(state, exception),
        Exception = exception?.ToString(),
        Properties = state as IDictionary<string, object>
    });
    
    WriteLine(json);
}

3.2 上下文传播

实现类似Log4J的MDC（Mapped Diagnostic Context）功能：

csharp复制public class ContextLogger
{
    private static readonly AsyncLocal<Dictionary<string, object>> _context 
        = new AsyncLocal<Dictionary<string, object>>();
        
    public static IDisposable BeginScope(Dictionary<string, object> context) {
        _context.Value = context;
        return new DisposableScope();
    }
    
    private class DisposableScope : IDisposable {
        public void Dispose() {
            _context.Value = null;
        }
    }
    
    // 在日志输出时合并上下文
    private string FormatWithContext(string message) {
        if(_context.Value == null) return message;
        
        var sb = new StringBuilder(message);
        foreach(var kv in _context.Value) {
            sb.AppendLine();
            sb.Append($"{kv.Key}={kv.Value}");
        }
        return sb.ToString();
    }
}

4. 生产环境经验分享

4.1 性能优化实战

在金融级系统中，我们通过以下优化将日志性能提升5倍：

1. 使用ObjectPool复用StringBuilder
2. 预分配文件空间
3. 批量写入替代单条写入
4. 避免频繁的锁竞争

csharp复制public class HighPerformanceLogger : LoggerBase
{
    private readonly ObjectPool<StringBuilder> _builderPool;
    private readonly Timer _flushTimer;
    private readonly ConcurrentQueue<string> _batchQueue = new();
    
    public HighPerformanceLogger(string filePath) 
        : base(LogLevel.Information) {
        _builderPool = new DefaultObjectPool<StringBuilder>(
            new StringBuilderPooledPolicy());
            
        _flushTimer = new Timer(_ => FlushBatch(), 
            null, 
            TimeSpan.FromSeconds(5), 
            TimeSpan.FromSeconds(5));
    }
    
    protected override void WriteLog(LogEntry entry) {
        var builder = _builderPool.Get();
        try {
            FormatEntry(builder, entry);
            _batchQueue.Enqueue(builder.ToString());
        } finally {
            _builderPool.Return(builder);
        }
    }
    
    private void FlushBatch() {
        const int batchSize = 100;
        var lines = new List<string>(batchSize);
        
        while(lines.Count < batchSize && _batchQueue.TryDequeue(out var line)) {
            lines.Add(line);
        }
        
        if(lines.Count > 0) {
            File.AppendAllLines(_filePath, lines);
        }
    }
}

4.2 常见问题排查指南

问题1：日志文件无限增长

• 解决方案：实现日志轮转策略

csharp复制private void RotateFilesIfNeeded() {
    var fileInfo = new FileInfo(_filePath);
    if(fileInfo.Exists && fileInfo.Length > 100 * 1024 * 1024) {
        string archivePath = $"{_filePath}.{DateTime.Now:yyyyMMddHHmmss}";
        File.Move(_filePath, archivePath);
    }
}

问题2：日志丢失

• 可能原因：进程崩溃时内存队列未持久化
• 解决方案：定期检查点+启动时恢复

问题3：日志格式混乱

• 最佳实践：采用固定格式模板
• 推荐使用类似Serilog的MessageTemplate语法

5. 与现有框架集成

5.1 适配Microsoft.Extensions.Logging

要让自定义日志器融入.NET Core生态，需要实现ILoggerProvider：

csharp复制public class CustomLoggerProvider : ILoggerProvider
{
    private readonly ConcurrentDictionary<string, CustomLogger> _loggers = new();
    
    public ILogger CreateLogger(string categoryName) {
        return _loggers.GetOrAdd(categoryName, name => new CustomLogger(name));
    }
    
    public void Dispose() {
        _loggers.Clear();
    }
}

// 注册方式
services.AddLogging(builder => {
    builder.AddProvider(new CustomLoggerProvider());
    builder.SetMinimumLevel(LogLevel.Debug);
});

5.2 性能对比测试

在我的基准测试中（i7-11800H, 32GB RAM）：

这个结果说明，合理设计的手写日志框架完全可以达到甚至超越主流框架的性能。