C#日志记录设计与实现（BenXHLog）

C#日志记录设计与实现

日志记录：

日志记录在程序设计开发过程中，是非常重要的，可以供调试和记录数据，虽然说有开源的强大日志管理系统，比如apache的Log4Net，功能可谓强悍，但是有时候，不需要这么大的日志，只需要显示和文件记录就可以了，没必要用这么重的日志系统，那么就需要自己来写，如下就是一个简单的日志记录和显示模块的设计和实现，如有不足，还望见谅！废话不多，直入主题。

笨小孩日志：BenXHLog

类文件设计：

文件结构简单，类图就不画了，细心的已经发现了，这就是一个简单工厂模式，

程序代码：

Ilog接口

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace BenXH.Log.Log
{
    public interface ILog
    {
        bool IsDebugEnabled { get; }

        bool IsErrorEnabled { get; }

        bool IsFatalEnabled { get; }

        bool IsInfoEnabled { get; }

        bool IsWarnEnabled { get; }

        void Debug(bool isWriteFile,object message);

        void Debug(bool isWriteFile, object message, Exception exception);

        void DebugFormat(bool isWriteFile, string format, object arg0);

        void DebugFormat(bool isWriteFile, string format, params object[] args);

        void DebugFormat(bool isWriteFile, IFormatProvider provider, string format, params object[] args);

        void DebugFormat(bool isWriteFile, string format, object arg0, object arg1);

        void DebugFormat(bool isWriteFile, string format, object arg0, object arg1, object arg2);

        void Error(bool isWriteFile,object message);

        void Error(bool isWriteFile, object message, Exception exception);

        void ErrorFormat(bool isWriteFile, string format, object arg0);

        void ErrorFormat(bool isWriteFile, string format, params object[] args);

        void ErrorFormat(bool isWriteFile, IFormatProvider provider, string format, params object[] args);

        void ErrorFormat(bool isWriteFile, string format, object arg0, object arg1);

        void ErrorFormat(bool isWriteFile, string format, object arg0, object arg1, object arg2);

        void Fatal(bool isWriteFile, object message);

        void Fatal(bool isWriteFile, object message, Exception exception);

        void FatalFormat(bool isWriteFile, string format, object arg0);

        void FatalFormat(bool isWriteFile, string format, params object[] args);

        void FatalFormat(bool isWriteFile, IFormatProvider provider, string format, params object[] args);

        void FatalFormat(bool isWriteFile, string format, object arg0, object arg1);

        void FatalFormat(bool isWriteFile, string format, object arg0, object arg1, object arg2);

        void Info(bool isWriteFile, object message);

        void Info(bool isWriteFile, object message, Exception exception);

        void InfoFormat(bool isWriteFile, string format, object arg0);

        void InfoFormat(bool isWriteFile, string format, params object[] args);

        void InfoFormat(bool isWriteFile, IFormatProvider provider, string format, params object[] args);

        void InfoFormat(bool isWriteFile, string format, object arg0, object arg1);

        void InfoFormat(bool isWriteFile, string format, object arg0, object arg1, object arg2);

        void Warn(bool isWriteFile, object message);

        void Warn(bool isWriteFile, object message, Exception exception);

        void WarnFormat(bool isWriteFile, string format, object arg0);

        void WarnFormat(bool isWriteFile, string format, params object[] args);

        void WarnFormat(bool isWriteFile, IFormatProvider provider, string format, params object[] args);

        void WarnFormat(bool isWriteFile, string format, object arg0, object arg1);

        void WarnFormat(bool isWriteFile, string format, object arg0, object arg1, object arg2);
    }
}

ILogFactory工厂接口

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace BenXH.Log.Log
{
    public interface ILogFactory
    {
        ILog GetLog(string name);
    }
}

日志类Log 这个代码实现多一点，合并了，点开看吧

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace BenXH.Log.Log
{
    /// <summary>
    /// Console Log
    /// </summary>
    internal class Log : ILog
    {
        private string m_Name;

        private const string m_MessageTemplate = "{0}-{1}: {2}";

        private const string m_Debug = "DEBUG";

        private const string m_Error = "ERROR";

        private const string m_Fatal = "FATAL";

        private const string m_Info = "INFO";

        private const string m_Warn = "WARN";

        /// <summary>
        /// Initializes a new instance of the <see cref="Log"/> class.
        /// </summary>
        /// <param name="name">The name.</param>
        public Log(string name)
        {
            m_Name = name;
        }

        /// <summary>
        /// Gets a value indicating whether this instance is debug enabled.
        /// </summary>
        /// <value>
        ///     <c>true</c> if this instance is debug enabled; otherwise, <c>false</c>.
        /// </value>
        public bool IsDebugEnabled
        {
            get { return true; }
        }

        /// <summary>
        /// Gets a value indicating whether this instance is error enabled.
        /// </summary>
        /// <value>
        ///     <c>true</c> if this instance is error enabled; otherwise, <c>false</c>.
        /// </value>
        public bool IsErrorEnabled
        {
            get { return true; }
        }

        /// <summary>
        /// Gets a value indicating whether this instance is fatal enabled.
        /// </summary>
        /// <value>
        ///     <c>true</c> if this instance is fatal enabled; otherwise, <c>false</c>.
        /// </value>
        public bool IsFatalEnabled
        {
            get { return true; }
        }

        /// <summary>
        /// Gets a value indicating whether this instance is info enabled.
        /// </summary>
        /// <value>
        ///     <c>true</c> if this instance is info enabled; otherwise, <c>false</c>.
        /// </value>
        public bool IsInfoEnabled
        {
            get { return true; }
        }

        /// <summary>
        /// Gets a value indicating whether this instance is warn enabled.
        /// </summary>
        /// <value>
        ///     <c>true</c> if this instance is warn enabled; otherwise, <c>false</c>.
        /// </value>
        public bool IsWarnEnabled
        {
            get { return true; }
        }

        public string GetDataTimeLog(string log)
        {
            return String.Format("[{0}]>>{1}", DateTime.Now.ToString("yy-MM-dd HH:mm:ss"), log);
        }

        /// <summary>
        /// Logs the debug message.
        /// </summary>
        /// <param name="isWriteFile"></param>
        /// <param name="message">The message.</param>
        public void Debug(bool isWriteFile, object message)
        {
            string log = GetDataTimeLog(message.ToString());
            Console.WriteLine(m_MessageTemplate, m_Name, m_Debug, log);
            if (isWriteFile)
            {
                LogUtil.WriteLogFile(m_Name, m_Debug, log);
            }
        }

        /// <summary>
        /// Logs the debug message.
        /// </summary>
        /// <param name="isWriteFile"></param>
        /// <param name="message">The message.</param>
        /// <param name="exception">The exception.</param>
        public void Debug(bool isWriteFile, object message, Exception exception)
        {
            string log =GetDataTimeLog(message + Environment.NewLine + exception.Message + exception.StackTrace);
            Console.WriteLine(m_MessageTemplate, m_Name, m_Debug, log);
            if (isWriteFile)
            {
                LogUtil.WriteLogFile(m_Name, m_Debug, log);
            }
        }

        /// <summary>
        /// Logs the debug message.
        /// </summary>
        /// <param name="isWriteFile"></param>
        /// <param name="format">The format.</param>
        /// <param name="arg0">The arg0.</param>
        public void DebugFormat(bool isWriteFile, string format, object arg0)
        {
            string log = GetDataTimeLog(string.Format(format, arg0));
            Console.WriteLine(m_MessageTemplate, m_Name, m_Debug, log);
            if (isWriteFile)
            {
                LogUtil.WriteLogFile(m_Name, m_Debug, log);
            }
        }

        /// <summary>
        /// Logs the debug message.
        /// </summary>
        /// <param name="isWriteFile"></param>
        /// <param name="format">The format.</param>
        /// <param name="args">The args.</param>
        public void DebugFormat(bool isWriteFile, string format, params object[] args)
        {
            string log = GetDataTimeLog(string.Format(format, args));
            Console.WriteLine(m_MessageTemplate, m_Name, m_Debug, string.Format(format, args));
            if (isWriteFile)
            {
                LogUtil.WriteLogFile(m_Name, m_Debug, log);
            }
        }

        /// <summary>
        /// Logs the debug message.
        /// </summary>
        /// <param name="isWriteFile"></param>
        /// <param name="provider">The provider.</param>
        /// <param name="format">The format.</param>
        /// <param name="args">The args.</param>
        public void DebugFormat(bool isWriteFile, IFormatProvider provider, string format, params object[] args)
        {
            string log = GetDataTimeLog(string.Format(format, args));
            Console.WriteLine(m_MessageTemplate, m_Name, m_Debug, string.Format(provider, format, args));
            if (isWriteFile)
            {
                LogUtil.WriteLogFile(m_Name, m_Debug, log);
            }
        }

        /// <summary>
        /// Logs the debug message.
        /// </summary>
        /// <param name="isWriteFile"></param>
        /// <param name="format">The format.</param>
        /// <param name="arg0">The arg0.</param>
        /// <param name="arg1">The arg1.</param>
        public void DebugFormat(bool isWriteFile, string format, object arg0, object arg1)
        {
            string log = GetDataTimeLog(string.Format(format, arg0, arg1));
            Console.WriteLine(m_MessageTemplate, m_Name, m_Debug, log);
            if (isWriteFile)
            {
                LogUtil.WriteLogFile(m_Name, m_Debug, log);
            }
        }

        /// <summary>
        /// Logs the debug message.
        /// </summary>
        /// <param name="isWriteFile"></param>
        /// <param name="format">The format.</param>
        /// <param name="arg0">The arg0.</param>
        /// <param name="arg1">The arg1.</param>
        /// <param name="arg2">The arg2.</param>
        public void DebugFormat(bool isWriteFile, string format, object arg0, object arg1, object arg2)
        {
            string log = GetDataTimeLog(string.Format(format, arg0, arg1, arg2));
            Console.WriteLine(m_MessageTemplate, m_Name, m_Debug, log);
            if (isWriteFile)
            {
                LogUtil.WriteLogFile(m_Name, m_Debug, log);
            }
        }

        /// <summary>
        /// Logs the error message.
        /// </summary>
        /// <param name="isWriteFile"></param>
        /// <param name="message">The message.</param>
        public void Error(bool isWriteFile, object message)
        {
            string log = GetDataTimeLog(message.ToString());
            Console.WriteLine(m_MessageTemplate, m_Name, m_Error, log);
            if (isWriteFile)
            {
                LogUtil.WriteLogFile(m_Name, m_Error, log);
            }
        }

        /// <summary>
        /// Logs the error message.
        /// </summary>
        /// <param name="isWriteFile"></param>
        /// <param name="message">The message.</param>
        /// <param name="exception">The exception.</param>
        public void Error(bool isWriteFile, object message, Exception exception)
        {
            string log = GetDataTimeLog(message + Environment.NewLine + exception.Message + exception.StackTrace);
            Console.WriteLine(m_MessageTemplate, m_Name, m_Error, log);
            if (isWriteFile)
            {
                LogUtil.WriteLogFile(m_Name, m_Error,log);
            }
        }

        /// <summary>
        /// Logs the error message.
        /// </summary>
        /// <param name="isWriteFile"></param>
        /// <param name="format">The format.</param>
        /// <param name="arg0">The arg0.</param>
        public void ErrorFormat(bool isWriteFile, string format, object arg0)
        {
            string log = GetDataTimeLog(string.Format(format, arg0));
            Console.WriteLine(m_MessageTemplate, m_Name, m_Error, log);
            if (isWriteFile)
            {
                LogUtil.WriteLogFile(m_Name, m_Error, log);
            }
        }

        /// <summary>
        /// Logs the error message.
        /// </summary>
        /// <param name="isWriteFile"></param>
        /// <param name="format">The format.</param>
        /// <param name="args">The args.</param>
        public void ErrorFormat(bool isWriteFile, string format, params object[] args)
        {
            string log = GetDataTimeLog(string.Format(format, args));
            Console.WriteLine(m_MessageTemplate, m_Name, m_Error,log);
            if (isWriteFile)
            {
                LogUtil.WriteLogFile(m_Name, m_Error, log);
            }
        }

        /// <summary>
        /// Logs the error message.
        /// </summary>
        /// <param name="isWriteFile"></param>
        /// <param name="provider">The provider.</param>
        /// <param name="format">The format.</param>
        /// <param name="args">The args.</param>
        public void ErrorFormat(bool isWriteFile, IFormatProvider provider, string format, params object[] args)
        {
            string log = GetDataTimeLog(string.Format(provider, format, args));
            Console.WriteLine(m_MessageTemplate, m_Name, m_Error, log);
            if (isWriteFile)
            {
                LogUtil.WriteLogFile(m_Name, m_Error, log);
            }
        }

        /// <summary>
        /// Logs the error message.
        /// </summary>
        /// <param name="isWriteFile"></param>
        /// <param name="format">The format.</param>
        /// <param name="arg0">The arg0.</param>
        /// <param name="arg1">The arg1.</param>
        public void ErrorFormat(bool isWriteFile, string format, object arg0, object arg1)
        {
            string log = GetDataTimeLog(string.Format(format, arg0, arg1));
            Console.WriteLine(m_MessageTemplate, m_Name, m_Error,log);
            if (isWriteFile)
            {
                LogUtil.WriteLogFile(m_Name, m_Error, log);
            }
        }

        /// <summary>
        /// Logs the error message.
        /// </summary>
        /// <param name="isWriteFile"></param>
        /// <param name="format">The format.</param>
        /// <param name="arg0">The arg0.</param>
        /// <param name="arg1">The arg1.</param>
        /// <param name="arg2">The arg2.</param>
        public void ErrorFormat(bool isWriteFile, string format, object arg0, object arg1, object arg2)
        {
            string log = GetDataTimeLog(string.Format(format, arg0, arg2));
            Console.WriteLine(m_MessageTemplate, m_Name, m_Error, log);
            if (isWriteFile)
            {
                LogUtil.WriteLogFile(m_Name, m_Error, log);
            }
        }

        /// <summary>
        /// Logs the fatal error message.
        /// </summary>
        /// <param name="isWriteFile"></param>
        /// <param name="message">The message.</param>
        public void Fatal(bool isWriteFile, object message)
        {
            string log = GetDataTimeLog(message.ToString());
            Console.WriteLine(m_MessageTemplate, m_Name, m_Fatal, log);
            if (isWriteFile)
            {
                LogUtil.WriteLogFile(m_Name,m_Fatal,log);
            }
        }

        /// <summary>
        /// Logs the fatal error message.
        /// </summary>
        /// <param name="isWriteFile"></param>
        /// <param name="message">The message.</param>
        /// <param name="exception">The exception.</param>
        public void Fatal(bool isWriteFile, object message, Exception exception)
        {
            string log = GetDataTimeLog(message + Environment.NewLine + exception.Message + exception.StackTrace);
            Console.WriteLine(m_MessageTemplate, m_Name, m_Fatal, log);
            if (isWriteFile)
            {
                LogUtil.WriteLogFile(m_Name, m_Fatal, log);
            }
        }

        /// <summary>
        /// Logs the fatal error message.
        /// </summary>
        /// <param name="isWriteFile"></param>
        /// <param name="format">The format.</param>
        /// <param name="arg0">The arg0.</param>
        public void FatalFormat(bool isWriteFile, string format, object arg0)
        {
            string log = GetDataTimeLog(string.Format(format, arg0));
            Console.WriteLine(m_MessageTemplate, m_Name, m_Fatal, log);
            if (isWriteFile)
            {
                LogUtil.WriteLogFile(m_Name, m_Fatal, log);
            }
        }

        /// <summary>
        /// Logs the fatal error message.
        /// </summary>
        /// <param name="isWriteFile"></param>
        /// <param name="format">The format.</param>
        /// <param name="args">The args.</param>
        public void FatalFormat(bool isWriteFile, string format, params object[] args)
        {
            string log = GetDataTimeLog(string.Format(format, args));
            Console.WriteLine(m_MessageTemplate, m_Name, m_Fatal,log);
            if (isWriteFile)
            {
                LogUtil.WriteLogFile(m_Name, m_Fatal, log);
            }
        }

        /// <summary>
        /// Logs the fatal error message.
        /// </summary>
        /// <param name="isWriteFile"></param>
        /// <param name="provider">The provider.</param>
        /// <param name="format">The format.</param>
        /// <param name="args">The args.</param>
        public void FatalFormat(bool isWriteFile, IFormatProvider provider, string format, params object[] args)
        {
            string log = GetDataTimeLog(string.Format(provider, format, args));
            Console.WriteLine(m_MessageTemplate, m_Name, m_Fatal, log);
            if (isWriteFile)
            {
                LogUtil.WriteLogFile(m_Name, m_Fatal, log);
            }
        }

        /// <summary>
        /// Logs the fatal error message.
        /// </summary>
        /// <param name="isWriteFile"></param>
        /// <param name="format">The format.</param>
        /// <param name="arg0">The arg0.</param>
        /// <param name="arg1">The arg1.</param>
        public void FatalFormat(bool isWriteFile, string format, object arg0, object arg1)
        {
            string log = GetDataTimeLog(string.Format(format, arg0, arg1));
            Console.WriteLine(m_MessageTemplate, m_Name, m_Fatal, log);
            if (isWriteFile)
            {
                LogUtil.WriteLogFile(m_Name, m_Fatal, log);
            }
        }

        /// <summary>
        /// Logs the fatal error message.
        /// </summary>
        /// <param name="isWriteFile"></param>
        /// <param name="format">The format.</param>
        /// <param name="arg0">The arg0.</param>
        /// <param name="arg1">The arg1.</param>
        /// <param name="arg2">The arg2.</param>
        public void FatalFormat(bool isWriteFile, string format, object arg0, object arg1, object arg2)
        {
            string log = GetDataTimeLog(string.Format(format, arg0, arg1, arg2));
            Console.WriteLine(m_MessageTemplate, m_Name, m_Fatal, log);
            if (isWriteFile)
            {
                LogUtil.WriteLogFile(m_Name, m_Fatal, log);
            }
        }

        /// <summary>
        /// Logs the info message.
        /// </summary>
        /// <param name="isWriteFile"></param>
        /// <param name="message">The message.</param>
        public void Info(bool isWriteFile,object message)
        {
            string log = GetDataTimeLog(message.ToString());
            Console.WriteLine(m_MessageTemplate, m_Name, m_Info, log);
            if (isWriteFile)
            {
                LogUtil.WriteLogFile(m_Name,m_Info,log);
            }
        }

        /// <summary>
        /// Logs the info message.
        /// </summary>
        /// <param name="isWriteFile"></param>
        /// <param name="message">The message.</param>
        /// <param name="exception">The exception.</param>
        public void Info(bool isWriteFile, object message, Exception exception)
        {
            string log = GetDataTimeLog(message + Environment.NewLine + exception.Message + exception.StackTrace);
            Console.WriteLine(m_MessageTemplate, m_Name, m_Info, log);
            if (isWriteFile)
            {
                LogUtil.WriteLogFile(m_Name, m_Info, log);
            }
        }

        /// <summary>
        /// Logs the info message.
        /// </summary>
        /// <param name="isWriteFile"></param>
        /// <param name="format">The format.</param>
        /// <param name="arg0">The arg0.</param>
        public void InfoFormat(bool isWriteFile, string format, object arg0)
        {
            string log = GetDataTimeLog(string.Format(format, arg0));
            Console.WriteLine(m_MessageTemplate, m_Name, m_Info, log);
            if (isWriteFile)
            {
                LogUtil.WriteLogFile(m_Name, m_Info, log);
            }
        }

        /// <summary>
        /// Logs the info message.
        /// </summary>
        /// <param name="isWriteFile"></param>
        /// <param name="format">The format.</param>
        /// <param name="args">The args.</param>
        public void InfoFormat(bool isWriteFile, string format, params object[] args)
        {
            string log = GetDataTimeLog(string.Format(format, args));
            Console.WriteLine(m_MessageTemplate, m_Name, m_Info, log);
            if (isWriteFile)
            {
                LogUtil.WriteLogFile(m_Name, m_Info, log);
            }
        }

        /// <summary>
        /// Logs the info message.
        /// </summary>
        /// <param name="isWriteFile"></param>
        /// <param name="provider">The provider.</param>
        /// <param name="format">The format.</param>
        /// <param name="args">The args.</param>
        public void InfoFormat(bool isWriteFile, IFormatProvider provider, string format, params object[] args)
        {
            string log = GetDataTimeLog(string.Format(provider, format, args));
            Console.WriteLine(m_MessageTemplate, m_Name, m_Info, log);
            if (isWriteFile)
            {
                LogUtil.WriteLogFile(m_Name, m_Info, log);
            }
        }

        /// <summary>
        /// Logs the info message.
        /// </summary>
        /// <param name="isWriteFile"></param>
        /// <param name="format">The format.</param>
        /// <param name="arg0">The arg0.</param>
        /// <param name="arg1">The arg1.</param>
        public void InfoFormat(bool isWriteFile, string format, object arg0, object arg1)
        {
            string log = GetDataTimeLog(string.Format(format, arg0, arg1));
            Console.WriteLine(m_MessageTemplate, m_Name, m_Info, log);
            if (isWriteFile)
            {
                LogUtil.WriteLogFile(m_Name, m_Info, log);
            }
        }

        /// <summary>
        /// Logs the info message.
        /// </summary>
        /// <param name="isWriteFile"></param>
        /// <param name="format">The format.</param>
        /// <param name="arg0">The arg0.</param>
        /// <param name="arg1">The arg1.</param>
        /// <param name="arg2">The arg2.</param>
        public void InfoFormat(bool isWriteFile, string format, object arg0, object arg1, object arg2)
        {
            string log = GetDataTimeLog(string.Format(format, arg0, arg1, arg2));
            Console.WriteLine(m_MessageTemplate, m_Name, m_Info,log);
            if (isWriteFile)
            {
                LogUtil.WriteLogFile(m_Name, m_Info, log);
            }
        }

        /// <summary>
        /// Logs the warning message.
        /// </summary>
        /// <param name="isWriteFile"></param>
        /// <param name="message">The message.</param>
        public void Warn(bool isWriteFile,object message)
        {
            string log = GetDataTimeLog(message.ToString());
            Console.WriteLine(m_MessageTemplate, m_Name, m_Warn, log);
            if (isWriteFile)
            {
                LogUtil.WriteLogFile(m_Name,m_Warn,log);
            }
        }

        /// <summary>
        /// Logs the warning message.
        /// </summary>
        /// <param name="isWriteFile"></param>
        /// <param name="message">The message.</param>
        /// <param name="exception">The exception.</param>
        public void Warn(bool isWriteFile, object message, Exception exception)
        {
            string log = GetDataTimeLog(message + Environment.NewLine + exception.Message + exception.StackTrace);
            Console.WriteLine(m_MessageTemplate, m_Name, m_Warn, log);
            if (isWriteFile)
            {
                LogUtil.WriteLogFile(m_Name, m_Warn, log);
            }
        }

        /// <summary>
        /// Logs the warning message.
        /// </summary>
        /// <param name="isWriteFile"></param>
        /// <param name="format">The format.</param>
        /// <param name="arg0">The arg0.</param>
        public void WarnFormat(bool isWriteFile, string format, object arg0)
        {
            string log = GetDataTimeLog(string.Format(format, arg0));
            Console.WriteLine(m_MessageTemplate, m_Name, m_Warn, log);
            if (isWriteFile)
            {
                LogUtil.WriteLogFile(m_Name, m_Warn, log);
            }
        }

        /// <summary>
        /// Logs the warning message.
        /// </summary>
        /// <param name="isWriteFile"></param>
        /// <param name="format">The format.</param>
        /// <param name="args">The args.</param>
        public void WarnFormat(bool isWriteFile, string format, params object[] args)
        {
            string log = GetDataTimeLog(string.Format(format, args));
            Console.WriteLine(m_MessageTemplate, m_Name, m_Warn, log);
            if (isWriteFile)
            {
                LogUtil.WriteLogFile(m_Name, m_Warn, log);
            }
        }

        /// <summary>
        /// Logs the warning message.
        /// </summary>
        /// <param name="isWriteFile"></param>
        /// <param name="provider">The provider.</param>
        /// <param name="format">The format.</param>
        /// <param name="args">The args.</param>
        public void WarnFormat(bool isWriteFile, IFormatProvider provider, string format, params object[] args)
        {
            string log = GetDataTimeLog(string.Format(provider, format, args));
            Console.WriteLine(m_MessageTemplate, m_Name, m_Warn, log);
            if (isWriteFile)
            {
                LogUtil.WriteLogFile(m_Name, m_Warn, log);
            }
        }

        /// <summary>
        /// Logs the warning message.
        /// </summary>
        /// <param name="isWriteFile"></param>
        /// <param name="format">The format.</param>
        /// <param name="arg0">The arg0.</param>
        /// <param name="arg1">The arg1.</param>
        public void WarnFormat(bool isWriteFile, string format, object arg0, object arg1)
        {
            string log = GetDataTimeLog(string.Format(format, arg0, arg1));
            Console.WriteLine(m_MessageTemplate, m_Name, m_Warn, log);
            if (isWriteFile)
            {
                LogUtil.WriteLogFile(m_Name, m_Warn, log);
            }
        }

        /// <summary>
        /// Logs the warning message.
        /// </summary>
        /// <param name="isWriteFile"></param>
        /// <param name="format">The format.</param>
        /// <param name="arg0">The arg0.</param>
        /// <param name="arg1">The arg1.</param>
        /// <param name="arg2">The arg2.</param>
        public void WarnFormat(bool isWriteFile, string format, object arg0, object arg1, object arg2)
        {
            string log = GetDataTimeLog(string.Format(format, arg0, arg1, arg2));
            Console.WriteLine(m_MessageTemplate, m_Name, m_Warn, log);
             if (isWriteFile)
            {
                LogUtil.WriteLogFile(m_Name, m_Warn, log);
            }
        }
    }
}

LogFactory 日志工厂

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace BenXH.Log.Log
{
    public class LogFactory:ILogFactory
    {
        /// <summary>
        /// 创建日志实例
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public ILog GetLog(string name)
        {
            return new Log(name);
        }
    }
}

 LogUtil日志格式化

using BenXH.Log.Common;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace BenXH.Log.Log
{
    internal class LogUtil
    {
        /// <summary>
        /// 格式式化Log信息
        /// </summary>
        /// <param name="format"></param>
        /// <param name="name"></param>
        /// <param name="logType"></param>
        /// <param name="log"></param>
        /// <returns></returns>
        private static string GetLogString(string name, string logType, string log)
        {
            return String.Format("[{0}]{1}-{2}: {3}", DateTime.Now.ToString("HH:mm:ss"),name, logType, log);
        }

        /// <summary>
        /// 获得日志要保存的路径
        /// </summary>
        /// <param name="name"></param>
        /// <param name="logType"></param>
        /// <returns></returns>
        private static string GetLogPath(string name, string logType)
        {
            string path = AppDomain.CurrentDomain.BaseDirectory+"Log";
            if (!System.IO.Directory.Exists(path))
            {
                System.IO.Directory.CreateDirectory(path);
            }

            return System.IO.Path.Combine(path,String.Format("{0}_{1}_{2}.log",DateTime.Now.ToString("yyyy-MM-dd"),name,logType));
        }

        public static void WriteLogFile(string name, string logType, string log)
        {
            string logPath = GetLogPath(name, logType);

            FileUtil.WriteAppend(logPath,log);
        }
    }
}

最后就是一个日志信息的显示和文件的存储   FileUtil

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;

namespace BenXH.Log.Common
{
    public static class FileUtil
    {
        /// <summary>
        /// 追加内容到指定文件中
        /// </summary>
        /// <param name="filePath"></param>
        /// <param name="content"></param>
        public static void WriteAppend(string filePath, string content)
        {
            WriteAppend(filePath,new string[]{content});
        }

        public static void WriteAppend(string filePath, string[] contents)
        {
            //System.IO.StreamWriter sr = new System.IO.StreamWriter(filePath, true);
            //foreach (string c in contents)
            //{
            //    sr.WriteLine(c);
            //}
            //sr.Flush();
            //sr.Close();

            using (FileStream fs = new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.Write, FileShare.ReadWrite))
            {
                fs.Seek(fs.Length, SeekOrigin.Current);

                string content = String.Join(Environment.NewLine, contents) + Environment.NewLine;

                byte[] data = System.Text.Encoding.UTF8.GetBytes(content);

                fs.Write(data, 0, data.Length);

                fs.Close();
            }
        }
    }
}

测试代码：

Test.cs

 class Test
    {
        static void Main(string[] args)
        {
            //日志BenXH的Debug信息
            new BenXH.Log.Log.LogFactory().GetLog("BenXH").Debug(true, "Hello");
            new BenXH.Log.Log.LogFactory().GetLog("BenXH").Debug(true, "World");

            //日志BenXH的info信息
            new BenXH.Log.Log.LogFactory().GetLog("BenXH").Info(true, "Hello");
            new BenXH.Log.Log.LogFactory().GetLog("BenXH").Info(true, "BenXH");
            Console.Read();
        }
    }

运行结果：

文件：程序运行根目录下Log文件夹

Log文件夹下新创建俩个文件DEBUG和INFO

文件：2017-07-29_BenXH_DEBUG.log

文件内容

[17-07-29 16:01:26]>>Hello
[17-07-29 16:01:26]>>World

文件：2017-07-29_BenXH_INFO.log

文件内容：

[17-07-29 16:01:26]>>Hello
[17-07-29 16:01:26]>>BenXH

工程源文件下载