日志记录器

项目名称 : Logger

项目介绍

　　适用范围：异常日志，操作日志，交互日志等等 各种日志

　　日志存储方式：SqlServer , MySql, Oracle, Text(即文本文件)

　　日志写入类型 ：Immediate(即时)  Queue(队列)

　　日志配置文件:LogConfig.xml

1.配置文件介绍

　　

<?xml version="1.0" encoding="utf-8" ?>
<configurations>
  <setting model="immediate" writer="sqlserver" connectionstring="server=.;database=Log;uid=sa;password=sqlpass;"></setting>
  <sections>
    <section type="LogService.Domain.ExceptionLog" catalog="ExceptionLog">
      <setting model="queue" writer="sqlserver" maxcount="1" interval="2" connectionstring="server=.;database=Log;uid=sa;password=sqlpass;"></setting>
      <mapping property="Message"></mapping>
      <mapping property="Source"></mapping>
      <mapping property="TargetSite"></mapping>
      <mapping property="StackTrace"></mapping>
      <mapping property="ErrorTime"></mapping>
      <mapping property="Remark"></mapping>
    </section>
  </sections>
</configurations>

 文件介绍:

　　sections节点:主要起到分类的作用,比如一个异常日志就需要一个sections

　　section节点:日志分类属性节点

　　　　　　type:日志实体类型的命名空间

　　　　　　catalog:写入数据的表名

　　setting节点: 主要设置写入类型,写入方式以及写入数据链接（这个节点在sections下面如果则节点不存在则采购最跟节点下面做为默认值）

　　      model(写入类型):queue(队列的方式写入)

　　　　　　如果model为queue类型 则需要设置2个额外的属性 

　　　　　　maxcount  :当内存存储日志条数到达maxcount条时则写入数据库或者文件

　　　　　　interval:如果内存存储日志条数没有到达maxcount时间 但是时间间隔为interval秒时也会写入数据库或文件

　　　　writer(写入方式):SqlServer , MySql, Oracle

　　　　connectionstring(数据库链接):如果是写入数据则需要配置这个数据

　　　　mapping : 日志实体对应字段描述

　　　　　　property:字段名称

　　　　

2.服务层介绍(LogService)

　　服务层即指日志组件提供给外界写入日志的方法

　　该类只公布1个方法，WriteLog  写入类型

　　该方法提供3个重置

　　 WriteLog(object item) 此方法会根据Objcet类型的命名空间去读取配置 并且解析出日志实体对象

　　 WriteLog(string content)  写入文本日志

　　 WriteLog(string content, string path)  写入文本日志并指定日志路径

    /// <summary>
    /// 日志记录器
    /// </summary>
    public class LogService
    {
        /// <summary>
        /// 添加日志
        /// </summary>
        /// <param name="item">日志内容</param>
        /// <returns>返回记录结果 成功?true:false</returns>
        public static bool WriteLog(object item)
        {
            return item != null && Allocator.Intance.Execute(item);
        }

        /// <summary>
        /// 记录文本日志
        /// </summary>
        /// <param name="content">日志内容</param>
        /// <returns>返回记录结果 成功?true:false</returns>
        public static bool WriteLog(string content) 
        {
            return WriteLog(content, Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Logs"));
        }
        /// <summary>
        /// 记录文本日志
        /// </summary>
        /// <param name="content">日志内容</param>
        /// <param name="path">日志路径</param>
        /// <returns>返回记录结果 成功?true:false</returns>
        public static bool WriteLog(string content, string path) 
        {
            return Factory.GetTextWriter(path).WriteLog(DateTime.Now.ToString("日志时间:yyyy-MM-dd HH:mm:ss fff  ") + content + Environment.NewLine);
        }

        internal static void WirteLogError(Exception exception) 
        {
            string content = string.Format("记录日志失败...消息:{0} 地址：{1} 堆栈：{2}", exception.Message, exception.TargetSite, exception.StackTrace);
            WriteLog(content);
        }
    }

 2.解析配置文件介绍(Config)

　　主要是把刚刚介绍的那几个属性解析出来　

　　解析成Dictionary<string, ConfigSection>联系 key就是对象 type 即一个分类(列如一个异常日志)

　　ConfigSection : 该日志的基本信息

　　　　　TypeName : 类型名称

　　　　　Catalog：表名

　　　　　Setting : 设置信息(数据库链接，写入数据库类型, 写入时间间隔 ，写入最大条数)　　　　　　

　　　　　Mapping : 日志实体信息　

　　

    internal class ConfigSection
    {
        internal ConfigSection(string typeName,string catalog,Setting setting,List<Mapping> mappings) 
        {
            TypeName = typeName;
            Catalog = catalog;
            Setting = setting;
            Mappings = mappings;
        }
        internal string TypeName { get; private set; }
        internal string Catalog { get; private set; }
        internal Setting Setting { get; private set; }
        internal List<Mapping> Mappings { get; private set; }
    }

    internal class ConfigSection
    {
        internal ConfigSection(string typeName,string catalog,Setting setting,List<Mapping> mappings) 
        {
            TypeName = typeName;
            Catalog = catalog;
            Setting = setting;
            Mappings = mappings;
        }
        internal string TypeName { get; private set; }
        internal string Catalog { get; private set; }
        internal Setting Setting { get; private set; }
        internal List<Mapping> Mappings { get; private set; }
    }

Mapping

 　　　 解析代码LocalXMLLoader

    internal class LocalXMLLoader:Loader
    {
        private readonly string _path;
        internal LocalXMLLoader(string path) 
        {
            _path = path;
        }

        internal override Dictionary<string, ConfigSection> Execute()
        {
            Dictionary<string, ConfigSection> result = new Dictionary<string, ConfigSection>();
            XmlDocument doc = new XmlDocument();
            doc.Load(this._path);
            XmlNode defaultSettingNode = doc.SelectSingleNode("configurations/setting");
            Setting defaultSetting = ParseSetting(defaultSettingNode);
            XmlNodeList sectionNodes = doc.SelectNodes("configurations/sections/section");
            if (sectionNodes == null) return result;
            foreach (XmlNode sectionNode in sectionNodes)
            {
                if (sectionNode.Attributes == null) continue;
                string typeName = GetAttribute(sectionNode.Attributes["type"]);
                string catalog = GetAttribute(sectionNode.Attributes["catalog"]);
                Setting setting = ParseSetting(sectionNode.SelectSingleNode("setting"),defaultSetting);
                List<Mapping> mappings = ParseMappings(sectionNode.SelectNodes("mapping"));
                ConfigSection section = new ConfigSection(typeName, catalog, setting, mappings);
                result.Add(section.TypeName, section);
            }
            return result;
        }
        private static Setting ParseSetting(XmlNode node) 
        {
            if (node == null || node.Attributes == null) return null;
            string model = GetAttribute(node.Attributes["model"]);
            //当在maxcount分钟内有大于等于interval条数据的时候才去写入数据库
            string maxCount = GetAttribute(node.Attributes["maxcount"]);
            string interval = GetAttribute(node.Attributes["interval"]);
            string writer = GetAttribute(node.Attributes["writer"]);
            string connectionString = GetAttribute(node.Attributes["connectionstring"]);
            return new Setting(model, maxCount, interval, writer, connectionString);
        }
        private static Setting ParseSetting(XmlNode node, Setting defaultSetting) 
        {
            Setting setting = ParseSetting(node);
            if (setting != null)
            {
                return new Setting(
                    string.IsNullOrWhiteSpace(setting.Model) ? defaultSetting.Model : setting.Model,
                    string.IsNullOrWhiteSpace(setting.MaxCount) ? defaultSetting.MaxCount : setting.MaxCount,
                    string.IsNullOrWhiteSpace(setting.Interval) ? defaultSetting.Interval : setting.Interval,
                    string.IsNullOrWhiteSpace(setting.Writer) ? defaultSetting.Writer : setting.Writer,
                    string.IsNullOrWhiteSpace(setting.ConnectionString) ? defaultSetting.ConnectionString : setting.ConnectionString);
            }
            return defaultSetting;
        }
        private static List<Mapping> ParseMappings(XmlNodeList nodes) 
        {
            List<Mapping> result = new List<Mapping>();
            if (nodes != null)
            {
                foreach (XmlNode node in nodes)
                {
                    if (node.Attributes == null) continue;
                    string property = GetAttribute(node.Attributes["property"]);
                    string name = GetAttribute(node.Attributes["name"]);
                    string format = GetAttribute(node.Attributes["format"]);
                    result.Add(new Mapping(property, name, format));
                }
            }
            return result;
        }
        private static string GetAttribute(XmlAttribute attr) 
        {
            return GetAttribute(attr, string.Empty);
        }
        private static string GetAttribute(XmlAttribute attr, string defaultValue)
        {
            return attr == null ? defaultValue : attr.Value;
        }
    }

 3.写入存储方式(Writer)

　　这里先暂时不考虑Context这个类型后面会讲解这个类型怎么来

　　写入抽象一个类型出来提供2个写入方法

　　单条写入

　　internal abstract void Execute(Context log);

　　批量写入
　　internal abstract void Execute(List<Context> logs);

　　DBWriter数据库写入方式

    internal abstract class DBWriter : Writer
    {
        private readonly string _connectionString = string.Empty;
        private readonly string _provider = string.Empty;
        protected readonly string Catalog = string.Empty;
        protected DBWriter(string provider, string connectionString, string cataLog)
        {
            _provider = provider;
            _connectionString = connectionString;
            Catalog = cataLog;
        }
        internal override void Execute(Context log)
        {
            if (log == null || log.Content == null || log.Content.Count == 0) return;
            try
            {
                using (DbConnection conn = GetConnection())
                {
                    using (DbCommand cmd = conn.CreateCommand())
                    {
                        PrepareInsert(cmd, log);
                        cmd.ExecuteNonQuery();
                    }
                }
            }
            catch (Exception ex)
            {
                LogService.WirteLogError(ex);
            }
        }

        internal override void Execute(List<Context> logs)
        {
            try
            {
                using (DbConnection conn = GetConnection())
                {
                    using (DbCommand cmd = conn.CreateCommand())
                    {
                        PrepareInsert(cmd, logs);
                        cmd.ExecuteNonQuery();
                    }
                }
            }
            catch (Exception ex)
            {
                LogService.WirteLogError(ex);
            }
        }

        private DbConnection GetConnection()
        {
            DbProviderFactory dbf = DbProviderFactories.GetFactory(_provider);
            DbConnection conn = dbf.CreateConnection();
            if (conn == null) return null;
            conn.ConnectionString = _connectionString;
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }
            return conn;
        }
        protected abstract void PrepareInsert(DbCommand cmd, Context log);
        protected abstract void PrepareInsert(DbCommand cmd, List<Context> logs);
    }

　　Oracle数据库写入

    internal class OracleWriter:DBWriter
    {
        internal OracleWriter(string connectionString, string catalog) : base("System.Data.OracleClient", connectionString, catalog) { }
        protected override void PrepareInsert(DbCommand cmd, Context log)
        {
            const string sqlFormat = "INSERT INTO {0} ({1}) VALUES ({2})";
            var fields = new StringBuilder();
            var parameters = new StringBuilder();

            foreach (DataItem di in log.Content)
            {
                fields.AppendFormat("{0},", di.Name);
                parameters.AppendFormat(":{0},", di.Name);
                var p = cmd.CreateParameter();
                p.ParameterName = di.Name;
                if (di.Value == null)
                {
                    p.Value = System.DBNull.Value;
                }
                else if (di.Value is System.Enum)
                {
                    p.Value = di.Value.GetHashCode();
                }
                else
                {
                    p.Value = di.Value;
                }
                cmd.Parameters.Add(p);
            }
            cmd.CommandText = string.Format(sqlFormat,
                Catalog,
                fields.Remove(fields.Length - 1, 1),
                parameters.Remove(parameters.Length - 1, 1));
        }

        protected override void PrepareInsert(DbCommand cmd, List<Context> logs)
        {
            const string sqlFormat = "INSERT INTO {0} ({1}) ({2})";
            const string fieldFormat = " SELECT {0} FROM DUAL UNION ALL";
            var fields = new StringBuilder();
            var parameters = new StringBuilder();
            int index = 1;
            foreach (Context log in logs)
            {
                if (log.Content == null) continue;
                var tempParam = new StringBuilder();
                foreach (var di in log.Content)
                {
                    tempParam.AppendFormat(":{0}{1},", di.Name, index);
                    var p = cmd.CreateParameter();
                    p.ParameterName = di.Name + index;
                    if (di.Value == null)
                    {
                        p.Value = System.DBNull.Value;
                    }
                    else if (di.Value is System.Enum)
                    {
                        p.Value = di.Value.GetHashCode();
                    }
                    else
                    {
                        p.Value = di.Value;
                    }
                    cmd.Parameters.Add(p);
                }
                if (fields.Length == 0)
                {
                    foreach (var di in log.Content)
                    {
                        fields.Append(di.Name + ",");
                    }
                }
                index++;
                parameters.AppendFormat(fieldFormat, tempParam.Remove(tempParam.Length - 1, 1));
            }
            cmd.CommandText = string.Format(sqlFormat,
                Catalog,
                fields.Remove(fields.Length - 1, 1),
                parameters.Remove(parameters.Length - 10, 10));
        }
    }

　　SqlService数据写入

    internal class SqlServiceWriter:DBWriter
    {
        internal SqlServiceWriter(string connectionString, string cataLog) : base("System.Data.SqlClient", connectionString, cataLog) { }
        protected override void PrepareInsert(DbCommand cmd, Context log)
        {
            const string sqlFormat = "INSERT INTO {0} ({1}) VALUES ({2});";
            StringBuilder fields = new StringBuilder();
            StringBuilder parameters = new StringBuilder();

            foreach (DataItem di in log.Content)
            {
                fields.AppendFormat("{0},", di.Name);
                parameters.AppendFormat("@{0},", di.Name);
                DbParameter p = cmd.CreateParameter();
                p.ParameterName = di.Name;
                if (di.Value == null)
                {
                    p.Value = DBNull.Value;
                }
                else if (di.Value is Enum)
                {
                    p.Value = di.Value.GetHashCode();
                }
                else 
                {
                    p.Value = di.Value;
                }
                cmd.Parameters.Add(p);
            }
            cmd.CommandText = string.Format(sqlFormat,
                   Catalog,
                   fields.Remove(fields.Length - 1, 1),
                   parameters.Remove(parameters.Length - 1, 1));
        }

        protected override void PrepareInsert(DbCommand cmd, List<Context> logs)
        {
            const string sqlFormat = "INSERT INTO {0} ({1}) ({2});";
            const string fieldFormat = " SELECT {0} UNION ALL";
            StringBuilder fields = new StringBuilder();
            StringBuilder parameters = new StringBuilder();
            int index = 1;
            foreach (Context log in logs)
            {
                if (log.Content == null) continue;
                StringBuilder tempParam = new StringBuilder();
                foreach (DataItem di in log.Content)
                {
                    tempParam.AppendFormat("@{0}{1},", di.Name, index);
                    DbParameter p = cmd.CreateParameter();
                    p.ParameterName = di.Name + index;
                    if (di.Value == null)
                    {
                        p.Value = DBNull.Value;
                    }
                    else if (di.Value is Enum)
                    {
                        p.Value = di.Value.GetHashCode();
                    }
                    else 
                    {
                        p.Value = di.Value;
                    }
                    cmd.Parameters.Add(p);
                }
                if (fields.Length == 0)
                {
                    foreach (DataItem di in log.Content)
                    {
                        fields.Append(di.Name + ",");
                    }
                    index++;
                    parameters.AppendFormat(fieldFormat, tempParam.Remove(tempParam.Length - 1, 1));
                }
            }
            cmd.CommandText = string.Format(sqlFormat,
                Catalog,
                fields.Remove(fields.Length - 1, 1),
                parameters.Remove(parameters.Length - 10, 10));

        }
    }
}

　　文本文件方式写入

    internal class TextWriter:Writer
    {
        private const long LogFileMaxLength = 1024 * 1024 * 1;
        private readonly string _fileName = string.Empty;
        internal TextWriter(string fineName) 
        {
            _fileName = fineName;
        }
        internal override void Execute(Context log)
        {
            try
            {
                WriteLog(GetLogContent(log) + Environment.NewLine);
            }
            catch (Exception ex)
            {
                LogService.WirteLogError(ex);
            }
        }
        internal override void Execute(List<Context> logs)
        {
            try
            {
                StringBuilder sbContent = new StringBuilder();
                foreach (Context log in logs)
                {
                    sbContent.AppendLine(GetLogContent(log));
                }
                WriteLog(sbContent.ToString());
            }
            catch (Exception ex)
            {
                LogService.WirteLogError(ex);
            }
        }
        internal bool WriteLog(string logInfo) 
        {
            if (string.IsNullOrWhiteSpace(logInfo)) 
            {
                return true;
            }
            DateTime timeStamp = DateTime.Now;
            string path = GetFileMainPath(timeStamp);
            FileInfo lastFile = GetLastAccessFile(path);
            FileStream fileStream = GetFileStream(lastFile, path, timeStamp);
            if (fileStream == null) 
            {
                return false;
            }
            try
            {
                StreamWriter sw = new StreamWriter(fileStream);
                sw.BaseStream.Seek(0, SeekOrigin.End);
                sw.Write(logInfo);
                sw.Flush();
                sw.Close();
            }
            catch 
            {
                return false;
            }
            finally
            {
                fileStream.Close();
                fileStream.Dispose();
            }
            return true;
        }
        private static FileInfo GetLastAccessFile(string path) 
        {
            FileInfo result = null;
            DirectoryInfo direcInfo = new DirectoryInfo(path);
            //查找目录中最后的创建的文档
            if (direcInfo.Exists)
            {
                FileInfo[] fileInfos = direcInfo.GetFiles();
                foreach (FileInfo fileinfo in fileInfos)
                {
                    if (result == null)
                    {
                        result = fileinfo;
                    }
                    else if (result.CreationTime < fileinfo.CreationTime) 
                    {
                        result = fileinfo;
                    }
                }
            }
            else 
            {
                direcInfo.Create();
            }
            return result;
        }
        private static FileStream GetFileStream(FileInfo fileInfo, string path, DateTime timeStamp) 
        {
            FileStream result = null;
            // 没找到则创建一个新日志文件
            // 如果文件大于100M，则新创建一个文件
            // 如果文件无法打开，则新创建一个文件
            if (fileInfo == null)
            {
                try
                {
                    result = CreateFile(path, GetFileMainName(timeStamp));
                }
                catch (Exception)
                {
                    return null;
                }
            }
            else if (IsOutOfFileMaxLength(fileInfo.Length))
            {
                result = CreateFile(path, GetFileMainName(timeStamp));
            }
            else 
            {
                try
                {
                    result = fileInfo.OpenWrite();
                }
                catch
                {
                    result = CreateFile(path, GetFileMainName(timeStamp));
                }
            }
            return result;
        }
        private static bool IsOutOfFileMaxLength(long fileLength) 
        {
            return fileLength > LogFileMaxLength;   
        }
        private static string GetLogContent(Context log)
        {
            StringBuilder result = new StringBuilder();
            result.AppendFormat("日志时间：{0} ", log.Time.ToString("yyyy-MM-dd HH:mm:ss fff"));
            if (log.Content != null)
            {
                foreach (DataItem di in log.Content)
                {
                    string value;
                    if (di.Value is DateTime)
                    {
                        if (di.Format == null || di.Format.Trim().Length == 0)
                        {
                            value = ((DateTime)di.Value).ToString("yyyy-MM-dd HH:mm:ss fff");
                        }
                        else
                        {
                            value = ((DateTime)di.Value).ToString(di.Format);
                        }
                    }
                    else 
                    {
                        value = (di.Value ?? "").ToString();
                    }
                    result.AppendFormat("{0}:{1}  ", di.Name, value);
                }
            }
            result.AppendLine();
            return result.ToString();
        }
        private static FileStream CreateFile(string path, string fileName) 
        {
            return File.Create(string.Format(@"{0}{1}.log",path,fileName));
        }

        private string GetFileMainPath(DateTime timeStamp) 
        {
            return Path.Combine(_fileName, timeStamp.ToString("yyyyMMdd"));
        }
        private static string GetFileMainName(DateTime timeStamp) 
        {
            return timeStamp.ToString("HHmmss");
        }
    }

4.写入类型(Processor)

　　处理方式:Immediate(即时写入)则非常简单只需要直接调用写入方法即可

    internal class ImmediateProcessor:Processor
    {
        internal ImmediateProcessor(Writer.Writer writer) : base(writer) { }
        internal override void Inject(Context log)
        {
            LogWriter.Execute(log);
        }
    }

      处理方式:Queue(队列写入) 队列写入实现原理 则是新开一条线程来存储即将写入的日志 当写入满足配置文件配置的 maxcount  或者 interval 2个属性的任意一个条件则写入数据库

    internal class QueueProcessor:Processor
    {
        private readonly uint _maxCount;
        private readonly uint _interval;
        private readonly Queue<Context> _logs;
        private readonly object _locker = new object();
        private bool _stoped = true;
        private DateTime _lastFlusTime = DateTime.Now;
        internal QueueProcessor(Writer.Writer write, uint maxCount, uint interval) 
            :base(write)
        {
            _maxCount = maxCount;
            _interval = interval;
            _logs = new Queue<Context>();
        }
        internal override void Inject(Context log)
        {
            lock (_locker)
            {
                _logs.Enqueue(log);
                SetThread();
            }
        }

        private void SetThread()
        {
            if (!_stoped) return;
            _stoped = false;
            ThreadPool.QueueUserWorkItem(Run);
        }
        private void Run(object state) 
        {
            while (!_stoped)
            {
                if (RequireFlush())
                {
                    FlushData();
                    SetFlushInfo();
                }
                Thread.Sleep(50);
            }
        }
        private bool RequireFlush()
        {
            return _logs.Count >= _maxCount || IsExpired();
        }

        private bool IsExpired()
        {
            return (DateTime.Now - _lastFlusTime).TotalMinutes >= _interval;
        }

        private void FlushData()
        {
            LogWriter.Execute(GetData());
        }

        private List<Context> GetData()
        {
            List<Context> result = new List<Context>();
            lock (_locker)
            {
                while (result.Count < _maxCount && _logs.Count > 0)
                {
                    result.Add(_logs.Dequeue());
                }
            }
            return result;
        }

        private void SetFlushInfo()
        {
            _lastFlusTime = DateTime.Now;
            if (_logs.Count == 0)
            {
                _stoped = true;
            }
        }
    }

 5.服务层创建日志并调用

　Allocator类来联系当前上下文

　Intance属性:为单列模式 使用单列模式创建该类型对象

　bool Execute(object item) 执行方法根据 item 取出配置文件信息 并且创建Context对象

　Processor GetProcessor(ConfigSection section, string key) 方法根据配置文件信息创建出使用那种写入方式跟数据库

　创建方式通过Factory类(工厂方法实现)

Factory

    internal class Factory
    {
        internal static Processor.Processor CreateProcessor(Writer.Writer writer, Setting setting) 
        {
            Processor.Processor result = null;
            if (setting == null) return null;
            switch ((setting.Model ?? "").ToLower())
            {
                case "queue":
                    result = new QueueProcessor(writer, GetUnit(setting.MaxCount, 10), GetUnit(setting.Interval, 2));
                    break;
                case "immediate":
                    result = new ImmediateProcessor(writer);
                    break;
                        
            }
            return result;
        }
        private static uint GetUnit(string value, uint defaultVaule) 
        {
            uint result;
            if (!uint.TryParse(value,out result))
            {
                result = defaultVaule;
            }
            return result;
        }
        private static readonly Dictionary<string, Writer.Writer> Writers = new Dictionary<string, Writer.Writer>();
        internal static Writer.Writer CreateWriter(ConfigSection section) 
        {
            if (section == null) return null;
            if (section.Setting == null) return null;
            string key = section.Setting.Writer + section.Catalog;
            if (Writers.ContainsKey(key))
            {
                return Writers[key];
            }
            Writer.Writer writer = null;
            switch ((section.Setting.Writer ?? "").ToLower())
            {
                case "text":
                    writer = new TextWriter(section.Catalog);
                    break;
                case "oracle":
                    writer = new OracleWriter(section.Setting.ConnectionString,section.Catalog);
                    break;
                case "sqlserver":
                    writer = new SqlServiceWriter(section.Setting.ConnectionString, section.Catalog);
                    break;
            }
            Writers.Add(key, writer);
            return writer;
        }
        private static readonly Dictionary<string, TextWriter> TextWriters = new Dictionary<string, TextWriter>();
        internal static TextWriter GetTextWriter(string path) 
        {
            TextWriter writer;
            if (TextWriters.TryGetValue(path, out writer)) return writer;
            writer = new TextWriter(path);
            TextWriters.Add(path, writer);
            return writer;
        }
        internal static Loader CreateLoader() 
        {
            //return new LocalXMLLoader(System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "LogConfig.xml"));
            return new LocalXMLLoader(System.Configuration.ConfigurationManager.AppSettings["LogConfig"]);
        }
    }

    /// <summary>
    /// 日志处理分配器
    /// </summary>
    internal class Allocator
    {
        private static readonly object InstanceLocker = new object();
        private static Allocator _intance;

        /// <summary>
        /// 分配器实例
        /// </summary>
        internal static Allocator Intance 
        {
            get 
            {
                if (_intance == null)
                {
                    lock (InstanceLocker)
                    {
                        if (_intance == null)
                        {
                            _intance = new Allocator();
                        }
                    }
                }
                return _intance;
            }
        }

        private readonly Dictionary<string, Processor.Processor> _processors;
        private Allocator() {
            _processors = new Dictionary<string, Processor.Processor>();
        }
        /// <summary>
        /// 分配日志
        /// </summary>
        /// <param name="item">日志信息</param>
        /// <returns>成功?true:false</returns>
        internal bool Execute(object item) 
        {
            DateTime logTime = DateTime.Now;
            string key = item.GetType().FullName;
            ConfigSection section = ConfigCollections.Instance[key];
            if (section == null)
            {
                LogService.WriteLog("未找到[" + key + "]的配置信息");
            }
            else {
                Processor.Processor processor = GetProcessor(section, key);
                if (processor == null)
                {
                    LogService.WriteLog("未找到日志[" + key + "的处理器");
                }
                else 
                {
                    try
                    {
                        Context context = new Context(logTime, Parser.Execute(item, section.Mappings));
                        processor.Inject(context);
                        return true;
                    }
                    catch (Exception ex)
                    {
                        LogService.WirteLogError(ex);   
                    }
                }
            }
            return false;
        }
        private Processor.Processor GetProcessor(ConfigSection section, string key) 
        {
            Processor.Processor processor = null;
            if (_processors.ContainsKey(key))
            {
                return _processors[key];
            }
            lock (_processors)
            {
                if (_processors.ContainsKey(key))
                {
                    return _processors[key];
                }
                var writer = Factory.CreateWriter(section);
                if (writer != null)
                {
                    processor = Factory.CreateProcessor(writer, section.Setting);
                }
                _processors.Add(key, processor);
            }
            return processor;
        }
    }

6.DEMO

 记录异常日志类型为列子 配置文件 如1.

 异常实体类ExceptionLog

    public class ExceptionLog
    {
        public ExceptionLog(string message, string source, string targetSite, string stackTrace, DateTime errorTime, string remark) 
        {
            this.Message = message;
            this.Source = source;
            this.TargetSite = targetSite;
            this.StackTrace = stackTrace;
            this.ErrorTime = errorTime;
            this.Remark = remark;
        }
        /// <summary>
        /// 消息
        /// </summary>
        public string Message { get; private set; }
        /// <summary>
        /// 程序集或对象的名称
        /// </summary>
        public string Source { get; private set; }
        /// <summary>
        /// 引发异常的方法
        /// </summary>
        public string TargetSite { get; private set; }
        /// <summary>
        /// 堆栈信息
        /// </summary>
        public string StackTrace { get; private set; }
        /// <summary>
        /// 错误发生时间
        /// </summary>
        public DateTime ErrorTime { get; private set; }
        /// <summary>
        /// 备注
        /// </summary>
        public string Remark { get; private set; }
    }

写入异常日志

    /// <summary>
    /// 记录日志
    /// </summary>
    public static class LogService
    {
        /// <summary>
        /// 记录异常日志
        /// </summary>
        /// <param name="ex">异常信息</param>
        public static void SaveExceptionLog(Exception ex)
        {
            SaveExceptionLog(ex, DateTime.Now);
        }
        /// <summary>
        /// 记录异常日志
        /// </summary>
        /// <param name="ex">异常信息</param>
        /// <param name="errorTime">发生异常时间</param>
        public static void SaveExceptionLog(Exception ex, DateTime errorTime)
        {
            SaveExceptionLog(ex, errorTime, string.Empty);
        }
        /// <summary>
        /// 记录异常日志
        /// </summary>
        /// <param name="ex">异常信息</param>
        /// <param name="errorTime">发生异常时间</param>
        /// <param name="remark">备注信息</param>
        public static void SaveExceptionLog(Exception ex, DateTime errorTime, string remark)
        {
            try
            {
                ExceptionLog log = new ExceptionLog(ex.Message,
                ex.Message,
                ex.TargetSite == null ? string.Empty : ex.TargetSite.ToString(),
                ex.StackTrace,
                errorTime,
                remark);
                Logger.LogService.WriteLog(log);
            }
            catch
            {
                return;
            }
        }
        /// <summary>
        /// 记录操作日志
        /// </summary>
        /// <param name="log">日志详细内容</param>
        public static void SaveOpetationLog(OperationLog log)
        {
            try
            {
                Logger.LogService.WriteLog(log);
            }
            catch
            {

            }
        }
    }

7.结语

　　如果上面讲解中没有列出的类或者方法可以到下载下面的附件

　　

8.提供源代码下载

源代码下载