C#日志记录

    /// <summary>
    /// 接口类 TCP的通信日志处理
    /// </summary>
    public class ShowInfo
    {
        public delegate void WriteTView(string str);

        private WriteTView _myViewWrite;

        public delegate void WriteTLog(object str);

        private WriteTLog _myLogWrite;

        /// <summary>
        /// 构造
        /// </summary>
        public ShowInfo()
        {
            _myViewWrite = WriteDemo;
            _myLogWrite = LogManager.LogRunInfo;
        }

        /// <summary>
        /// 构造
        /// </summary>
        /// <param name="write"></param>
        public ShowInfo(WriteTView write)
        {
            _myViewWrite = write;
            _myLogWrite = LogManager.LogRunInfo;
        }

        /// <summary>
        /// 显示的demo
        /// </summary>
        /// <param name="str"></param>
        private void WriteDemo(string str)
        {
            Trace.WriteLine(str);
        }

        /// <summary>
        /// 设置显示的回调函数
        /// </summary>
        /// <param name="write"></param>
        public void SetViewWrite(WriteTView write)
        {
            _myViewWrite = write;
        }

        /// <summary>
        /// 设置记录的回调函数
        /// </summary>
        /// <param name="write"></param>
        public void SetLogWrite(WriteTLog write)
        {
            _myLogWrite = write;
        }

        /// <summary>
        /// 显示
        /// </summary>
        /// <param name="obj"></param>
        public void WriteView(object obj)
        {
            if (obj is Exception)
            {
                _myLogWrite(obj);
            }
            else if (obj is string)
            {
                _myViewWrite(obj as string);
            }
        }

        /// <summary>
        ///  记录到日志文件中
        /// </summary>
        /// <param name="str"></param>
        public void WriteToLog(object obj)
        {
            if (_myLogWrite != null)
            {
                _myLogWrite(obj);
            }
        }

        /// <summary>
        ///  记录到日志文件中
        /// </summary>
        /// <param name="condition"></param>
        /// <param name="str"></param>
        public void WriteToLog(bool condition, object obj)
        {
            if (condition)
            {
                if (_myLogWrite != null)
                {
                    _myLogWrite(obj);
                }
            }
        }

        #region 输出

        /// <summary>
        /// 显示
        /// </summary>
        /// <param name="format"></param>
        /// <param name="arg"></param>
        public void WriteToView(string format, params Object[] arg)
        {
            string str = String.Format(format, arg);
            WriteView(str);
        }

        /// <summary>
        /// 满足条件方可显示或记录
        /// </summary>
        /// <param name="condition">输出条件</param>
        /// <param name="str">要输出的输出字符串</param>
        /// <param name="isWriteLog">是否记录到日志文件</param>
        /// <param name="isWriteView">是否显示</param>
        public void WriteToView(bool condition, string str, bool isWriteLog, bool isWriteView)
        {
            if (condition)
            {
                if (isWriteView)
                {
                    WriteView(str);
                }
                if (isWriteLog)
                {
                    WriteToLog(str);
                }
            }
        }

        /// <summary>
        /// 满足条件方可记录,不显示
        /// </summary>
        /// <param name="condition">输出条件</param>
        /// <param name="str">要输出的输出字符串</param>
        public void WriteToView(bool condition, string str)
        {
            WriteToView(condition, str, true, false);
        }

        /// <summary>
        /// 满足条件方可记录，并标记是否显示
        /// </summary>
        /// <param name="condition">输出条件</param>
        /// <param name="str">要输出的输出字符串</param>
        /// <param name="isWriteView">是否显示</param>
        public void WriteToView(bool condition, string str, bool isWriteView)
        {
            WriteToView(condition, str, true, isWriteView);
        }

        /// <summary>
        /// 显示或记录
        /// </summary>
        /// <param name="str"></param>
        /// <param name="isWriteLog"></param>
        public void WriteToView(string str, bool isWriteLog, bool isWriteView)
        {
            WriteToView(true, str, isWriteLog, isWriteView);
        }

        /// <summary>
        ///显示，并标记是否记录
        /// </summary>
        /// <param name="str"></param>
        /// <param name="isWriteLog"></param>
        public void WriteToView(string str, bool isWriteLog)
        {
            WriteToView(true, str, isWriteLog, true);
        }

        /// <summary>
        /// 显示并记录
        /// </summary>
        /// <param name="info"></param>
        public void WriteToView(string info)
        {
            WriteToView(true, info, true, true);
        }

        /// <summary>
        /// 记录，并标记是否显示
        /// </summary>
        /// <param name="str"></param>
        /// <param name="isWriteLog"></param>
        public void WriteToLog(string str, bool isWriteView)
        {
            WriteToView(true, str, true, isWriteView);
        }

        #endregion
    }

    /// <summary>
    /// 日志记录
    /// </summary>
    public static class LogManager
    {
        /// <summary>
        /// 文件夹名称
        /// </summary>
        public static string FolderName = "Log";

        /// <summary>
        /// 当前进程的ID
        /// </summary>
        public static string ID = Process.GetCurrentProcess().Id.ToString();

        /// <summary>
        /// 当天日志的个数
        /// </summary>
        private static int LogIndex = 1;

        /// <summary>
        /// 当天异常日志的个数
        /// </summary>
        private static int ExIndex = 1;

        /// <summary>
        /// 记录日志的线程锁
        /// </summary>
        private static object LOCKER_LOG = new object();

        /// <summary>
        /// 记录异常的线程锁
        /// </summary>
        private static object LOCKER_EX = new object();

        /// <summary>
        /// 记录运行日志
        /// </summary>
        /// <param name="msg">日志内容</param>
        //[MethodImpl(MethodImplOptions.Synchronized)]
        public static void LogRunInfo(string msg)
        {
            lock (LOCKER_LOG)
            {
                string path;
                string file;
                try
                {
                    path = Path.Combine(AppDomain.CurrentDomain.SetupInformation.ApplicationBase
                        , "LOG\\" + FolderName, DateTime.Now.Year.ToString(), DateTime.Now.Month.ToString());
                    if (!Directory.Exists(path))
                    {
                        Directory.CreateDirectory(path);
                    }
                    var name = string.Format("{0}_{1}_{2}", FolderName, ID, DateTime.Now.ToString("yyyyMMdd"));
                    file = string.Format("{0}.log", name);
                    var pathName = Path.Combine(path, file);
                    FileInfo fi = new FileInfo(pathName);
                    if (fi.Exists)
                    {
                        while (fi.Exists
                            && fi.Length > 50 * 1024 * 1024)//50MB
                        {
                            file = string.Format("{0}_{1}.log", name, LogIndex);
                            pathName = Path.Combine(path, file);
                            fi = new FileInfo(pathName);

                            if (!fi.Exists)
                            {
                                break;
                            }
                            else if (fi.Length > 50 * 1024 * 1024)
                            {
                                //当前日志大于50MB
                                LogIndex++;
                            }
                        }
                    }
                    else
                    {
                        LogIndex = 1;
                    }

                    using (StreamWriter sw = new StreamWriter(pathName, true))
                    {
                        sw.WriteLine(string.Format("{0}  {1}", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff"), msg));
                        sw.Dispose();
                        sw.Close();
                    }
                }
                catch
                {
                }
            }
        }

        /// <summary>
        /// 记录异常日志
        /// </summary>
        /// <param name="ex">获取的异常</param>
        //[MethodImpl(MethodImplOptions.Synchronized)]
        public static void LogRunInfo(Exception ex)
        {
            lock (LOCKER_EX)
            {
                string path;
                string file;
                try
                {
                    //如果日志文件为空，则默认在Debug目录下新建 YYYY-mm-dd_Log.log文件
                    path = Path.Combine(AppDomain.CurrentDomain.SetupInformation.ApplicationBase, "LOG\\" + FolderName);
                    if (!Directory.Exists(path))
                    {
                        Directory.CreateDirectory(path);
                    }
                    var name = string.Format("{0}_Err_{1}", FolderName, DateTime.Now.ToString("yyyyMMdd"));
                    file = string.Format("{0}.log", name);
                    var pathName = Path.Combine(path, file);
                    FileInfo fi = new FileInfo(pathName);
                    if (fi.Exists)
                    {
                        while (fi.Exists
                            && fi.Length > 50 * 1024 * 1024)//50MB
                        {
                            file = string.Format("{0}_{1}.log", name, ExIndex);
                            pathName = Path.Combine(path, file);
                            fi = new FileInfo(pathName);

                            if (!fi.Exists)
                            {
                                break;
                            }
                            else if (fi.Length > 50 * 1024 * 1024)
                            {
                                ExIndex++;
                            }
                        }
                    }
                    else
                    {
                        ExIndex = 1;
                    }

                    //把异常信息输出到文件
                    using (StreamWriter fs = new StreamWriter(pathName, true))
                    {
                        fs.WriteLine("-------------------------------------------------------------");
                        fs.WriteLine("当前时间：" + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff"));
                        fs.WriteLine("异常信息：" + ex.Message);
                        fs.WriteLine("异常对象：" + ex.Source);
                        fs.WriteLine("调用堆栈：\n" + ex.StackTrace.Trim());
                        fs.WriteLine("触发方法：" + ex.TargetSite);
                        fs.WriteLine("-------------------------------------------------------------");
                        fs.WriteLine();
                        fs.Dispose();
                        fs.Close();
                    }
                }
                catch
                {
                }
            }
        }

        /// <summary>
        /// 记录日志
        /// </summary>
        /// <param name="obj"></param>
        public static void LogRunInfo(object obj)
        {
            if (obj is Exception)
            {
                LogManager.LogRunInfo(obj as Exception);
            }

            if (obj is string)
            {
                LogManager.LogRunInfo(obj as string);
            }
        }
    }

    /// <summary>
    /// 接口指针
    /// </summary>
    public class IWriteRec
    {
        public static ShowInfo g_ShowInfo = new ShowInfo();
    }