To set up the target in the configuration file, use the following syntax:

<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd" 
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
  <targets> 
    <target name="file" xsi:type="File" 
            layout="${longdate} ${logger} ${message}" 
            fileName="${basedir}/logs/logfile.txt" keepFileOpen="false" 
            encoding="iso-8859-2"/> 
  </targets> 
  <rules> 
    <logger name="*" minlevel="Debug" writeTo="file"/> 
  </rules> 
</nlog> 

You can use a single target to write to multiple files. The following example writes each log message to a file named after its log level, so it will create: Trace.log, Debug.log, Info.log, Warn.log, Error.log, Fatal.log

<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd" 
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
  <targets> 
    <target name="file" xsi:type="File" 
            layout="${longdate} ${logger} ${message}" 
            fileName="${basedir}/${level}.log"/> 
  </targets> 
  <rules> 
    <logger name="*" minlevel="Debug" writeTo="file"/> 
  </rules> 
</nlog> 

The file names can be quite complex for the most demanding scenarios. This example shows a way to create separate files for each day, user and log level. As you can see, the possibilities are endless.

<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd" 
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
  <targets> 
    <target name="file" xsi:type="File" 
            layout="${longdate} ${logger} ${message}" 
            fileName="${basedir}/${shortdate}/${windows-identity:domain=false}.${level}.log"/> 
  </targets> 
  <rules> 
    <logger name="*" minlevel="Debug" writeTo="file"/> 
  </rules> 
</nlog> 

Depending on your usage scenario it may be useful to add an asynchronous target wrapper around the file target. This way all your log messages will be written in a separate thread so your main thread can finish your work more quickly. Asynchronous logging is recommended for multi-threaded server applications which run for a long time and is not recommended for quickly-finishing command line applications.

<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd" 
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
  <targets> 
    <!-- Log in a separate thread, possibly queueing up to
        5000 messages. When the queue overflows, discard any
        extra messages--> 
    <target name="file" xsi:type="AsyncWrapper" queueLimit="5000" 
            overflowAction="Discard"> 
      <target xsi:type="File" fileName="${basedir}/logs/${level}.txt"/> 
    </target> 
  </targets> 
  <rules> 
    <logger name="*" minlevel="Debug" writeTo="file"/> 
  </rules> 
</nlog> 

The above examples assume just one target and a single rule. See below for a programmatic configuration that's equivalent to the above config file:

using NLog; 
using NLog.Targets; 
using NLog.Targets.Wrappers; 
 
class Example 
{ 
    static void Main(string[] args) 
    { 
        FileTarget target = new FileTarget(); 
        target.Layout = "${longdate} ${logger} ${message}"; 
        target.FileName = "${basedir}/logs/logfile.txt"; 
        target.KeepFileOpen = false; 
        target.Encoding = "iso-8859-2"; 
 
        AsyncTargetWrapper wrapper = new AsyncTargetWrapper(); 
        wrapper.WrappedTarget = target; 
        wrapper.QueueLimit = 5000; 
        wrapper.OverflowAction = AsyncTargetWrapperOverflowAction.Discard; 
 
        NLog.Config.SimpleConfigurator.ConfigureForTargetLogging(wrapper, LogLevel.Debug); 
 
        Logger logger = LogManager.GetLogger("Example"); 
        logger.Debug("log message"); 
    } 
}

More configuration options are described here.

To set up the log target programmatically use code like this:

using NLog; 
using NLog.Targets; 
 
class Example 
{ 
    static void Main(string[] args) 
    { 
        FileTarget target = new FileTarget(); 
        target.Layout = "${longdate} ${logger} ${message}"; 
        target.FileName = "${basedir}/logs/logfile.txt"; 
        target.KeepFileOpen = false; 
        target.Encoding = "iso-8859-2"; 
 
        NLog.Config.SimpleConfigurator.ConfigureForTargetLogging(target, LogLevel.Debug); 
 
        Logger logger = LogManager.GetLogger("Example"); 
        logger.Debug("log message"); 
    } 
}

File target can also do file archiving, meaning that the log file is automatically moved to another place based on its size and time. This example demonstrates file archiving based on size. Files after 10000 bytes are moved to a separate folder and renamed log.00000.txt, log.00001.txt and so on.

using NLog; 
using NLog.Targets; 
using NLog.Targets.Wrappers; 
 
class Example 
{ 
    static void Main(string[] args) 
    { 
        FileTarget target = new FileTarget(); 
        target.Layout = "${longdate} ${logger} ${message}"; 
        target.FileName = "${basedir}/logs/logfile.txt"; 
        target.ArchiveFileName = "${basedir}/archives/log.{#####}.txt"; 
        target.ArchiveAboveSize = 10 * 1024; // archive files greater than 10 KB 
        target.ArchiveNumbering = FileTarget.ArchiveNumberingMode.Sequence; 
 
        // this speeds up things when no other processes are writing to the file 
        target.ConcurrentWrites = true; 
 
        NLog.Config.SimpleConfigurator.ConfigureForTargetLogging(target, LogLevel.Debug); 
 
        Logger logger = LogManager.GetLogger("Example"); 
         
        // generate a large volume of messages 
        for (int i = 0; i < 1000; ++i) 
        { 
            logger.Debug("log message {0}", i); 
        } 
    } 
}

File archiving can also be done on date/time changes. For example, to create a new archive file every minute use this code:

using NLog; 
using NLog.Targets; 
using NLog.Targets.Wrappers; 
using System.Threading; 
 
class Example 
{ 
    static void Main(string[] args) 
    { 
        FileTarget target = new FileTarget(); 
        target.Layout = "${longdate} ${logger} ${message}"; 
        target.FileName = "${basedir}/logs/logfile.txt"; 
        target.ArchiveFileName = "${basedir}/archives/log.{#####}.txt"; 
        target.ArchiveEvery = FileTarget.ArchiveEveryMode.Minute; 
        target.ArchiveNumbering = FileTarget.ArchiveNumberingMode.Rolling; 
        target.MaxArchiveFiles = 3; 
 
        // this speeds up things when no other processes are writing to the file 
        target.ConcurrentWrites = true; 
 
        NLog.Config.SimpleConfigurator.ConfigureForTargetLogging(target, LogLevel.Debug); 
 
        Logger logger = LogManager.GetLogger("Example"); 
 
        // generate a large number of messages, sleeping 1 second between writes 
        // to observe time-based archiving which occurs every minute 
 
        // 
        // you get: 
        //      logs/logfile.txt 
        // 
        // and your archives go to: 
        // 
        //      archives/log.00000.txt 
        //      archives/log.00001.txt 
        //      archives/log.00002.txt 
        //      archives/log.00003.txt 
        //      archives/log.00004.txt 
 
        for (int i = 0; i < 250; ++i) 
        { 
            logger.Debug("log message {i}", i); 
            Thread.Sleep(1000); 
        } 
    } 
}

You can combine both methods as demonstrated here:

using NLog; 
using NLog.Targets; 
using NLog.Targets.Wrappers; 
using System.Threading; 
 
class Example 
{ 
    static void Main(string[] args) 
    { 
        FileTarget target = new FileTarget(); 
        target.Layout = "${longdate} ${logger} ${message}"; 
        target.FileName = "${basedir}/logs/logfile.txt"; 
        // where to store the archive files 
        target.ArchiveFileName = "${basedir}/archives/log.{#####}.txt"; 
        target.ArchiveEvery = FileTarget.ArchiveEveryMode.Minute; 
        target.ArchiveNumbering = FileTarget.ArchiveNumberingMode.Rolling; 
        target.MaxArchiveFiles = 3; 
        target.ArchiveAboveSize = 10000; 
 
        // this speeds up things when no other processes are writing to the file 
        target.ConcurrentWrites = true; 
 
        NLog.Config.SimpleConfigurator.ConfigureForTargetLogging(target, LogLevel.Debug); 
 
        Logger logger = LogManager.GetLogger("Example"); 
 
        // generate a large number of messages, sleeping 1/10 of second between writes 
        // to observe time-based archiving which occurs every minute 
        // the volume is high enough to cause ArchiveAboveSize to be triggered 
        // so that log files larger than 10000 bytes are archived as well 
 
        // 
        // you get: 
        //      logs/logfile.txt 
        // 
        // and your archives go to: 
        // 
        //      archives/log.00000.txt 
        //      archives/log.00001.txt 
        //      archives/log.00002.txt 
        //      archives/log.00003.txt 
        //      archives/log.00004.txt 
 
        for (int i = 0; i < 2500; ++i) 
        { 
            logger.Debug("log message {i}", i); 
            Thread.Sleep(100); 
        } 
    } 
}

Note that file archiving works even when you use a single target instance to write to multiple files, such as putting each log level in a separate place:

using NLog; 
using NLog.Targets; 
using NLog.Targets.Wrappers; 
using System.Threading; 
 
class Example 
{ 
    static void Main(string[] args) 
    { 
        FileTarget target = new FileTarget(); 
        target.Layout = "${longdate} ${logger} ${message}"; 
        target.FileName = "${basedir}/logs/logfile.${level}.txt"; 
        // where to store the archive files 
        target.ArchiveFileName = "${basedir}/archives/${level}/log.{#####}.txt"; 
        target.ArchiveEvery = FileTarget.ArchiveEveryMode.Minute; 
        target.ArchiveNumbering = FileTarget.ArchiveNumberingMode.Rolling; 
        target.MaxArchiveFiles = 3; 
        target.ArchiveAboveSize = 10000; 
 
        // this speeds up things when no other processes are writing to the file 
        target.ConcurrentWrites = true; 
 
        NLog.Config.SimpleConfigurator.ConfigureForTargetLogging(target, LogLevel.Debug); 
 
        Logger logger = LogManager.GetLogger("Example"); 
 
        // generate a large number of messages, sleeping 1/10 of second between writes 
        // to observe time-based archiving which occurs every minute 
        // the volume is high enough to cause ArchiveAboveSize to be triggered 
        // so that log files larger than 10000 bytes are archived as well 
 
        // in this version, a single File target keeps track of 3 sets of log and  
        // archive files, one for each level 
 
        // you get: 
        //      logs/logfile.Debug.txt 
        //      logs/logfile.Error.txt 
        //      logs/logfile.Fatal.txt 
        // 
        // and your archives go to: 
        // 
        //      archives/Debug/log.00000.txt 
        //      archives/Debug/log.00001.txt 
        //      archives/Debug/log.00002.txt 
        //      archives/Debug/log.00003.txt 
        //      archives/Error/log.00000.txt 
        //      archives/Error/log.00001.txt 
        //      archives/Error/log.00002.txt 
        //      archives/Error/log.00003.txt 
        //      archives/Fatal/log.00000.txt 
        //      archives/Fatal/log.00001.txt 
        //      archives/Fatal/log.00002.txt 
        //      archives/Fatal/log.00003.txt 
 
        for (int i = 0; i < 2500; ++i) 
        { 
            logger.Debug("log message {i}", i); 
            logger.Error("log message {i}", i); 
            logger.Fatal("log message {i}", i); 
            Thread.Sleep(100); 
        } 
    } 
}

You can write texts using alternative layouts, such as CSV (comma-separated values). This example writes files which are properly CSV-quoted (can handle messages with line breaks and quotes)

using System; 
 
using NLog; 
using NLog.Targets; 
using NLog.Layouts; 
 
class Example 
{ 
    static void Main(string[] args) 
    { 
        FileTarget target = new FileTarget(); 
        target.FileName = "${basedir}/file.csv"; 
 
        CsvLayout layout = new CsvLayout(); 
 
        layout.Columns.Add(new CsvColumn("time", "${longdate}")); 
        layout.Columns.Add(new CsvColumn("message", "${message}")); 
        layout.Columns.Add(new CsvColumn("logger", "${logger}")); 
        layout.Columns.Add(new CsvColumn("level", "${level}")); 
 
        target.CompiledLayout = layout; 
 
        NLog.Config.SimpleConfigurator.ConfigureForTargetLogging(target, LogLevel.Debug); 
 
        Logger logger = LogManager.GetLogger("Example"); 
        logger.Debug("log message"); 
        logger.Debug("Message with \"quotes\" and \nnew line characters."); 
    } 
}

<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd" 
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
  <targets> 
    <target name="csv" xsi:type="File" fileName="${basedir}/file.csv"> 
      <layout xsi:type="CSVLayout"> 
        <column name="time" layout="${longdate}"/> 
        <column name="message" layout="${message}"/> 
        <column name="logger" layout="${logger}"/> 
        <column name="level" layout="${level}"/> 
      </layout> 
    </target> 
  </targets> 
  <rules> 
    <logger name="*" minlevel="Debug" writeTo="csv"/> 
  </rules> 
</nlog>