Creating C# Logger with CsharpGears

The Need of Logger for C#

Loggers come in handy when one wishes to trace the execution of his program. These pieces of code make life much easier when it comes to maintaining the application code error free. That is because with logging capabilities, the developer is able to track every time an unusual event occurs. Then it will be easy to determine where the code needs more attention, whether it includes refactoring, bugs or something else.

There are loggers for C#, they are not something new. But what they often lack, is known as ease-of-use. Here could fall Log4Net and other classes that could be found accross the Web. Often, developer needs a simple logger, some code that will get the job done when an exception is thrown. 

Therefore I have decided to write flexible C# classes that will still be extremely simple to use, flexible by design, and will give the developer control of the log level.(Log levels are an important aspect of the loggers, as they give the power to control which events will enter the log, and which will be left out.

The Database Logger in C#
The Logger classes in the CsharpGears Framework are organized in the following way:

 

 There exists a class named LoggerBase which is abstract and it also implements the ILogger interface. From it DbLogger class is derived, and that is the main class we are going to use. There are also SqlServerDbLoggerProvider class which configures the DbLogger so that it creates the needed tables and stored procedures in the database. These logger classes communicate with LogMessages. There is a generic LogMessage

from which other LogMessages are derived. For each log level, there exists an appropriate message.


So, let's show an example of the usage of the the C# logger.

/* Set up configuration for the logger */
string DbProvider = "System.Data.SqlClient";
            string ConnectionString = "...";

            /* Create the logger */
            ILogger Logger = new DbLogger(DbProvider,ConnectionString);
            Configuration.LogLevel = LogLevel.ERROR;
            /* Create log messages */
            ILogMessage Message = new LogMessage("Message Content: Error", "SYSTEM",
LogLevel.INFO);
            ILogMessage InfoMessage = new InfoLogMessage("Info log message", "SYSTEM");
            ILogMessage ErrorMessage = new ErrorLogMessage("Fatal error", "SYSTEM");
            ILogMessage AllMessage = new AllLogMessage("All log message", "SYSTEM");

            /* Append the messages */
            Logger.Append(Message);
            Logger.Append(InfoMessage);
            Logger.Append(ErrorMessage);
            Logger.Append(AllMessage);

            /* Retrieve all messages from the log */
            List<LogMessage> LogContent = Logger.ReadLog();

            /* Retrieve the messages from today */
            List<LogMessage> TodaysLogContent = Logger.ReadLogByDate(DateTime.Now);

            /* Print the log messages from today */
            foreach (LogMessage message in TodaysLogContent) 
            {
                Console.WriteLine(message.Message + " " + message.UserName + " "
+ message.Date + "\n");
            }

As you can see, you only need to configure the logger for the database provider and the connection string - and you are ready to go. When you want to append a message, you only need to create the appropriate message object - you can either use the interface notation, or create the message type directly, by creating a log message of the specific type. Then you need to invoke the Append() method. For retrieval of the messages from the logger, you need to invoke the method ReadLog(), or you can read the messages from today. (In the future version, I will add an opportunity to read according to the log level). And then, you will get a generic C# list of Log messages. In case you were wondering, this utilizes the DatabaseEntity classes, discussed in my previous post about database access with the CsharpGears framework.
If you have any questions about using this logger, feel free to ask. As you can see, it is very simple to use, and it abstracts most of the annoying things when developing logger classes in C#.