你的日志组件记录够清晰嘛？--自己开发日志组件 Logger

现在现成的日志组件实在是太多太多，为什么我还需要自己实现呢？？？？？

需求来源于java的log4j，

[07-31 16:40:00:557:WARN : com.game.engine.thread.ServerThread:117] -> 全局排行榜同步执行器-->ServerThread[全局排行榜同步执行器]执行 执行时间过长:23

简单的一句日志信息，但是我却可以很清晰的定位日志输出的代码位置；com.game.engine.thread包下面的ServerThread这个类文件的第117行；

而log4net却不行，

也许是因为我米有找到正确的对应配置文件、可惜吧~！

于是我打算自己重组日志组件来实现清洗的日志记录。当然你也可以说，.net平台下面的exception抛错的话日志也很清晰。

但是有时候我们逻辑错误或者是参数错误，根本不会抛错，这种情况下我们没有得到预期结果的时候只能通过简单调试找出原因。

那么很明显费时，费力，所以我就想得到像log4j那样打印出清晰的日志。

可能你会问有这个必要嘛？很有必要哦，比如你程序上线一个版本，然后打印的信息和现在最新版本行号已经不符合了，数据流向和清晰度自然而然就不存在多大的意义~！

如果需要找到这样清晰的日志。那么就需要得到方法的调用堆栈信息。

查阅文档发现 System.Diagnostics.StackTrace 类是记录堆栈信息的

于是开始无尽的测试之行

namespace Sz.StackTraceTest
{
    class Program
    {
        static void Main(string[] args)
        {
            Test();
            Console.ReadLine();
        }

        static public void Test()
        {
            ShowStackTrace();
        }

        static public void ShowStackTrace()
        {

            StackTrace trace = new StackTrace();
            var frames = trace.GetFrames();
            foreach (var item in frames)
            {
                Console.WriteLine(string.Format("[{0},文件{1},方法{2},行{3}]", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff"), item.GetFileName(), item.GetMethod(), item.GetFileLineNumber()));
            }
        }

    }
}

运行后发现：

并未得到文件等信息，为啥会这样

        // 摘要: 
        //     用调用方的帧初始化 System.Diagnostics.StackTrace 类的新实例。
        public StackTrace();
        //
        // 摘要: 
        //     用调用方的帧初始化 System.Diagnostics.StackTrace 类的新实例，可以选择捕获源信息。
        //
        // 参数: 
        //   fNeedFileInfo:
        //     如果为 true，则捕获文件名、行号和列号；否则为 false。
        public StackTrace(bool fNeedFileInfo);

查询了一下StackTrace类的重载得知，应该是默认构造函数并未捕获信息

那么重来一次

这次取到了。可是意外的发现，记录的文件居然 是全路径。，

显然这不是我想要的结果。

那么再试试看有么有其他路径。

于是想到，既然有函数，那么可以通过函数入手啊，函数，肯定有父节啊。

        //
        // 摘要: 
        //     获取声明该成员的类。
        //
        // 返回结果: 
        //     声明该成员的类的 Type 对象。
        public abstract Type DeclaringType { get; }

于是找到这个属性，声明该函数的对象。那么肯定会得到类型的完全限定名称了；

namespace Sz.StackTraceTest
{
    class Program
    {
        static void Main(string[] args)
        {
            Test();
            Console.ReadLine();
        }

        static public void Test()
        {
            ShowStackTrace();
        }

        static public void ShowStackTrace()
        {

            StackTrace trace = new StackTrace(true);
            var frames = trace.GetFrames();
            foreach (var item in frames)
            {
                Console.WriteLine(string.Format("[{0},文件{1},方法{2},行{3}]", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff"), item.GetMethod().DeclaringType.FullName, item.GetMethod(), item.GetFileLineNumber()));
            }
        }

    }
}

看看那运行结果

得到命名空间和类型名了。

但是图中我们看到，其实我只想Test()中输出打印的地方加入一个而已，

但是打印出了整个走向，这个时候我们是普通打印日志根本不需要整个的流程走向

再次查看StackTrace类还有一个重载方式

        //
        // 摘要: 
        //     从调用方的帧初始化 System.Diagnostics.StackTrace 类的新实例，跳过指定的帧数并可以选择捕获源信息。
        //
        // 参数: 
        //   skipFrames:
        //     堆栈中的帧数，将从其上开始跟踪。
        //
        //   fNeedFileInfo:
        //     如果为 true，则捕获文件名、行号和列号；否则为 false。
        //
        // 异常: 
        //   System.ArgumentOutOfRangeException:
        //     skipFrames 参数为负数。
        public StackTrace(int skipFrames, bool fNeedFileInfo);

跳过指定帧；

namespace Sz.StackTraceTest
{
    class Program
    {
        static void Main(string[] args)
        {
            Test();
            Console.ReadLine();
        }

        static public void Test()
        {
            Log("test");
            Log("test");
            Log("test");
        }

        static public void Log(string msg)
        {
            StackTrace trace = new StackTrace(1, true);
            if (trace.GetFrames().Length > 0)
            {
                var item = trace.GetFrame(0);
                Console.WriteLine(string.Format("[{0},文件{1},方法{2},行{3}]：{4}", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff"), item.GetMethod().DeclaringType.FullName, item.GetMethod(), item.GetFileLineNumber(), msg));
            }
            else
            {
                Console.WriteLine(string.Format("[{0},文件{1},方法{2},行{3}]：{4}", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff"), null, null, null, msg));
            }
            //var frames = trace.GetFrames();

            //foreach (var item in frames)
            //{
            //    Console.WriteLine(string.Format("[{0},文件{1},方法{2},行{3}]", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff"), item.GetMethod().DeclaringType.FullName, item.GetMethod(), item.GetFileLineNumber()));
            //}
        }
    }
}

再来看看

ok已完全符合我的需求了。是不是呢？？？这样检查逻辑错误的时候方便许多了。

附上我的全部日志组件源码

组件实现了简单的配置；

由于日志打印控制还是输出文本文件都是比较耗时的事情；所以加入线程模型

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

/**
 * 
 * @author 失足程序员
 * @Blog http://www.cnblogs.com/ty408/
 * @mail 492794628@qq.com
 * @phone 13882122019
 * 
 */
namespace Sz
{
    /// <summary>
    /// 日志辅助
    /// <para>AppSettings 设置 LogRootPath 为日志的根目录</para>
    /// </summary>
    public class Logger
    {
        static ThreadModel logConsoleThread = new ThreadModel("Console Log Thread");
        static ThreadModel logFileThread = new ThreadModel("File Log Thread");
        static string logInfoPath = "log/info/";
        static string logErrorPath = "log/error/";

        /// <summary>
        /// 设置日志的输出根目录
        /// </summary>
        /// <param name="path"></param>
        static public void SetLogRootPath(string path)
        {

            logInfoPath = path + logInfoPath;
            logErrorPath = path + logErrorPath;
            if (!Directory.Exists(logInfoPath)) { Directory.CreateDirectory(logInfoPath); }
            if (!Directory.Exists(logErrorPath)) { Directory.CreateDirectory(logErrorPath); }

        }

        static Logger()
        {

            if (System.Configuration.ConfigurationManager.AppSettings.AllKeys.Contains("LogRootPath"))
            {
                string logPath = System.Configuration.ConfigurationManager.AppSettings["LogRootPath"].ToString();
                if (!(logPath.EndsWith("\") || logPath.EndsWith("/")))
                {
                    logPath = "\";
                }
                logInfoPath = logPath + logInfoPath;
                logErrorPath = logPath + logErrorPath;
            }
            if (!Directory.Exists(logInfoPath)) { Directory.CreateDirectory(logInfoPath); }
            if (!Directory.Exists(logErrorPath)) { Directory.CreateDirectory(logErrorPath); }

        }

        #region 日子写入文件辅助任务 class LogTaskFile : TaskBase
        /// <summary>
        /// 日子写入文件辅助任务
        /// </summary>
        class LogTaskFile : TaskBase
        {
            string msg, mathed;
            Exception exce;
            StackTrace trace;
            static readonly StringBuilder sb = new StringBuilder();
            public LogTaskFile(StackTrace trace, string mathed, string msg, Exception exce)
                : base("File Log Task")
            {
                this.mathed = mathed;
                this.trace = trace;
                this.msg = msg;
                this.exce = exce;
            }

            public override void TaskRun()
            {
                var frame = trace.GetFrame(0);
                DateTime dnow = DateTime.Now;
                sb.Clear();
                sb.Append("[")
                    .Append(dnow.NowString())
                    .Append(mathed.PadRight(5))
                    .Append("：")
                    .Append(frame.GetMethod().DeclaringType.FullName)
                    .Append(", ")
                    .Append(frame.GetMethod())
                    .Append(", ")
                    .Append(frame.GetFileLineNumber())
                    .Append("] ").Append(msg);

                if (exce != null)
                {
                    sb.AppendLine("")
                    .AppendLine("----------------------Exception--------------------------")
                    .Append(exce.GetType().FullName).Append(": ").AppendLine(exce.Message)
                    .AppendLine(exce.StackTrace)
                    .AppendLine("----------------------Exception--------------------------");
                }
                string logPath = string.Format("{0}info_{1}.log", logInfoPath, dnow.ToString("yyyyMMdd"));

                System.IO.File.AppendAllText(logPath, sb.ToString(), UTF8Encoding.Default);
                System.IO.File.AppendAllText(logPath, "
", UTF8Encoding.Default);

                logPath = string.Format("{0}error_{1}.log", logErrorPath, dnow.ToString("yyyyMMdd"));
                System.IO.File.AppendAllText(logPath, sb.ToString(), UTF8Encoding.Default);
                System.IO.File.AppendAllText(logPath, "
", UTF8Encoding.Default);

            }
        }
        #endregion

        #region 日志写入控制台输出 class LogTaskConsole : TaskBase
        /// <summary>
        /// 日志写入控制台输出
        /// </summary>
        class LogTaskConsole : TaskBase
        {
            string msg, mathed;
            Exception exce;
            StackTrace trace;
            static readonly StringBuilder sb = new StringBuilder();

            public LogTaskConsole(StackTrace trace, string mathed, string msg, Exception exce)
                : base("Console Log Task")
            {
                this.mathed = mathed;
                this.trace = trace;
                this.msg = msg;
                this.exce = exce;
            }

            public override void TaskRun()
            {
                sb.Clear();
                var frame = trace.GetFrame(0);
                sb.Append("[")
                    .Append(DateTime.Now.NowString())
                    .Append(mathed.PadRight(5))
                    .Append("：")
                    .Append(frame.GetMethod().DeclaringType.FullName)
                    //.Append(", ")
                    //.Append(frame.GetMethod())
                    .Append(", ")
                    .Append(frame.GetFileLineNumber())
                    .Append("] ").Append(msg);

                if (exce != null)
                {
                    sb.AppendLine("")
                    .AppendLine("----------------------Exception--------------------------")
                    .Append(exce.GetType().FullName).Append(": ").AppendLine(exce.Message)
                    .AppendLine(exce.StackTrace)
                    .AppendLine("----------------------Exception--------------------------");
                }
                Console.WriteLine(sb.ToString());
            }
        }
        #endregion

        string name;
        /// <summary>
        /// 
        /// </summary>
        /// <param name="name"></param>
        public Logger(string name)
        {
            this.name = name;
        }

        /// <summary>
        /// 输出到控制台
        /// </summary>
        /// <param name="msg"></param>
        static public void Debug(string msg)
        {
            StackTrace trace = new StackTrace(1, true);
            LogTaskConsole logConsole = new LogTaskConsole(trace, "Debug", msg, null);
            logConsoleThread.AddTask(logConsole);
        }

        /// <summary>
        /// 控制台和文本文件
        /// </summary>
        /// <param name="msg"></param>
        static public void Info(string msg)
        {
            AddLog("Info", msg, null);
        }
        /// <summary>
        /// 控制台和文本文件
        /// </summary>
        static public void Error(string msg)
        {
            AddLog("Error", msg, null);
        }
        /// <summary>
        /// 控制台和文本文件
        /// </summary>
        static public void Error(string msg, Exception exception)
        {
            AddLog("Error", msg, exception);
        }

        static void AddLog(string mathed, string msg, Exception exception)
        {
            StackTrace trace = new StackTrace(2, true);
            LogTaskConsole logConsole = new LogTaskConsole(trace, mathed, msg, exception);
            logConsoleThread.AddTask(logConsole);
            LogTaskFile logFile = new LogTaskFile(trace, mathed, msg, exception);
            logFileThread.AddTask(logFile);
        }
    }
}

线程模型的任务类型

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

/**
 * 
 * @author 失足程序员
 * @Blog http://www.cnblogs.com/ty408/
 * @mail 492794628@qq.com
 * @phone 13882122019
 * 
 */
namespace Sz
{
    internal abstract class TaskBase
    {
        
        public string Name { get; private set; }

        public TaskBase(string name)
        {
            this.Name = name;
            TempAttribute = new ObjectAttribute();
        }
        public ObjectAttribute TempAttribute { get; set; }

        public abstract void TaskRun();
    }
}

线程模型

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

/**
 * 
 * @author 失足程序员
 * @Blog http://www.cnblogs.com/ty408/
 * @mail 492794628@qq.com
 * @phone 13882122019
 * 
 */
namespace Sz
{
    /// <summary>
    /// 线程模型
    /// </summary>    
    internal class ThreadModel
    {
        public bool IsStop = false;
        /// <summary>
        /// ID
        /// </summary>
        public int ID;

        static int StaticID = 0;

        public ThreadModel(string name)
        {
            lock (typeof(ThreadModel))
            {
                StaticID++;
            }
            ID = StaticID;
            System.Threading.Thread thread = new System.Threading.Thread(new System.Threading.ThreadStart(Run));
            thread.Name = name;
            thread.IsBackground = true;
            thread.Start();
        }

        /// <summary>
        /// 任务队列
        /// </summary>
        protected System.Collections.Concurrent.ConcurrentQueue<TaskBase> taskQueue = new System.Collections.Concurrent.ConcurrentQueue<TaskBase>();

        /// <summary>
        /// 加入任务
        /// </summary>
        /// <param name="t"></param>
        public virtual void AddTask(TaskBase t)
        {
            taskQueue.Enqueue(t);
            //防止线程正在阻塞时添加进入了新任务
            are.Set();
        }

        //通知一个或多个正在等待的线程已发生事件
        protected ManualResetEvent are = new ManualResetEvent(false);

        protected virtual void Run()
        {
            while (true)
            {
                while (!taskQueue.IsEmpty)
                {
                    TaskBase t = null;
                    if (!taskQueue.IsEmpty && taskQueue.TryDequeue(out t))
                    {
                        try
                        {
                            t.TaskRun();//执行任务
                            t = null;
                        }
                        catch (Exception ex)
                        {
                            Logger.Error("Thread：<" + Thread.CurrentThread.Name + "> TaskRun <" + t.Name + ">", ex);
                        }
                    }
                }
                are.Reset();
                //队列为空等待200毫秒继续
                are.WaitOne(200);
            }
        }
    }
}

到此为止，日志组件完成。如果有需要的或者原因的可以自己加入，数据库，和mail处理的