Create Multiple Sink Files with Log4net

#region File Header
// File				: Logger.cs
// Project			: MyLogger	 
// Change History  	:
// Date	         Version	   Author    	    Remarks
// 01/06/2007    1.0           Manas Bhardwaj            
// Copyright � 2007 Manas Bhardwaj
#endregion

#region NameSpace Declaration
using System;
using System.Collections;
using log4net;
using System.Threading;
using System.Configuration;

#endregion
namespace MyLogger
{

    /// <summary>
    /// This enumeration contains the different levels of logging.
    /// </summary>
    internal enum LogSettings
    {
        Debug,
        Info,
        Warning,
        Error,
        Fatal
    }

    /// <summary>
    /// Summary description for Logger.
    /// </summary>
    public class Logger
    {
        #region Member Variables

        public static readonly string LOG_TRACE = "Trace";
        public static readonly string LOG_ERROR = "Error";

        public static string loggerFileName = null;

        private static Queue messageQueue = new Queue();
        private static Queue threadSafemessageQueue = Queue.Synchronized(messageQueue);
        private static ManualResetEvent threadSycnResetEvent = new ManualResetEvent(false);
        private static bool IsPolling = true;
        private static char loggerDelimiter = Convert.ToChar(18);
        private static log4net.Appender.FileAppender traceFileAppender = null;
        private static log4net.Appender.FileAppender errorFileAppender = null;
        private static ILog traceLog = null;
        private static ILog errorLog = null;
        private static ArrayList logList = null;
        #endregion

        #region Methods
        public Logger()
        { }

        /// <summary>
        /// This method is used to log a particular message
        /// </summary>
        /// <param name="log"></param>
        /// <param name="LogSetng"></param>
        /// <param name="Msg"></param>
        private static void LogEntry(ILog log, LogSettings LogSetng, string Msg)
        {
            try
            {
                switch (LogSetng)
                {
                    case LogSettings.Debug:
                        if (log.IsDebugEnabled)
                            log.Debug(Msg);
                        break;
                    case LogSettings.Info:
                        log.Info(Msg);
                        break;
                    case LogSettings.Warning:
                        log.Warn(Msg);
                        break;
                    case LogSettings.Error:
                        log.Error(Msg);
                        break;
                    case LogSettings.Fatal:
                        log.Fatal(Msg);
                        break;
                }
            }
            catch
            {

            }
        }

        /// <summary>
        /// This method queues up a message to log
        /// </summary>
        /// <param name="message"></param>
        /// <param name="logDestination"></param>
        public static void LogMessage(string message, string logDestination)
        {
            string logObject = message + loggerDelimiter + logDestination;
            threadSafemessageQueue.Enqueue(logObject);
            threadSycnResetEvent.Set();
        }

        /// <summary>
        /// This method is used to configure the loggers required
        /// </summary>
        /// <param name="logDestination"></param>
        private static void ConfigureLogging(string logDestination)
        {
            try
            {
                if (logList == null)
                    logList = new ArrayList();

                if (!logList.Contains(logDestination))
                {
                    logList.Add(logDestination);

                    switch (logDestination)
                    {
                        case "Trace":
                            traceFileAppender = CreateAppender(AppDomain.CurrentDomain.BaseDirectory + @"\" + loggerFileName + "_Trace.txt", LOG_TRACE);
                            CreateLogger(traceFileAppender, LOG_TRACE);
                            traceLog = LogManager.GetLogger(LOG_TRACE);
                            break;
                        case "Error":
                            errorFileAppender = CreateAppender(AppDomain.CurrentDomain.BaseDirectory + @"\" + loggerFileName + "_Error.txt", LOG_ERROR);
                            CreateLogger(errorFileAppender, LOG_ERROR);
                            errorLog = LogManager.GetLogger(LOG_ERROR);
                            break;
                    }
                }
            }
            catch
            {

            }
        }

        /// <summary>
        /// This method starts up the logging for application.
        /// It Should always run a seperate thread and NOT on MAIN APPLICATION thread.
        /// </summary>
        public static void StartLoggingThread()
        {
            Thread thread = new Thread(new ThreadStart(StartLogger));
            thread.Priority = ThreadPriority.Lowest;
            thread.Start();
        }

        private static void StartLogger()
        {
            try
            {
                string messageToLog = null;

                while (IsPolling)
                {
                    if (threadSafemessageQueue.Count == 0)
                        threadSycnResetEvent.WaitOne();

                    threadSycnResetEvent.Reset();
                    messageToLog = threadSafemessageQueue.Dequeue().ToString();

                    string[] logObject = messageToLog.Split(loggerDelimiter);

                    ConfigureLogging(logObject[1]);

                    switch (logObject[1])
                    {
                        case "Trace":
                            LogEntry(traceLog, LogSettings.Info, logObject[0]);
                            break;
                        case "Error":
                            LogEntry(errorLog, LogSettings.Info, logObject[0]);
                            break;
                    }
                }

            }
            catch
            {

            }
        }

        /// <summary>
        /// This method is used to create the appender
        /// </summary>
        /// <param name="fileName"></param>
        /// <param name="appenderName"></param>
        /// <returns></returns>
        private static log4net.Appender.FileAppender CreateAppender(string fileName, string appenderName)
        {
            log4net.Appender.FileAppender fileAppender = new log4net.Appender.FileAppender();

            log4net.Layout.PatternLayout patternLayOut = new log4net.Layout.PatternLayout();
            patternLayOut.Header = System.Environment.NewLine + "---Starts Here---" + System.Environment.NewLine;
            patternLayOut.Footer = "---Ends---";
            patternLayOut.ConversionPattern = "%d %m%n";
            patternLayOut.ActivateOptions();

            fileAppender.Layout = patternLayOut;
            fileAppender.AppendToFile = true;
            fileAppender.File = fileName;
            fileAppender.Name = appenderName;
            fileAppender.ActivateOptions();

            return fileAppender;
        }

        /// <summary>
        /// This method creates the loggers
        /// </summary>
        /// <param name="fileAppender"></param>
        /// <param name="loggerName"></param>
        private static void CreateLogger(log4net.Appender.FileAppender fileAppender, string loggerName)
        {
            log4net.Repository.Hierarchy.Hierarchy hierarchy = (log4net.Repository.Hierarchy.Hierarchy)log4net.LogManager.GetRepository();
            log4net.Repository.Hierarchy.Logger logger = (log4net.Repository.Hierarchy.Logger)hierarchy.GetLogger(loggerName);
            logger.AddAppender(fileAppender);
            hierarchy.Configured = true;
        }

        /// <summary>
        /// This method returns the todays date string.
        /// </summary>
        /// <returns></returns>
        private static string GetDateString()
        {
            string dateString = string.Empty;

            dateString = DateTime.Today.Day.ToString() + "_";
            dateString += DateTime.Today.Month + "_";
            dateString += DateTime.Today.Year.ToString();

            return dateString;
        }

        /// <summary>
        /// This method is used to shut down the logger block.
        /// It should always be called on APPLICATION.EXIT() method.
        /// </summary>
        public static void ShutDownLogger()
        {
            if (traceFileAppender != null)
                traceFileAppender.Close();
            if (errorFileAppender != null)
                errorFileAppender.Close();
        }
        #endregion
    }
}