NLog 入门

• 下载 NLog 源代码 - 1.28 MB
• 下载 NLog 帮助 - 1.23 MB
• 下载最新的 NLog 源代码和二进制包

引言

很久以前，当世界上还没有调试器，软件主要是基于控制台的时候，程序员们习惯于使用 `printf()` 语句输出跟踪消息。今天的世界技术已经取得了巨大的进步，`printf()` 已经被 `Console.WriteLine()` 取代。

我们都写过类似下面的代码

static void Main()
{
    Console.WriteLine("SuperApp started.");
    DoSomething();         
    Console.WriteLine("SuperApp finished.");
}

上面例子中的 `Console.WriteLine()` 语句被称为“跟踪语句”，因为它们仅用于报告我们应用程序的控制流，没有其他功能。`Console.WriteLine()` 的输出被称为程序跟踪。在这个例子中，跟踪语句产生的输出告诉我们 `DoSomething()` 方法是否已完成执行。

在对应用程序进行一些测试后，我们倾向于删除跟踪代码以提高性能（跟踪可能花费大量时间）。跟踪指令通常会被注释掉，以便将来可以重新启用。不幸的是，这需要重新编译我们的程序。

过了一段时间，在删除了几百次注释并重新添加它们之后，我们觉得我们的跟踪解决方案并不完美，我们可以从中受益：

• 能够控制跟踪消息的详细程度（例如，仅显示警告和错误，或非常详细的程序跟踪），
• 可以在不关闭应用程序和重新编译的情况下，单独打开和关闭程序组件的跟踪功能，
• 将跟踪消息写入文件、系统日志、消息队列或其他输出，
• 能够通过电子邮件发送特别重要的消息或将其存储在数据库中，
• 等等……

在图形化调试器时代，基于跟踪的解决方案的实用性可能有限。有时，跟踪被证明是唯一可用的工具，可用于定位无法中断一分钟的关键任务系统中的错误。

什么是 NLog？

NLog 是一个 .NET 库，它使您能够在应用程序中添加复杂的跟踪代码，提供上述功能以及更多。

NLog 允许您编写 **规则**，这些规则控制诊断跟踪从 **源** 到 **目标** 的流动，目标可以是

• 文件
• 文本控制台
• 电子邮件
• 数据库
• 网络上的另一台机器（使用 TCP/UDP）
• 基于 MSMQ 的消息队列
• 事件日志
• 以及其他，在此 处 进行了描述。

此外，每条跟踪消息都可以添加 **上下文信息**，这些信息将随消息一起发送到目标。上下文信息可以包括

• 当前日期和时间（以各种格式）
• 日志级别
• 源名称
• 堆栈跟踪/有关发出跟踪消息的方法的信息
• 环境变量的值
• 异常信息
• 机器、进程和线程名称
• 等等，在此 处 进行了描述。

每条跟踪消息都与一个日志级别相关联，该级别描述其严重性。NLog 支持以下级别：

• Trace - 非常详细的日志消息，可能频率和数量很高。
• Debug - 细节较少和/或频率较低的调试消息。
• Info - 信息性消息。
• Warn - 应用程序用户未注意到的警告。
• Error - 错误消息。
• Fatal - 致命错误消息。发生致命错误后，应用程序通常会终止。

NLog 是一个开源库，在 BSD 许可证 条款下免费分发，该许可证允许商业用途，几乎没有义务。您可以从 其网站 下载 NLog 二进制和源代码发行版。还提供了一个图形安装程序，它允许您将 NLog 安装到首选位置，并支持与 Visual Studio 2005（也支持 Express 版本）的集成，包括：

• 配置文件模板
• NLog 配置文件智能感知
• 代码片段
• 添加引用... 对话框集成

我们的第一个 NLog 应用程序

让我们使用 Visual Studio 2005 创建我们的第一个使用 NLog 的应用程序。我们将从一个仅将日志记录到控制台的简单示例开始，然后添加功能来演示控制 NLog 中日志配置的容易程度。

第一步是创建一个 Visual Studio 项目（在本例中，我们将使用 C#），并使用“添加新项...”对话框添加一个 NLog 配置文件。让我们添加一个“空 NLog 配置文件”并将其保存为“NLog.config”。

请注意，对 `NLog.dll` 的引用已自动添加到我们的项目中。我们将在此教程中修改的 `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" >

    <targets>
    </targets>

    <rules>
    </rules>
</nlog>

您只需要再做一件事：将此文件的“复制到输出目录”选项更改为“始终复制”。这样，我们的配置文件将被放置在与 `*.exe` 文件相同的目录中，NLog 将无需特殊配置即可读取它。

现在是时候配置日志输出了。在 `<targets />` 部分，我们将添加一个条目来定义控制台输出和所需的输出布局。

<targets>
    <target name="console" xsi:type="Console" 
            layout="${longdate}|${level}|${message}" />
</targets>

请注意，Visual Studio 如何建议可能的 XML 元素名称和属性名称/值。一旦我们输入 **xsi:**，就会出现可用的日志目标列表。

在 `<rules />` 部分，我们将添加一个规则，将所有级别为 Debug 或更高级别的消息路由到控制台。XML 非常自明。

<rules>
  <logger name="*" minlevel="Debug" writeTo="console" />
</rules>

为了发送诊断消息，我们使用一个 `Logger` 对象，其方法名与支持的日志级别（`Debug()`、`Info()`、`Fatal()` 等）相对应。 `Logger` 对象可以通过 `LogManager` 类创建。建议日志记录器的名称对应于应用程序中的完整类名。 `LogManager` 对象有一个 `GetCurrentClassLogger()` 方法，该方法可以根据调用它的类自动创建一个日志记录器。

让我们通过在文件开头添加 `using NLog` 语句，以及创建日志记录器的代码和示例日志消息来修改向导生成的 C# 文件。请注意，您可以通过使用 NLog 安装的代码段快速输入日志记录器创建语句。只需键入“nlogger”并按两次 TAB。

using System;
using System.Collections.Generic;
using System.Text;
using NLog;

namespace NLogExample
{
    class Program
    {
        private static Logger logger = LogManager.GetCurrentClassLogger();
        
        static void Main(string[] args)
        {
            logger.Debug("Hello World!");
        }
    }
}

运行此程序的结果是在控制台输出一条消息，其中包含当前日期、日志级别（`Debug`）以及“Hello World”消息。

让我们看看我们是如何实现的。

1. LogManager.GetCurrentClassLogger(); 创建一个 `Logger` 类的实例，它代表与当前类关联的日志消息的 **源**。
2. 在源对象上调用 `Debug()` 方法会将诊断消息以 Debug 级别发送。
3. 由于我们的日志级别和源名称与 `<rules />` 部分定义的规则匹配，因此消息将根据“布局”规范进行格式化并发送到控制台。

更高级的日志记录场景

让我们将日志消息以及一些上下文信息（如当前堆栈跟踪）同时记录到文件和控制台。为此，我们需要定义一个类型为“File”的另一个目标，并告诉 `<logger>` 节点我们想写入它。

<?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" >

   <targets>
     <target name="console" xsi:type="ColoredConsole" 
      layout="${date:format=HH\:mm\:ss}|${level}|${stacktrace}|${message}" />
     <target name="file" xsi:type="File" fileName="${basedir}/file.txt" 
      layout="${stacktrace} ${message}" />
   </targets>

    <rules>
        <logger name="*" minlevel="Trace" writeTo="console,file" />
    </rules>
</nlog>

这是发出更多日志消息的 C# 源代码；此处引入了其他方法来观察堆栈跟踪功能。

static void C()
{
    logger.Info("Info CCC");
}
static void B()
{
    logger.Trace("Trace BBB");
    logger.Debug("Debug BBB");
    logger.Info("Info BBB");
    C();
    logger.Warn("Warn BBB");
    logger.Error("Error BBB");
    logger.Fatal("Fatal BBB");
}
static void A()
{
    logger.Trace("Trace AAA");
    logger.Debug("Debug AAA");
    logger.Info("Info AAA");
    B();
    logger.Warn("Warn AAA");
    logger.Error("Error AAA");
    logger.Fatal("Fatal AAA");
}
static void Main(string[] args)
{
    logger.Trace("This is a Trace message");
    logger.Debug("This is a Debug message");
    logger.Info("This is an Info message");
    A();
    logger.Warn("This is a Warn message");
    logger.Error("This is an Error message");
    logger.Fatal("This is a Fatal error message");
}

运行程序时，以下信息将被写入应用程序目录中的“file.txt”：

Program.Main This is a Trace message
Program.Main This is a Debug message
Program.Main This is an Info message
Program.Main => Program.A Trace AAA
Program.Main => Program.A Debug AAA
Program.Main => Program.A Info AAA
Program.Main => Program.A => Program.B Trace BBB
Program.Main => Program.A => Program.B Debug BBB
Program.Main => Program.A => Program.B Info BBB
Program.A => Program.B => Program.C Info CCC
Program.Main => Program.A => Program.B Warn BBB
Program.Main => Program.A => Program.B Error BBB
Program.Main => Program.A => Program.B Fatal BBB
Program.Main => Program.A Warn AAA
Program.Main => Program.A Error AAA
Program.Main => Program.A Fatal AAA
Program.Main This is a Warn message
Program.Main This is an Error message
Program.Main This is a Fatal error message

同时，我们在控制台上看到这种花哨的彩色输出：

现在，让我们稍微修改一下配置。典型的要求是根据输出具有不同的详细程度。例如，我们只希望将级别为 `Info` 或更高级别的消息写入控制台，而我们希望将 **所有** 消息都写入文件。使用 NLog，您只需要更改 `<rules />` 部分。不需要更改 C# 源代码。

<rules>
    <logger name="*" minlevel="Info" writeTo="console" />
    <logger name="*" minlevel="Trace" writeTo="file" />
</rules>

运行程序后，我们会发现 `Trace` 和 `Debug` 消息仅在文件中找到，而不会显示在控制台上。

日志配置

现在是时候描述 NLog 配置机制了。与其他工具不同，NLog 会在启动时尝试自动配置自身，在某些标准位置查找配置文件。执行独立的 `*.exe` 应用程序时将搜索以下位置：

• 标准应用程序配置文件（通常是 `applicationname.exe.config`）
• 应用程序目录中的 `applicationname.exe.nlog`
• 应用程序目录中的 `NLog.nlog`
• 位于 `NLog.dll` 所在目录中的 `NLog.dll.nlog`
• 由 `NLOG_GLOBAL_CONFIG_FILE` 环境变量（如果已定义）指向的文件名

对于 ASP.NET 应用程序，将搜索以下文件：

• 标准 Web 应用程序文件 `web.config`
• 位于 `web.config` 同一目录中的 `web.nlog`
• 应用程序目录中的 `NLog.nlog`
• 位于 `NLog.dll` 所在目录中的 `NLog.dll.nlog`
• 由 `NLOG_GLOBAL_CONFIG_FILE` 环境变量（如果已定义）指向的文件名

.NET Compact Framework 无法识别应用程序配置文件（`*.exe.config`）或环境变量，因此 NLog 仅在以下位置查找：

• 应用程序目录中的 `applicationname.exe.nlog`
• 应用程序目录中的 `NLog.nlog`
• 位于 `NLog.dll` 所在目录中的 `NLog.dll.nlog`

配置文件格式

NLog 支持两种配置文件格式：

• 嵌入在标准的 `*.exe.config` 或 `web.config` 文件中的配置
• 存储在单独文件中的简化配置

在第一种变体中，我们使用标准的 `configSections` 机制，这使得我们的文件看起来像这样：

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <configSections>
    <section name="nlog" type="NLog.Config.ConfigSectionHandler, NLog" />
  </configSections>
  <nlog>
  </nlog>
</configuration>

简化格式是纯 XML，以 `<nlog />` 元素为根。命名空间的使用是可选的，但它可以在 Visual Studio 中启用智能感知。

<?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" >
</nlog>

请注意，NLog 配置文件在不使用命名空间时是大小写不敏感的，在使用命名空间时是大小写敏感的。智能感知仅适用于大小写敏感的配置。

配置元素

您可以将以下元素用作 `<nlog />` 的子元素。列表中的前两个元素是所有 NLog 配置文件必需的，其余元素是可选的，在高级场景中可能很有用。

• <targets /> - 定义日志目标/输出。
• <rules /> - 定义日志路由规则。
• <extensions /> - 从 `*.dll` 文件加载 NLog 扩展。
• <include /> - 包含外部配置文件。
• <variable /> - 设置配置变量的值。

目标

`<targets />` 部分定义日志目标/输出。每个目标由 `<target />` 元素表示。每个目标都需要两个属性：

• name - 目标名称。
• type - 目标类型 - 例如“File”、“Database”、“Mail”。使用命名空间时，此属性名为 `xsi:type`。

除此之外，目标通常还接受其他参数，这些参数会影响诊断跟踪的写入方式。每个目标都有不同的参数集，它们在项目主页上进行了详细描述，并且在 Visual Studio 中也提供了上下文智能感知。

例如 - “File”目标接受 `fileName` 参数，该参数定义输出文件名；“Console”目标具有 `error` 参数，该参数决定诊断跟踪是写入标准错误（stderr）还是标准输出（stdout）。

NLog 提供了许多预定义的 Targe。它们在项目主页上进行了描述。创建自己的目标实际上非常容易 - 它只需要 15-20 行代码，并且在 文档 中进行了描述。

规则

日志路由规则在 `<rules />` 部分定义。它是一个简单的路由表，我们定义了对于每个源/日志记录器名称和日志级别的组合，应该写入哪个目标列表。规则的处理从列表中的第一个规则开始。当规则匹配时，日志消息将被定向到该规则中的目标。如果规则被标记为 final，则不会处理当前规则下方的规则。

每个路由表条目都是一个 `<logger />` 元素，它接受以下属性：

• name - 源/日志记录器名称（可能包含通配符 **\***）。
• minlevel - 此规则匹配的最小日志级别。
• maxlevel - 此规则匹配的最大日志级别。
• level - 此规则匹配的单个日志级别。
• levels - 用于此规则匹配的日志级别的逗号分隔列表。
• writeTo - 匹配此规则时应写入的目标的逗号分隔列表。
• final - 使此规则成为 final。当任何 final 规则匹配时，不再处理后续规则。

一些示例

• <logger name="Name.Space.Class1" minlevel="Debug" writeTo="f1" /> - `Name.Space` 中 `Class1` 的所有级别为 `Debug` 或更高级别的消息都写入“f1”目标。
• <logger name="Name.Space.Class1" levels="Debug,Error" writeTo="f1" /> - `Name.Space` 中 `Class1` 的所有级别为 `Debug` 或 `Error` 或更高级别的消息都写入“f1”目标。
• <logger name="Name.Space.*" writeTo="f3,f4" /> - `Name.Space` 命名空间中任何类的消息都将写入“f3”和“f4”目标，无论其级别如何。
• <logger name="Name.Space.*" minlevel="Debug" maxlevel="Error" final="true" /> - `Name.Space` 命名空间中级别在 `Debug` 和 `Error` 之间（包括 `Debug`、`Info`、`Warn`、`Error`）的任何类的消息都将被拒绝（因为没有 `writeTo` 子句），并且不再为它们处理后续规则（因为设置了 final="true"）。

在最简单的情况下，整个日志配置包括一个 `<target />` 和一个 `<logger />` 规则，该规则根据消息的级别将其路由到此目标。随着应用程序的增长，添加更多目标和规则非常简单。

上下文信息

NLog 的强大优势之一是使用布局的能力。它们包含用一对“**${**”（美元符号 + 左花括号）和“**}**”（右花括号）包围的文本片段。标记表示“布局渲染器”，可用于将 **上下文信息** 插入到文本中。布局可以在许多地方使用。例如，它们可以控制在屏幕上显示或写入文件的信息的格式，还可以控制文件名本身。这非常强大，我们稍后将看到。

假设我们想在写入控制台的每条消息中添加：

• 当前日期和时间
• 发出日志消息的类名和方法名
• 日志级别
• 消息文本

这非常容易。

<target name="c" xsi:type="Console" 
        layout="${longdate} ${callsite} ${level} ${message}" />

我们可以让每个日志记录器的每条消息都转到单独的文件，如下例所示：

<target name="f" xsi:type="File" fileName="${logger}.txt" />

如您所见，`<fileName>` 属性中使用了 `${logger}` 布局渲染器，这会导致每条日志消息写入一个包含日志记录器名称的文件。上面的示例将创建以下文件：

• Name.Space.Class1.txt
• Name.Space.Class2.txt
• Name.Space.Class3.txt
• Other.Name.Space.Class1.txt
• Other.Name.Space.Class2.txt
• Other.Name.Space.Class3.txt
• ...

通常需要能够为每天保留日志文件。由于 `${shortdate}` 布局渲染器，这也变得微不足道。

<target name="f" xsi:type="File" filename="${shortdate}.txt" />

如何为每个员工提供自己的日志文件？`${windows-identity}` 布局渲染器可以做到这一点。

<target name="f" xsi:type="File" 
        filename="${windows-identity:domain=false}.txt" />

通过这个简单的设置，NLog 将创建一组以员工登录名命名的文件：

1. Administrator.txt
2. MaryManager.txt
3. EdwardEmployee.txt
4. ...

当然，也可能存在更复杂的情况。以下示例演示了如何为每个人每天创建一个不同的日志文件。每天的日志文件存储在单独的目录中。

<target name="f" xsi:type="File" 
        filename="${shortdate}/${windows-identity:domain=false}.txt" />

这将创建以下文件：

1. 2006-01-01/Administrator.txt
2. 2006-01-01/MaryManager.txt
3. 2006-01-01/EdwardEmployee.txt
4. 2006-01-02/Administrator.txt
5. 2006-01-02/MaryManager.txt
6. 2006-01-02/EdwardEmployee.txt
7. ...

NLog 提供了许多预定义的布局渲染器。它们在 网站 上进行了描述。创建自己的布局渲染器非常容易。只需要 15-20 行代码，并在项目网站的 文档 部分进行了描述。

包含文件

有时希望将配置文件拆分成多个较小的文件。NLog为此提供了包含文件机制。要包含外部文件，只需使用以下代码。值得注意的是，`fileName` 属性，就像 NLog 配置文件中的大多数属性一样，可以使用熟悉的 `${var}` 表示法包含动态值，因此可以根据环境属性包含不同的文件。以下配置示例演示了这一点，通过加载我们正在运行的机器名称派生的文件名。

<nlog>
    ...
    <include file="${basedir}/${machinename}.config" />
    ...
</nlog>

变量使我们能够以简洁的方式编写复杂或可重复的表达式（例如文件名）。要定义变量，我们使用 `<variable name="var" value="xxx" />` 语法。定义后，变量就可以像布局渲染器一样使用 - 使用 `${var}` 语法，如以下示例所示：

<nlog>
    <variable name="logDirectory" value="${basedir}/logs/${shortdate}" />

    <targets>
        <target name="file1" xsi:type="File" filename="${logDirectory}/file1.txt" />
        <target name="file2" xsi:type="File" filename="${logDirectory}/file2.txt" />
    </targets>
</nlog>

自动重新配置

配置文件在程序启动时自动读取。在长期运行的进程（如 Windows 服务或 ASP.NET 应用程序）中，有时希望在不停止应用程序的情况下临时提高日志级别。NLog 可以监视日志配置文件并在每次修改时重新读取它们。要启用此机制，只需在配置文件中设置 `<nlog autoReload="true" />`。请注意，自动重新配置支持包含文件，因此每次更改包含文件之一时，整个配置都会重新加载。

故障排除日志记录

有时我们的应用程序根本没有写入日志文件，尽管我们已经正确配置了日志记录。日志未写入可能有很多原因。最常见的问题是权限，通常是在 ASP.NET 进程中，`aspnet_wp.exe` 或 `w3wp.exe` 进程可能没有写入要存储日志的目录的权限。NLog 设计用于吞噬日志记录时可能发生的运行时异常。以下设置可以更改此行为和/或重定向这些消息。

• <nlog throwExceptions="true" /> - 在配置文件中添加 `throwExceptions` 属性会导致 NLog 不会屏蔽异常，而是将其传递给调用应用程序。此属性在部署时非常有用，可以快速定位任何问题。建议在应用程序配置为运行时，尽快将 `throwExceptions` 设置为“false”，以免任何意外的日志记录问题导致应用程序崩溃。
• <nlog internalLogFile="file.txt" /> - 添加 `internalLogFile` 会导致 NLog 将其内部调试消息写入指定的文件。这包括在日志记录期间可能抛出的任何异常。
• <nlog internalLogLevel="Trace|Debug|Info|Warn|Error|Fatal" /> - 确定内部日志级别。级别越高，内部日志输出的详细程度越低。
• <nlog internalLogToConsole="false|true" /> - 将内部日志消息发送到控制台。
• <nlog internalLogToConsoleError="false|true" /> - 将内部日志消息发送到控制台错误输出 (stderr)。

异步处理、包装器和复合目标

NLog 提供包装器和复合目标，它们可以修改其他目标的行为，添加功能，如：

• 异步处理（包装目标在一个单独的线程中运行）
• 重试错误
• 负载均衡（轮询目标）
• 缓冲
• 过滤
• 备份目标（故障转移）
• 以及在 网站 上描述的其他功能。

要在配置文件中定义包装器或复合目标，只需将一个 `target` 节点嵌套在另一个 `target` 节点内。您甚至可以包装一个包装器目标。深度没有限制。例如，要添加具有重试错误功能的异步日志记录，请将以下内容添加到您的配置文件中：

<targets>
    <target name="n" xsi:type="AsyncWrapper">
        <target xsi:type="RetryingWrapper">
            <target xsi:type="File" fileName="${file}.txt" />
        </target>
    </target>
</targets>

由于异步处理是一种常见场景，NLog 支持一种简写方式来为所有目标启用它，而无需指定显式包装器。只需设置 `<targets async="true" />`，您的所有目标都将被 `AsyncWrapper` 目标包装。

程序化配置

在某些情况下，您可能选择不使用配置文件，而是通过提供的 API 配置 NLog。此功能的完整描述超出了本文的范围，因此我们仅概述使其正常工作的必要步骤。要在代码中配置 NLog，您需要：

1. 创建一个 `LoggingConfiguration` 对象来保存配置。
2. 创建一种或多种目标（继承自 `Target` 的类的对象）。
3. 设置目标的属性。
4. 通过 `LoggingRule` 对象定义日志记录规则，并将其添加到配置的 `LoggingRules` 中。
5. 通过将配置对象分配给 `LogManager.Configuration` 来激活配置。

此示例演示了两个目标的程序化创建：一个是有色控制台，另一个是文件，以及将级别为 `Debug` 或更高级别的消息发送到它们的规则。

using NLog;
using NLog.Targets;
using NLog.Config;
using NLog.Win32.Targets;

class Example
{
static void Main(string[] args)
{
    // Step 1. Create configuration object
    
    LoggingConfiguration config = new LoggingConfiguration();
    
    // Step 2. Create targets and add them to the configuration

    ColoredConsoleTarget consoleTarget = new ColoredConsoleTarget();
    config.AddTarget("console", consoleTarget);
    
    FileTarget fileTarget = new FileTarget();
    config.AddTarget("file", fileTarget);
    
    // Step 3. Set target properties
    
    consoleTarget.Layout = "${date:format=HH\\:MM\\:ss} ${logger} ${message}";
    fileTarget.FileName = "${basedir}/file.txt";
    fileTarget.Layout = "${message}";
    
    // Step 4. Define rules
    
    LoggingRule rule1 = new LoggingRule("*", LogLevel.Debug, consoleTarget);
    config.LoggingRules.Add(rule1);

    LoggingRule rule2 = new LoggingRule("*", LogLevel.Debug, fileTarget);
    config.LoggingRules.Add(rule2);
    
    // Step 5. Activate the configuration

    LogManager.Configuration = config;
    
    // Example usage

    Logger logger = LogManager.GetLogger("Example");
    logger.Trace("trace log message");
    logger.Debug("debug log message");
    logger.Info("info log message");
    logger.Warn("warn log message");
    logger.Error("error log message");
    logger.Fatal("fatal log message");
}
}

NLog 还能做什么？

NLog 支持更多日志记录场景，此处无法完全描述。有关更多信息，请参阅以下链接：

• 异常日志记录
• 条件表达式语言
• NLogViewer - 实时日志查看器应用程序（目前处于预 Alpha 阶段）

更多信息

有关 NLog 的其他信息可以在 项目主页 上找到。欢迎开发人员加入该项目。有一个邮件列表，您可以 订阅。

历史

• 2005-06-09
  • 文章已提交。
• 2006-02-20
  • 已更新以反映 0.95 版本更改。
• 2006-06-27
  • 已更新以反映 1.0 版本更改。有关 1.0 版本所做更改的完整列表，请在此处 单击。