.NET 9使用Nlog

1.安装Nlog包

dotnet add package NLog

2.配置Nlog 配置文件

在项目根目录创建 NLog.config 文件，用于定义日志目标和规则

右键 NLog.config 文件，选择属性，将复制到输出目录设置为 如果较新则复制。

配置文件的重要参数结构说明

nlog.config 配置文件案例

<?xml version="1.0" encoding="utf-8" ?>
<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      autoReload="true"
      throwExceptions="false"
      internalLogLevel="Warn"
      internalLogFile="internal-nlog.log">

  <!-- 全局变量（可选） -->
  <variable name="logDir" value="${basedir}/logs" />
  <variable name="appName" value="MyApp" />

  <!-- 目标（Targets）定义 -->
  <targets>
    <!-- 1. 控制台输出（适合开发调试） -->
    <target name="console" xsi:type="Console"
            layout="${longdate} | ${level:uppercase=true:padding=5} | ${logger} | ${message} ${exception:format=tostring}" />

    <!-- 2. 文件输出 - 按天归档，自动删除7天前日志 -->
    <target name="file" xsi:type="AsyncWrapper" queueLimit="5000" overflowAction="Discard">
      <target xsi:type="File"
              fileName="${logDir}/${appName}_${shortdate}.log"
              layout="${longdate} | ${level:uppercase=true:padding=5} | ${logger} | ${message} ${exception:format=tostring}"
              archiveEvery="Day"
              archiveNumbering="Rolling"
              archiveFileName="${logDir}/archives/${appName}_{#}.log"
              archiveDateFormat="yyyy-MM-dd"
              maxArchiveDays="7"
              enableFileDelete="true"
              createDirs="true"
              keepFileOpen="false"
              concurrentWrites="true" />
    </target>

    <!-- 3. 错误日志专用文件（包含异常堆栈） -->
    <target name="errorFile" xsi:type="AsyncWrapper">
      <target xsi:type="File"
              fileName="${logDir}/${appName}_error_${shortdate}.log"
              layout="${longdate} | ${level:uppercase=true} | ${message} ${exception:format=tostring:maxInnerExceptionLevel=5}"
              archiveEvery="Day"
              maxArchiveDays="7"
              enableFileDelete="true"
              createDirs="true" />
    </target>
  </targets>

  <!-- 规则（Rules）定义：决定哪些 Logger 名称、哪些级别，写入哪些目标 -->
  <rules>
    <!-- 记录所有级别的日志到控制台（开发环境用） -->
    <logger name="*" minlevel="Trace" writeTo="console" />

    <!-- 记录Info及以上级别到普通日志文件 -->
    <logger name="*" minlevel="Info" writeTo="file" />

    <!-- 记录Error及以上级别到错误日志文件 -->
    <logger name="*" minlevel="Error" writeTo="errorFile" />

    <!-- 排除特定命名空间的冗余日志（可选） -->
    <logger name="Microsoft.*" maxlevel="Info" final="true" />
  </rules>
</nlog>

以上配置,生成的文件结构示例
logs/
├── MyApp_2025-11-19.log # 当前日志文件
└── archives/
├── MyApp_2025-11-12.log # 7天前的归档文件（已自动删除）
└── MyApp_2025-11-18.log # 昨日归档文件
logs/
├── MyApp_error_2025-11-19.log # 当前错误日志

2.1 如果要设置异步的写入， targets 节点下的 target需要定义2级
例如:

<targets>
  <target  name="onlyfile"  xsi:type="AsyncWrapper" queueLimit="5000" overflowAction="Discard">
    <target xsi:type="File"
          fileName="Onlylogs/OnlyFile_${shortdate}.log"
          layout="${longdate}|${level:uppercase=true}|${message}${onexception:${newline}${exception:format=tostring}}${newline}"
          archiveEvery="Day"
          archiveNumbering="Rolling"
          maxArchiveDays="7"
          archiveAboveSize="5242880"
          enableFileDelete="true" 
          keepFileOpen="false"
          concurrentWrites="true" />
  </target>
  </targets>

  <rules>
    <logger name="*" minlevel="Info"  writeTo="logfile" />
    <logger name="*" minlevel="Warn"  writeTo="warnfile" />
    <logger name="*" minlevel="Error"  writeTo="errfile" />
  </rules>

rules 规则 在NLog的配置中， minlevel属性不是“排除低于该级别的日志”，而是“包含等于或高于该级别的日志”。如上面的配置会导致日志被重复写入多个目标文件，具体规则如下：

实际测试效果示例

总结上面配置意思：

当我们在程序中实例化NLog.Logger，例如:

NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();

然后进行日志记录的时候，例如:

logger.Warn("我的第一条日志")

该日志就会被 rules 规则 第一条 minlevel="Info"和第二条 minlevel="Warn" 所匹配到。由上匹配规则表可以看出， minlevel="Info"能匹配到Warn级别的日志， minlevel="Warn"也能匹配到 Warn级别的日志。所以当前打印的日志，就会被2个规则匹配，从而记录到 writeTo="logfile" 和 writeTo="warnfile" 这2个日志文件当中。

在C# 代码中，使用的案例

dotnet add package NLog.Extensions.Logging
dotnet add package NLog.Web.AspNetCore

using NLog;

public class MyService
{
    private static readonly ILogger Logger = LogManager.GetCurrentClassLogger();

    public void DoWork()
    {
        Logger.Trace("Trace message");
        Logger.Debug("Debug message");
        Logger.Info("Application started");
        
        try
        {
            // ...
            throw new InvalidOperationException("Oops");
        }
        catch (Exception ex)
        {
            Logger.Error(ex, "Unhandled exception in DoWork");
        }
    }
}

<rules>
  <!-- 优先匹配高优先级日志，匹配后终止后续规则 -->
  <logger name="*" minlevel="Error" writeTo="errfile" final="true"/>
  <logger name="*" minlevel="Warn" writeTo="warnfile" final="true"/>
  <logger name="*" minlevel="Info" writeTo="logfile"/>
</rules>

这样就实现了，Warn 级别的日志，只会出现在 warnfile 的日志文件中，而不会出现在logfile 的日志文件中。

方案一：规则内嵌条件过滤（推荐）

通过在 <logger>规则中直接添加 condition属性实现精准过滤，无需依赖 final属性。例如：

    <rules>
      <!-- Info日志仅写入logfile -->
      <logger name="*" minlevel="Info" writeTo="logfile" 
              condition="level == LogLevel.Info" />
      
      <!-- Warn日志仅写入warnfile -->
      <logger name="*" minlevel="Warn" writeTo="warnfile" 
              condition="level == LogLevel.Warn" />
      
      <!-- Error日志仅写入errfile -->
      <logger name="*" minlevel="Error" writeTo="errfile" 
              condition="level == LogLevel.Error" />
    </rules>

优势：

方案二：目标内嵌级别过滤器

在 <target>定义中通过 layout或 filters实现级别过滤，例如：

<targets>
      <!-- logfile目标仅接收Info日志 -->
      <target name="logfile" xsi:type="File" 
              layout="${longdate}|${message}" 
              fileName="logs/info.log">
        <filter type="Condition" condition="level == LogLevel.Info" />
      </target>
      
      <!-- warnfile目标仅接收Warn日志 -->
      <target name="warnfile" xsi:type="File" 
              layout="${longdate}|${message}" 
              fileName="logs/warn.log">
        <filter type="Condition" condition="level == LogLevel.Warn" />
      </target>
    </targets>

    <rules>
      <!-- 单条规则覆盖所有级别 -->
      <logger name="*" minlevel="Info" writeTo="logfile,warnfile,errfile" />
    </rules>

优势：

方案三：日志路由拆分（高级场景）

通过 <logger>的 name属性结合命名空间隔离，实现物理日志源隔离：

l<rules>
      <!-- 专用Info日志记录器 -->
      <logger name="InfoLogger.*" minlevel="Info" writeTo="logfile" final="true" />
      
      <!-- 专用Warn日志记录器 -->
      <logger name="WarnLogger.*" minlevel="Warn" writeTo="warnfile" final="true" />
      
      <!-- 专用Error日志记录器 -->
      <logger name="ErrorLogger.*" minlevel="Error" writeTo="errfile" final="true" />
    </rules>

需要在代码中需显式使用对应记录器：

    // C#代码示例
    var infoLogger = NLog.LogManager.GetLogger("InfoLogger.Namespace");
    var warnLogger = NLog.LogManager.GetLogger("WarnLogger.Namespace");
    var errorLogger = NLog.LogManager.GetLogger("ErrorLogger.Namespace");

适用场景：

3. Nlog 案例,使用方案3实现

要求：对于不同业务类型的处理逻辑生成的日志，需分别存储到对应的独立日志目录中。所有日志输出必须严格保持时序性，确保在多线程环境下不会出现日志内容交叉打印的情况（即每个线程产生的日志条目始终按照程序逻辑的执行顺序完整输出）。

<?xml version="1.0" encoding="utf-8" ?>
<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://www.nlog-project.org/schemas/NLog.xsd NLog.xsd"
      autoReload="true"
      throwExceptions="false"
      internalLogLevel="Off" internalLogFile="c:	emp
log-internal.log">
      
  <targets>
    <!-- only设备日志配置, -->
    <target  name="onlyfile"  xsi:type="AsyncWrapper" queueLimit="5000" overflowAction="Discard">
      <target xsi:type="File"
            fileName="Onlylogs/OnlyFile_${shortdate}.log"
            layout="${longdate}|${level:uppercase=true}|${message}${onexception:${newline}${exception:format=tostring}}${newline}"
            archiveEvery="Day"
            archiveNumbering="Rolling"
            maxArchiveDays="7"
            archiveAboveSize="5242880"
            enableFileDelete="true" 
            keepFileOpen="false"
            concurrentWrites="true" />
    </target>
    <!-- line设备日志配置, -->
    <target  name="linefile"  xsi:type="AsyncWrapper" queueLimit="5000" overflowAction="Discard">
      <target xsi:type="File"
            fileName="Linelogs/LineFile_${shortdate}.log"
            layout="${longdate}|${level:uppercase=true}|${message}${onexception:${newline}${exception:format=tostring}}${newline}"
            archiveEvery="Day"
            archiveNumbering="Rolling"
            maxArchiveDays="7"
            archiveAboveSize="5242880"
            enableFileDelete="true"
            keepFileOpen="false"
            concurrentWrites="true" />
    </target>
    <!-- stacker设备日志配置, -->
    <target  name="stackerfile"  xsi:type="AsyncWrapper" queueLimit="5000" overflowAction="Discard">
      <target xsi:type="File"
            fileName="Stackerlogs/StackerFile_${shortdate}.log"
            layout="${longdate}|${level:uppercase=true}|${message}${onexception:${newline}${exception:format=tostring}}${newline}"
            archiveEvery="Day"
            archiveNumbering="Rolling"
            maxArchiveDays="7"
            archiveAboveSize="5242880"
            enableFileDelete="true"
            keepFileOpen="false"
            concurrentWrites="true" />
    </target>
    <!-- other日志配置, -->
    <target  name="otherfile"  xsi:type="AsyncWrapper" queueLimit="5000" overflowAction="Discard">
      <target xsi:type="File"
            fileName="Otherlogs/OtherFile_${shortdate}.log"
            layout="${longdate}|${level:uppercase=true}|${message}${onexception:${newline}${exception:format=tostring}}${newline}"
            archiveEvery="Day"
            archiveNumbering="Rolling"
            maxArchiveDays="7"
            archiveAboveSize="5242880"
            enableFileDelete="true"
            keepFileOpen="false"
            concurrentWrites="true" />
    </target>
    <target  name="errfile"  xsi:type="AsyncWrapper" queueLimit="5000" overflowAction="Discard">
      <!-- err_file 配置 -->
      <target xsi:type="File"
              fileName="Errorlogs/ErrorFile_${shortdate}.log"
              layout="${longdate}|${level:uppercase=true}|${message}${onexception:${newline}${exception:format=tostring}}${newline}"
              archiveEvery="Day"
              archiveNumbering="Rolling"
              archiveAboveSize="5242880"
              enableFileDelete="true"
              maxArchiveDays="7"
              keepFileOpen="false"
              concurrentWrites="true" />
    </target>

  </targets>
  <rules>
    <!-- 专用Only设备日志记录器 -->
    <logger name="OnlyInfoLogger.*" minlevel="Info" writeTo="onlyfile" final="true" />

    <!-- 专用Line日志记录器 -->
    <logger name="LineInfoLogger.*" minlevel="Info" writeTo="linefile" final="true" />

    <!-- 专用Stacker日志记录器 -->
    <logger name="StackerInfoLogger.*" minlevel="Info" writeTo="stackerfile" final="true" />

    <!-- 专用Error日志记录器 -->
    <logger name="ErrorLogger.*" minlevel="Error" writeTo="errfile" final="true" />

    <!-- 其他日志记录器,默认 -->
    <logger name="OtherLogger.*" minlevel="Info" writeTo="otherfile" final="true" />
  </rules>
</nlog>

public enum MessageLevel
{
    Debug = 1,
    Info = 2,
    Warning = 3,
    Error = 4,
}
public class ExceptionLog : Exception, IDisposable
{
    private struct MyStruct
    {
        public MessageLevel Level;
        public DateTime CreateDate;
        public string? MethodPath;
        public string Message;
    }
    private readonly DateTime _createDate;
    private readonly List<MyStruct> _myLogs;
    private readonly string? _method_name;

    // 每个实例的 logger 名称与实例 ID（用于区分多个实例）
    private readonly string _loggerName;
    private readonly Guid _instanceId;
    // private static readonly NLog.Logger _logger = LogManager.GetCurrentClassLogger();
    // 用于序列化日志块并保持顺序，队列元素包含 loggerName 与 instanceId
    private static readonly BlockingCollection<(string LoggerName, LogLevel Level, string Message, Guid InstanceId)> _logQueue = new();
    private static readonly Task _logWorker;

    static ExceptionLog()
    {
        // 启动按顺序写入日志的后台工作程序
        _logWorker = Task.Run(() =>
        {
            try
            {
                foreach (var item in _logQueue.GetConsumingEnumerable())
                {
                    try
                    {
                        // 动态根据 loggerName 获取 Logger，并在消息前附加 InstanceId 以便区分来源实例
                        var logger = LogManager.GetLogger(item.LoggerName);
                        var messageWithId = $"[{item.InstanceId}] {item.Message}";
                        logger.Log(item.Level, messageWithId);
                    }
                    catch (Exception ex)
                    {
                        try { Debug.WriteLine($"NLog工作线程写入失败: {ex}"); } catch { }
                    }
                }
            }
            catch (Exception ex)
            {
                try { Debug.WriteLine($"NLog线程已终止: {ex}"); } catch { }
            }
        });
    }

    // 新增构造函数：允许传入 loggerName
    public ExceptionLog(string? loggerName = null)
    {
        _createDate = DateTime.Now;
        _myLogs = new List<MyStruct>();
        _method_name = new StackTrace().GetFrame(1)?.GetMethod()?.DeclaringType?.FullName;
        _loggerName = string.IsNullOrWhiteSpace(loggerName) ? "ErrorLogger" : loggerName!;
        _instanceId = Guid.NewGuid();
    }

    public void AddLog(string message, MessageLevel level = MessageLevel.Debug)
    {
        _myLogs.Add(new MyStruct { Level = level, CreateDate = DateTime.Now, Message = message, MethodPath = new StackTrace().GetFrame(1)?.GetMethod()?.DeclaringType?.FullName });
    }
    public void AddLog(Exception exception, MessageLevel level = MessageLevel.Error)
    {
        _myLogs.Add(new MyStruct { Level = level, CreateDate = DateTime.Now, Message = exception.Message, MethodPath = new StackTrace().GetFrame(1)?.GetMethod()?.DeclaringType?.FullName });
    }

    public override string Message => _myLogs.LastOrDefault().Message;

    private void WriteLog()
    {
        if (_myLogs.Count == 0) return;

        var maxLevel = _myLogs.Select(x => x.Level).Max();

        var sb = new StringBuilder();
        sb.AppendLine($"[开始] {_createDate.ToDateTimeMillisecond()} {_method_name}");

        _myLogs.ForEach(a =>
        {
            if ( maxLevel == MessageLevel.Error || (maxLevel != MessageLevel.Error && a.Level != MessageLevel.Debug))
            {
                sb.AppendLine($"[{a.Level}] {a.CreateDate.ToDateTimeMillisecond()} {a.Message}");
            }
        });

        sb.AppendLine($"[结束] {DateTime.Now.ToDateTimeMillisecond()} {_method_name}");

        var message = sb.ToString();
        var nlogLevel = MapToNLogLevel(maxLevel);

        // 对聚合消息进行排队，以保留块顺序并避免交织
        try
        {
            _logQueue.Add((_loggerName, nlogLevel, message, _instanceId));
        }
        catch (Exception ex)
        {
            try { Debug.WriteLine($"日志入队失败: {ex}"); } catch { }
        }
    }

    private static LogLevel MapToNLogLevel(MessageLevel level)
    {
        return level switch
        {
            MessageLevel.Debug => LogLevel.Debug,
            MessageLevel.Info => LogLevel.Info,
            MessageLevel.Warning => LogLevel.Warn,
            MessageLevel.Error => LogLevel.Error,
            _ => LogLevel.Info,
        };
    }

    public void Dispose()
    {
        try
        {
            WriteLog();
            _myLogs.Clear();
        }
        catch (Exception ex)
        {
            try { Debug.WriteLine($"调用Dispose批量写日志抛出异常，错误原因: {ex}"); } catch { }
        }

    }
}

using (var exceptionLog = new ExceptionLog("OnlyInfoLogger.Namespace"))
{
    var watch = Stopwatch.StartNew();
    try
    {                                   
        exceptionLog.AddLog($"Only设备【{equ.EquipmentCode}】开始轮询。逻辑处理计时开始:", MessageLevel.Info);
        PolicyLogic(equ,exceptionLog).ConfigureAwait(false).GetAwaiter().GetResult();
    }
    catch (Exception ex)
    {
        exceptionLog.AddLog($"Only设备[{equ.EquipmentCode}]轮询异常:{ex.Message}",MessageLevel.Info);
    }
    finally
    {
        mutex.ReleaseMutex();
        watch.Stop();
        exceptionLog.AddLog($"Only设备【{equ.EquipmentCode}】轮询结束。逻辑处理计时结束，耗时:{watch.ElapsedMilliseconds}", MessageLevel.Info);
    }
} 

在ExceptionLog中，需明确传入并使用相应的日志记录器

最后效果：