.Net Core Logger 实现log写入本地文件系统

.net core 自带一个基础的logger框架Microsoft.Extensions.Logging。

微软默认实现了Microsoft.Extensions.Logging.Console.dll。控制台的日志输出和Microsoft.Extensions.Logging.Debug.dll调试输出。

下面我们写一个我们自己的本地文件输出模块demo，简单理解一下自带的这个logger系统。

logger框架主要几个类：LoggerFactory，Logger，LoggerProvider。

看名字就很好理解，都不需要解释。

实现我们自己的file logger只需要实现logger，loggerProvider即可。

第一步：入口。

loggerFactory.AddFile(this.Configuration.GetSection("FileLogging"));

为LoggerFactory扩张一个方法，提供增加日志写文件方式的入口。相关的配置来自appsettings.json

     public static class FileLoggerExtensions

     {

         //add 日志文件创建规则，分割规则，格式化规则，过滤规则 to appsettings.json

         public static ILoggerFactory AddFile(this ILoggerFactory factory, IConfiguration configuration)

         {

             return AddFile(factory, new FileLoggerSettings(configuration));

         }

         public static ILoggerFactory AddFile(this ILoggerFactory factory, FileLoggerSettings fileLoggerSettings)

         {

             factory.AddProvider(new FileLoggerProvider(fileLoggerSettings));

             return factory;

         }

     }

第二步：实现我们的logger提供程序，实现ILoggerProvider接口

public class FileLoggerProvider : ILoggerProvider, Idisposable

关键方法CreateLogger，创建真正写日志的logger。对当前的logger可以做适当的缓存，配置logger

     public class FileLoggerProvider : ILoggerProvider, IDisposable

     {

         FileLoggerSettings _configuration;

         readonly ConcurrentDictionary<string, InitLoggerModel> _loggerKeys = new ConcurrentDictionary<string, InitLoggerModel>();

         readonly ConcurrentDictionary<string, FileLogger> _loggers = new ConcurrentDictionary<string, FileLogger>();

         public FileLoggerProvider(FileLoggerSettings configuration)

         {

             _configuration = configuration;

             _configuration.ChangeToken.RegisterChangeCallback(p =>

             {

                 //appsettings.json changed. reload settings.

                 _configuration.Reload();

                 //update loggers settings form new settings

                 foreach (var item in this._loggers.Values)

                 {

                     InitLoggerModel model = new InitLoggerModel();

                     InitLoggerSettings(item.Name, model);

                     InitLogger(model, item);

                 }

             }, null);

         }

         public ILogger CreateLogger(string categoryName)

         {

             var loggerKey = this._loggerKeys.GetOrAdd(categoryName, p =>

              {

                  InitLoggerModel model = new InitLoggerModel();

                  InitLoggerSettings(categoryName, model);

                  return model;

              });

             var key = loggerKey.FileDiretoryPath + loggerKey.FileNameTemplate;

             return this._loggers.GetOrAdd(key, p =>

             {

                 var logger = new FileLogger(categoryName);

                 InitLogger(loggerKey, logger);

                 return logger;

             });

         }

         private static void InitLogger(InitLoggerModel model, FileLogger logger)

         {

             logger.FileNameTemplate = model.FileNameTemplate;

             logger.FileDiretoryPath = model.FileDiretoryPath;

             logger.MinLevel = model.MinLevel;

         }

         class InitLoggerModel

         {

             public LogLevel MinLevel { get; set; }

             public string FileDiretoryPath { get; set; }

             public string FileNameTemplate { get; set; }

             public override int GetHashCode()

             {

                 return this.MinLevel.GetHashCode() + this.FileDiretoryPath.GetHashCode() + this.FileNameTemplate.GetHashCode();

             }

             public override bool Equals(object obj)

             {

                 var b = obj as InitLoggerModel;

                 if (b == null)

                     return false;

                 return this.MinLevel == b.MinLevel && this.FileDiretoryPath == b.FileDiretoryPath && this.FileNameTemplate == b.FileNameTemplate;

             }

         }

         private void InitLoggerSettings(string categoryName, InitLoggerModel model)

         {

             model.MinLevel = LogLevel.Debug;

             var keys = this.GetKeys(categoryName);

             foreach (var item in keys)

             {

                 var switchV = _configuration.GetSwitch(item);

                 if (switchV.Item1)

                 {

                     model.MinLevel = switchV.Item2;

                     break;

                 }

             }

             model.FileDiretoryPath = this._configuration.DefaultPath;

             foreach (var item in keys)

             {

                 var switchV = _configuration.GetDiretoryPath(item);

                 if (switchV.Item1)

                 {

                     model.FileDiretoryPath = switchV.Item2;

                     break;

                 }

             }

             model.FileNameTemplate = this._configuration.DefaultFileName;

             foreach (var item in keys)

             {

                 var switchV = _configuration.GetFileName(item);

                 if (switchV.Item1)

                 {

                     model.FileNameTemplate = switchV.Item2;

                     break;

                 }

             }

         }

         IEnumerable<string> GetKeys(string categoryName)

         {

             while (!String.IsNullOrEmpty(categoryName))

             {

                 // a.b.c

                 //--result

                 // a.b.c，a.b，a，Default

                 yield return categoryName;

                 var last = categoryName.LastIndexOf('.');

                 if (last <= )

                 {

                     yield return "Default";

                     yield break;

                 }

                 System.Diagnostics.Debug.WriteLine(categoryName + "--" + last);

                 categoryName = categoryName.Substring(, last);

             }

             yield break;

         }

         public void Dispose()

         {

         }

     }

第三步：实现我们的logger，实现ILogger接口。真正将log写入file

public class FileLogger : Ilogger

     public class FileLogger : ILogger

     {

         static protected string delimiter = new string(new char[] { (char) });

         public FileLogger(string categoryName)

         {

             this.Name = categoryName;

         }

         class Disposable : IDisposable

         {

             public void Dispose()

             {

             }

         }

         Disposable _DisposableInstance = new Disposable();

         public IDisposable BeginScope<TState>(TState state)

         {

             return _DisposableInstance;

         }

         public bool IsEnabled(LogLevel logLevel)

         {

             return this.MinLevel <= logLevel;

         }

         public void Reload()

         {

             _Expires = true;

         }

         public string Name { get; private set; }

         public LogLevel MinLevel { get; set; }

         public string FileDiretoryPath { get; set; }

         public string FileNameTemplate { get; set; }

         public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)

         {

             if (!this.IsEnabled(logLevel))

                 return;

             var msg = formatter(state, exception);

             this.Write(logLevel, eventId, msg, exception);

         }

         void Write(LogLevel logLevel, EventId eventId, string message, Exception ex)

         {

             EnsureInitFile();

             //TODO 提高效率 队列写！！！

             var log = String.Concat(DateTime.Now.ToString("HH:mm:ss"), '[', logLevel.ToString(), ']', '[',

                   Thread.CurrentThread.ManagedThreadId.ToString(), ',', eventId.Id.ToString(), ',', eventId.Name, ']',

                   delimiter, message, delimiter, ex?.ToString());

             lock (this)

             {

                 this._sw.WriteLine(log);

             }

         }

         bool _Expires = true;

         string _FileName;

         protected StreamWriter _sw;

         void EnsureInitFile()

         {

             if (CheckNeedCreateNewFile())

             {

                 lock (this)

                 {

                     if (CheckNeedCreateNewFile())

                     {

                         InitFile();

                         _Expires = false;

                     }

                 }

             }

         }

         bool CheckNeedCreateNewFile()

         {

             if (_Expires)

             {

                 return true;

             }

             //TODO 使用 RollingType判断是否需要创建文件。提高效率！！！

             if (_FileName != DateTime.Now.ToString(this.FileNameTemplate))

             {

                 return true;

             }

             return false;

         }

         void InitFile()

         {

             if (!Directory.Exists(this.FileDiretoryPath))

             {

                 Directory.CreateDirectory(this.FileDiretoryPath);

             }

             var path = "";

             int i = ;

             do

             {

                 _FileName = DateTime.Now.ToString(this.FileNameTemplate);

                 path = Path.Combine(this.FileDiretoryPath, _FileName + "_" + i + ".log");

                 i++;

             } while (System.IO.File.Exists(path));

             var oldsw = _sw;

             _sw = new StreamWriter(new FileStream(path, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.Read), Encoding.UTF8);

             _sw.AutoFlush = true;

             if (oldsw != null)

             {

                 try

                 {

                     _sw.Flush();

                     _sw.Dispose();

                 }

                 catch

                 {

                 }

             }

         }

     }

代码：https://github.com/czd890/NetCoreWebApp

巴特西

.Net Core Logger 实现log写入本地文件系统

最新文章

热门文章