[原創]分享一個輕量級日志類

日常開發中，常常會在程序部署到生產環境后發現有些問題，但無法直接調試，這就需要用到日志，本來想找一些開源的完善的日志類來實現，但試了幾個都感覺太重。於是意識到一個問題，懶是偷不得的，只好擼起袖子，自己寫一個。這個日志類是基於訂閱模式的，而且是線程安全的，現在分享給大家，希望能給大家帶來幫助。

閑話不多說，直接上代碼。代碼有兩個實現版本（Java與C#），這里放出的是C#。

一共用到三個類：JzgLogs.cs主類，LogBuffer.cs日志緩沖類，LogInfo是用於日志緩沖中做記錄的實體類，基本原理是把所有待寫入的日志寫到緩沖中，然后一個線程輪詢緩沖，發現有需要寫入的數據，就寫入，否則就下一次。

No.1  JzgLogs.cs

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

/****************************************************************************
單例類     ：日志記錄類
作者       ：賈淵
版本       ：1.5
上一版本   ：1.4
更新日志   ：
    2018-07-06  創建
    2018-08-06  增加了屬性LogMode，用於改變記錄日志的方式
    2018-12-26  修改了讀寫文件的線程鎖定方式
    2019-01-14  改進日志寫入的時的對象鎖定方式
    2019-01-15  改進了日志寫入的方式為多線程隊列寫入，操你大爺的Lock，又慢又爛
****************************************************************************/

namespace Jzg.Logs
{
    /// <summary>
    /// 日志記錄類
    /// </summary>
    public class JzgLogs : IDisposable
    {
        /// <summary>
        /// 記錄類型：消息
        /// </summary>
        public const string LOGTYPE_INFO = "INFO";
        /// <summary>
        /// 記錄類型：錯誤
        /// </summary>
        public const string LOGTYPE_ERROR = "ERROR";

        //線程鎖
        private static readonly object locker = new object();

        //日志記錄路徑
        private string logPath = "";

        //日志記錄方式
        private LogMode logMode = LogMode.lmAll;

        /// <summary>
        /// 日志記錄方式，從枚舉LogMode中取值
        /// </summary>
        public LogMode LogMode
        {
            get
            {
                return logMode;
            }

            set
            {
                logMode = value;
            }
        }

        /// <summary>
        /// 私有構造方法
        /// </summary>
        private JzgLogs()
        {
            //默認為全記錄
            logMode = LogMode.lmAll;
            //創建線程安全的消息隊列
            LogQueue = new LogBuffer();
            //開啟寫入線程
            WriteThread = new Thread(FlushBuffer);
            WriteThread.IsBackground = true;
            WriteThread.Start();
        }

        private LogBuffer LogQueue;

        //是否停止處理緩存
        private volatile bool _FlushAlive = true;

        private void FlushBuffer()
        {
            while (_FlushAlive)
            {
                LogInfo logInfo = LogQueue.ReadBuffer();
                if (logInfo == null)
                {
                    //如果沒有要寫入的內容則延時100毫秒再看
                    Thread.Sleep(200);
                }
                else
                {
                    try
                    {
                        using (FileStream fs = new FileStream(logInfo.LogFile, FileMode.OpenOrCreate, FileAccess.Write, FileShare.ReadWrite))
                        {
                            using (StreamWriter sw = new StreamWriter(fs))
                            {
                                sw.BaseStream.Seek(0, SeekOrigin.End);
                                sw.WriteLine(logInfo.LogContent);
                                sw.Flush();
                            }
                        }
                    }
                    catch (Exception)
                    {
                        //出錯就不管丫的
                    }
                }
            }
        }

        private static JzgLogs instance = null;

        /// <summary>
        /// 獲取或設置日志記錄路徑
        /// </summary>
        public string LogPath
        {
            get
            {
                //補齊路徑結束的\符號
                if (!logPath.EndsWith("\\"))
                {
                    logPath += "\\";
                }
                return logPath;
            }

            set
            {
                logPath = value;
            }
        }


        /// <summary>
        /// 靜態方法：獲取實例（單例模式）
        /// </summary>
        /// <returns></returns>
        [Obsolete("該方法已過時，推薦使用靜態屬性Instance代替")]
        public static JzgLogs getInstance()
        {
            //2019-01-14 改為二次驗證單例模式，提高了性能和並發安全性
            if (instance == null)
            {
                lock (locker)
                {
                    if (instance == null)
                    {
                        var tmp = new JzgLogs();
                        Thread.MemoryBarrier();
                        instance = tmp;
                    }
                }
            }

            return instance;
        }

        /// <summary>
        /// 靜態屬性：單例實例
        /// </summary>
        public static JzgLogs Instance
        {
            get
            {
                //2019-01-14 改為二次驗證單例模式，提高了性能和並發安全性
                if (instance == null)
                {
                    lock (locker)
                    {
                        if (instance == null)
                        {
                            var tmp = new JzgLogs();
                            Thread.MemoryBarrier();
                            instance = tmp;
                        }
                    }
                }

                return instance;
            }
        }

        //寫入線程
        private Thread WriteThread = null;

        /// <summary>
        /// 記錄日志
        /// </summary>
        /// <param name="subPath">子路徑</param>
        /// <param name="logType">記錄類型</param>
        /// <param name="tag">模塊標識</param>
        /// <param name="logContent">記錄內容</param>
        public void Log(string subPath, string logType, string tag, string logContent)
        {
            //如果未設置路徑則拋出錯誤
            if (string.IsNullOrEmpty(logPath))
            {
                throw new Exception("logPath not set");
            }

            //判斷記錄模式
            bool canLog = (logMode == LogMode.lmAll) || (logMode == LogMode.lmError && logType == LOGTYPE_ERROR) || (logMode == LogMode.lmInfo && logType == LOGTYPE_INFO);
            //如果不需要記錄則直接退出
            if (!canLog)
            {
                return;
            }

            //當前時間
            DateTime logTime = DateTime.Now;
            //記錄時間的字符串
            string logTimeStr = logTime.ToString("yyyy/MM/dd HH:mm:ss:fff");
            //文件名
            string fileName = String.Format("log_{0}.log", DateTime.Now.ToString("yyyyMMdd"));

            //計算子路徑
            string fullLogPath = LogPath + subPath;
            //補齊路徑結尾\符號
            if (!fullLogPath.EndsWith("\\") && !String.IsNullOrEmpty(fullLogPath))
            {
                fullLogPath += "\\";
            }
            //自動創建路徑
            DirectoryInfo di = new DirectoryInfo(fullLogPath);
            if (!di.Exists)
            {
                di.Create();
            }

            //文件完整路徑
            string fullFilePath = fullLogPath + fileName;
            //記錄格式模板
            string contentTemplate = "【{0}】 【{1}】 【{2}】 【記錄】{3}";
            logContent = Regex.Replace(logContent, @"[\n\r]", "");//去掉換行符
                                                                  //計算日志內容
            string lineContent = String.Format(contentTemplate, logType, logTimeStr, tag, logContent);

            LogInfo logInfo = new LogInfo()
            {
                LogFile = fullFilePath,
                LogContent = lineContent
            };

            //寫入緩存
            LogQueue.WriteBuffer(logInfo);
        }

        /// <summary>
        /// 記錄日志
        /// </summary>
        /// <param name="logType">記錄類型</param>
        /// <param name="tag">模塊標識</param>
        /// <param name="logContent">記錄內容</param>
        public void Log(string logType, string tag, string logContent)
        {
            Log("", logType, tag, logContent);
        }

        /// <summary>
        /// 釋放資源
        /// </summary>
        public void Dispose()
        {
            _FlushAlive = false;
        }
    }

    /// <summary>
    /// 枚舉：日志記錄方式
    /// </summary>
    public enum LogMode
    {
        /// <summary>
        /// 不記錄
        /// </summary>
        lmNone = 0,
        /// <summary>
        /// 全記錄
        /// </summary>
        lmAll = 1,
        /// <summary>
        /// 只記錄Info類型
        /// </summary>
        lmInfo = 2,
        /// <summary>
        /// 只記錄Error類型
        /// </summary>
        lmError = 3
    }
}

No.2  LogBuffer.cs

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

namespace Jzg.Logs
{
    /// <summary>
    /// 日志寫入緩沖
    /// </summary>
    public class LogBuffer
    {
        private ConcurrentQueue<LogInfo> Logs;

        /// <summary>
        /// 構造方法
        /// </summary>
        public LogBuffer()
        {
            Logs = new ConcurrentQueue<LogInfo>();
        }

        /// <summary>
        /// 把日志加入寫入隊列末端
        /// </summary>
        /// <param name="logInfo">要寫入的日志對象</param>
        public void WriteBuffer(LogInfo logInfo)
        {
            Logs.Enqueue(logInfo);
        }

        /// <summary>
        /// 從日志中取出開頭的一條
        /// </summary>
        /// <returns>為null表示隊列為空了</returns>
        public LogInfo ReadBuffer()
        {
            LogInfo logInfo = null;

            if (!Logs.TryDequeue(out logInfo))
                return null;

            return logInfo;
        }
        
        /// <summary>
        /// 隊列中的數量
        /// </summary>
        /// <returns></returns>
        public int Count()
        {
            return Logs.Count;
        }
    }
}

No.3  LogInfo.cs

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

namespace Jzg.Logs
{
    /// <summary>
    /// 用於緩存的日志記錄實體
    /// </summary>
    public class LogInfo
    {
        /// <summary>
        /// 要記錄到哪個文件里
        /// </summary>
        public string LogFile
        {
            get; set;
        }

        /// <summary>
        /// 記錄的文字內容
        /// </summary>
        public string LogContent
        {
            get; set;
        }
    }
}