日志记录类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 = ;
         /// <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 = ; i < createdFileCounts.Length; i++)
                 {
                     createdFileCounts[i] = ;
                 }
             }
             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 > )
                             tmsg = qMsg.Dequeue();
                     }

                     //往日志文件中写错误信息
                     if (!String.IsNullOrEmpty(tmsg))
                     {
                         int index = tmsg.IndexOf("&&");
                         string logTypeStr = tmsg.Substring(, 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 + ));
                         //分开记录日志
                         if (logType != LogType.All)
                         {
                             WriteLog(tmsg.Substring(index + ), logType);
                         }
                     }

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

         /// <summary>
         /// 程序刚启动时 检测已创建的日志文件个数
         /// </summary>
         private static void SetCreatedFileCount()
         {
             string logPath = LogFilePath;
             if (!Directory.Exists(logPath))
             {
                 for (int i = ; i < createdFileCounts.Length; i++ )
                 {
                     createdFileCounts[i] = ;
                 }
             }
             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(, 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 >  && fileInfo.Length > ( *  * 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, , 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”文件接着存放日志。