Create a Logger using the Trace Listener in C#

When writing software for the commercial world it is crucial your application can log errors, be it to the database, or to a text file, or even to theWindows Event Log if necessary. The .NET Framework contains a mechanism called a Trace Listener. This Listener is an object which directs the trace output to an appropriate target, such as an error log for example.

In this article I am going to show you how to use the Trace Listener to record your application’s errors to an error log.

To begin this example create a console application and add an App.config file to your project. We are going to use the App.config file to tell our application that it should create a trace listener on start-up. Amend the XML code of your App.configfile to look like the below example.

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.diagnostics>
    <trace autoflush="true" indentsize="4">
      <listeners>
        <add name="myListener" type="System.Diagnostics.TextWriterTraceListener" initializeData="application.log" />
        <remove name="Default" />
      </listeners>
    </trace>
  </system.diagnostics>
</configuration>

As you can see, we are adding a listener of typeSystem.Diagnostics.TextWriterTraceListener which is set to write to a log file called application.log. Also note that in the <trace> node we are setting theautoflush attribute to true. When set to true this attribute tells the listener to flush the buffer after every write operation. For this example it is great but for real world applications you probably would want to set this to false to limit disk read and write operations.

Now in your static Main method you can write to the log using the Trace class as shown below.

static void Main(string[] args)
{
    Trace.WriteLine("Application started.", "MyApp");

    Trace.WriteLine("working...", "MyApp");

    Trace.WriteLine("Application finished.", "MyApp");
}

If we open the application.log file created automatically by the listener right after we run the above code we will find the following in the file:

MyApp: Application started.
MyApp: working...
MyApp: Application finished.

As you can see it’s quite easy to write to the log file. We didn’t even have to open a FileStream to write to the file because it was all done for us automatically by the listener.

This logger we just created is quite crude since we are not recording the date and time of the error, nor are we recording the source. So let’s extend the concept a little by creating a small logger class as shown below.

using System;
using System.Diagnostics;

public static class Logger
{
    public static void Error(string message, string module)
    {
        WriteEntry(message, "error", module);
    }

    public static void Error(Exception ex, string module)
    {
        WriteEntry(ex.Message, "error", module);
    }

    public static void Warning(string message, string module)
    {
        WriteEntry(message, "warning", module);
    }

    public static void Info(string message, string module)
    {
        WriteEntry(message, "info", module);
    }

    private static void WriteEntry(string message, string type, string module)
    {
        Trace.WriteLine(
                string.Format("{0},{1},{2},{3}",
                              DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
                              type,
                              module,
                              message));
    }
}

The above Logger class has four public static methods – Warning, Info, and an overloaded Error method. Each of these methods calls the private WriteEntrymethod which actually writes to the log through the Trace class. As you can see here we are writing the date and time, the entry type (“error”, “warning”, or“info”), the module where the error occurred, and the actual error message.

Now to use this class we can do the following:

static void Main(string[] args)
{
    try
    {
        Logger.Info("Application started.", "MyApp");
        Logger.Info("working...", "MyApp");
        Logger.Warning("Application about to exit!", "MyApp");
        Logger.Info("Application finished.", "MyApp");

        throw new Exception();
    }
    catch (Exception ex)
    {
        Logger.Error(ex, "MyApp");
    }
}

The above code would produce the following log:

2009-09-16 23:02:04,info,MyApp,Application started.
2009-09-16 23:02:04,info,MyApp,working...
2009-09-16 23:02:04,warning,MyApp,Application about to exit!
2009-09-16 23:02:04,info,MyApp,Application finished.
2009-09-16 23:02:04,error,MyApp,Exception of type 'System.Exception' was thrown.

And there you have it – you now know how to use the Trace Listener in C# and how to create a simple logger class. Obviously the Logger class we created can be enhanced a lot more. For example you could add code to wrap the log file after it grows to 5MB. You could also add code to log the thread which the error occurred on. There is a large number of amendments you could do to make this class better.

I hope you enjoyed this article. Feel free to leave any comments below or if you want you can contact me through my contact page. Also, if you haven’t already subscribed to my rss feed, please do so – Grab RSS Feed.