日志記錄類LogHelper

開源日志log4net使用起來很方便，但是項目中不讓用，所以自己重寫了一個類，用來記錄日志，比較簡單。

1、首先是可以把日志分成多個類型，分別記錄到不同的文件中

   /// <summary>
    /// 日志類型
    /// </summary>
    public enum LogType
    {
        /// <summary>
        /// 插入型
        /// </summary>
        Insert,
        /// <summary>
        /// 更新型
        /// </summary>
        Update,
        /// <summary>
        /// 所有
        /// </summary>
        All,
        /// <summary>
        /// 結尾，放在最后
        /// </summary>
        End
    } 

我的是分三個，insert插入，update更新，all包括所有的日志。

2、接下來是LogHelper類，代碼中已注釋，不多說，直接上代碼

    /// <summary>
    /// 記錄日志
    /// </summary>
    public class LogHelper
    {

        #region 自定義變量
        /// <summary>
        /// 異常信息的隊列
        /// </summary>
        private static Queue<string> qMsg = null;
        /// <summary>
        /// 文件大小最大值，單位：Mb
        /// </summary>
        private static int maxFileSize = 10;
        /// <summary>
        /// 當天創建同一類型的日志文件的個數
        /// </summary>
        private static int[] createdFileCounts = new int[(int)LogType.End];
        /// <summary>
        /// 日志文件存放路徑
        /// </summary>
        private static string logFilePath = "";
        #endregion

        #region 屬性
        /// <summary>
        /// 文件大小最大值，單位：Mb。小於0時則不限制
        /// </summary>
        public static int MaxFileSize
        {
            get { return maxFileSize; }
            set { maxFileSize = value; }
        }
        /// <summary>
        /// 日志文件存放路徑
        /// </summary>
        public static string LogFilePath
        {
            set { logFilePath = value; }
            get
            {
                if (!String.IsNullOrEmpty(logFilePath))
                {
                    return logFilePath;
                }
                else
                {
                    return System.Windows.Forms.Application.StartupPath + "\\Log\\" + DateTime.Now.ToString("yyyy-MM-dd");
                }
            }
        }
        #endregion

        #region 構造函數
        /// <summary>
        /// 靜態構造函數
        /// </summary>
        static LogHelper()
        {
            qMsg = new Queue<string>();
            SetCreatedFileCount();
            RunThread();
        }
        #endregion

        #region 輔助
        /// <summary>
        /// 獲取日志文件的全路徑
        /// </summary>
        /// <param name="logType"></param>
        /// <returns></returns>
        private static string GetLogPath(LogType logType, bool isCreateNew)
        {
            string logPath = LogFilePath;
            if (!Directory.Exists(logPath))
            {
                Directory.CreateDirectory(logPath);
                //看成是新的一天，要將昨天的數據清空
                for (int i = 0; i < createdFileCounts.Length; i++)
                {
                    createdFileCounts[i] = 0;
                }
            }
            switch (logType)
            {
                case LogType.Insert:
                    logPath = logPath + "\\" + "Insert";
                    break;
                case LogType.Update:
                    logPath = logPath + "\\" + "Update";
                    break;
                default:
                    logPath = logPath + "\\" + "All";
                    break;
            }
            if (isCreateNew)
            {
                int num = ++createdFileCounts[(int)logType];
                logPath += string.Format("({0}).log", num);
                return logPath;
            }

            logPath += ".log";
            //createdFileCounts[(int)logType] = 0;
            if (!File.Exists(logPath))
            {
                //File.Create(logPath);
                FileStream fs = File.Create(logPath);
                fs.Close();
                fs.Dispose();
            }

            return logPath;
        }

        /// <summary>
        /// 運行線程
        /// </summary>
        private static void RunThread()
        {
            ThreadPool.QueueUserWorkItem(u =>
            {
                while (true)
                {
                    string tmsg = string.Empty;
                    lock (qMsg)
                    {
                        if (qMsg.Count > 0)
                            tmsg = qMsg.Dequeue();
                    }

                    //往日志文件中寫錯誤信息                     
                    if (!String.IsNullOrEmpty(tmsg))
                    {
                        int index = tmsg.IndexOf("&&");
                        string logTypeStr = tmsg.Substring(0, index);
                        LogType logType = LogType.All;
                        if (logTypeStr == string.Format("{0}", LogType.Insert))
                        {
                            logType = LogType.Insert;
                        }
                        else if (logTypeStr == string.Format("{0}", LogType.Update))
                        {
                            logType = LogType.Update;
                        }

                        //記錄所有日志
                        WriteLog(tmsg.Substring(index + 2));
                        //分開記錄日志
                        if (logType != LogType.All)
                        {
                            WriteLog(tmsg.Substring(index + 2), logType);
                        }
                    }

                    if (qMsg.Count <= 0)
                    {
                        Thread.Sleep(1000);
                    }
                }
            });
        }

        /// <summary>
        /// 程序剛啟動時 檢測已創建的日志文件個數
        /// </summary>
        private static void SetCreatedFileCount()
        {
            string logPath = LogFilePath;
            if (!Directory.Exists(logPath))
            {
                for (int i = 0; i < createdFileCounts.Length; i++ )
                {
                    createdFileCounts[i] = 0;
                }
            }
            else
            {
                DirectoryInfo dirInfo = new DirectoryInfo(logPath);
                FileInfo[] fileInfoes = dirInfo.GetFiles("*.log");
                foreach (FileInfo fi in fileInfoes)
                {
                    string fileName = Path.GetFileNameWithoutExtension(fi.FullName).ToLower();
                    if (fileName.Contains('(') && fileName.Contains(')'))
                    {
                        fileName = fileName.Substring(0, fileName.LastIndexOf('('));
                        switch (fileName)
                        {
                            case "insert":
                                createdFileCounts[(int)LogType.Insert]++;
                                break;
                            case "update":
                                createdFileCounts[(int)LogType.Update]++;
                                break;
                            case "all":
                                createdFileCounts[(int)LogType.All]++;
                                break;
                            default:
                                break;
                        }
                    }
                }

            }
        }
        #endregion

        #region 寫日志

        /// <summary>
        /// 寫日志
        /// </summary>
        /// <param name="strLog">日志內容</param>
        public static void WriteLog(string strLog)
        {
            WriteLog(strLog, LogType.All);
        }

        /// <summary>
        /// 寫日志
        /// </summary>
        /// <param name="strLog">日志內容</param>
        /// <param name="logType">日志類型</param>
        public static void WriteLog(string strLog, LogType logType)
        {
            if (String.IsNullOrEmpty(strLog))
            {
                return;
            }
            strLog = strLog.Replace("\n", "\r\n");

            FileStream fs = null;
            try
            {
                string logPath = GetLogPath(logType, false);
                FileInfo fileInfo = new FileInfo(logPath);
                if (MaxFileSize > 0 && fileInfo.Length > (1024 * 1024 * MaxFileSize))
                {
                    fileInfo.MoveTo(GetLogPath(logType, true));
                }
                fs = File.Open(logPath, FileMode.OpenOrCreate);
                //fs = File.OpenWrite(logPath);
                byte[] btFile = Encoding.UTF8.GetBytes(strLog);
                //設定書寫的開始位置為文件的末尾  
                fs.Position = fs.Length;
                //將待寫入內容追加到文件末尾  
                fs.Write(btFile, 0, btFile.Length);
            }
            finally
            {
                if (fs != null)
                {
                    fs.Close();
                    fs.Dispose();
                }
            }
        }

        /// <summary>
        /// 寫入錯誤日志隊列
        /// </summary>
        /// <param name="msg">錯誤信息</param>
        public static void WriteLogAsync(string strLog, LogType logType)
        {
            //將錯誤信息添加到隊列中
            lock (qMsg)
            {
                qMsg.Enqueue(string.Format("{0}&&{1}\r\n", logType, strLog));
            }
        } 
        #endregion

    } 

使用時，可以直接調用WriteLogAsync函數，將消息添加到隊列中，然后在另外的線程中處理隊列中的消息。

其中，如果沒有給LogFilePath屬性賦值，則有一個默認的文件存放路徑。MaxFileSize屬性是用來限制日志文件大小的，如果小於等於0則表示不限制。如果有限制，當文件大小超過這個最大值后會將原來的文件重命名，然后再創建一個“自己”。例如：正在存放日志的文件名為"All.log"，當它滿了以后就成為“All(n).log”文件，n為從1開始遞增的數字，然后會重新創建一個“All.log”文件接着存放日志。