.Net Core日志记录器实例分析

这篇“.net Core日志记录器实例分析”文章的知识点大部分人都不太理解，所以小编给大家总结了以下内容，内容详细，步骤清晰，具有一定的借鉴价值，希望大家阅读完这篇文章能有所收获，下面我们一起来看看这篇“.Net Core日志记录器实例分析”文章吧。

日志记录器工厂

1 ILoggerFactory 接口

public interface ILoggerFactory : IDisposable{    ILogger CreateLogger(string cateGoryName);    void AddProvider(ILoggerProvider provider);}

ILoggerFactory是日志记录器的工厂接口类，用于配置日志记录系统并创建Logger实例的类，默认实现两个接口方法为，通过CreateLogger()方法来创建ILogger实例，（其中参数categoryName是一个日志类别，用于调用Logger所在类的全名，类别指明日志消息是谁写入的，一般我们将日志所属的的组件、服务或者消息类型名称作为日志类别。） 而AddProvider()添加日志记录提供程序，向日志系统注册添加一个ILoggerProvider。工厂接口类的默认实现类为LoggerFactory , 我们继续往下看：

2 LoggerFactory 实现

ILoggerFactory 的默认实现是 LoggerFactory ,在构造函数中，如下：

    public class LoggerFactory : ILoggerFactory    {        private static readonly LoggerRuleSelector RuleSelector = new LoggerRuleSelector();        private readonly Dictionary<string, Logger> _loggers = new Dictionary<string, Logger>(StrinGComparer.Ordinal);                private readonly List<ProviderReGIStration> _providerRegistrations = new List<ProviderRegistration>();                private readonly object _sync = new object();                private volatile bool _disposed;                private IDisposable _changeTokenRegistration;                private LoggerFilterOptions _filterOptions;                private LoggerExternalScopeProvider _scopeProvider;                public LoggerFactory() : this(Enumerable.Empty<ILoggerProvider>())        {        }                public LoggerFactory(IEnumerable<ILoggerProvider> providers) : this(providers, new StaticFilterOptionsMonitor(new LoggerFilterOptions()))        {        }                public LoggerFactory(IEnumerable<ILoggerProvider> providers, LoggerFilterOptions filterOptions) : this(providers, new StaticFilterOptionsMonitor(filterOptions))        {        }                public LoggerFactory(IEnumerable<ILoggerProvider> providers, IOptionsMonitor<LoggerFilterOptions> filterOption)        {            foreach (var provider in providers)            {                AddProviderRegistration(provider, dispose: false);            }            _changeTokenRegistration = filterOption.OnChange(RefreshFilters);            RefreshFilters(filterOption.CurrentValue);        }                private void AddProviderRegistration(ILoggerProvider provider, bool dispose)        {            _providerRegistrations.Add(new ProviderRegistration            {                Provider = provider,                ShouldDispose = dispose            });            if (provider is ISupportExternalScope supportsExternalScope)            {                if (_scopeProvider == null)                {                    _scopeProvider = new LoggerExternalScopeProvider();                }                supportsExternalScope.SetScopeProvider(_scopeProvider);            }        }    }

从LoggerFactory 中 的构造函数中可以发现，通过注入的方式获取到ILoggerProvider（这个在下文中会说明），并调用AddProviderRegistration方法添加注册程序，将ILoggerProvider保存到ProviderRegistration集合中。

AddProviderRegistration 方法：

这是一个日志程序提供器，将ILoggerProvider保存到ProviderRegistration集合中。当日志提供器实现 ISupportExternalScope 接口将单例 LoggerExternalScopeProvider 保存到 provider._scopeProvider 中。

ProviderRegistration集合:

private struct ProviderRegistration{   public ILoggerProvider Provider;   public bool ShouldDispose;}

其中的 ShouldDispose 字段标识在在LoggerFactory生命周期结束之后，该ILoggerProvider是否需要释放。虽然在系统中LoggerFactory为单例模式，但是其提供了一个静态方法生成一个可释放的DisposingLoggerFactory。

在LoggerFactory 实现默认的接口方法CreateLogger(),AddProvider()

查看源码如下：

CreateLogger

创建ILogger实例，CreateLogger() 源码如下：

    public class LoggerFactory : ILoggerFactory    {         private readonly Dictionary<string, Logger> _loggers = new Dictionary<string, Logger>(StringComparer.Ordinal);                 private readonly List<ProviderRegistration> _providerRegistrations = new List<ProviderRegistration>();                private struct ProviderRegistration        {            public ILoggerProvider Provider;            public bool ShouldDispose;        }                public ILogger CreateLogger(string categoryName)        {            if (CheckDisposed())            {                throw new ObjectDisposedException(nameof(LoggerFactory));            }            lock (_sync)            {                if (!_loggers.TryGetValue(categoryName, out var logger))                {                    logger = new Logger                    {                        Loggers = CreateLoggers(categoryName),                    };                    (logger.MessageLoggers, logger.ScopeLoggers) = ApplyFilters(logger.Loggers);                    _loggers[categoryName] = logger;                }                return logger;            }        }                private LoggerInfORMation[] CreateLoggers(string categoryName)        {            var loggers = new LoggerInformation[_providerRegistrations.Count];            for (var i = 0; i < _providerRegistrations.Count; i++)            {                loggers[i] = new LoggerInformation(_providerRegistrations[i].Provider, categoryName);            }            return loggers;        }    }

从源码可以看出，CreateLogger方法中，会检测资源是否被释放，在方法中，根据内部定义的字典集合Dictionary<string, Logger> _loggers,判断字典中是否存在对应的Logger属性对象，如果不存在，会调用CreateLoggers方法根据之前注册的的所有ILoggerProvider 所创建出来 ProviderRegistration 集合来实现创建Logger属性集合（根据日志类别生成了对应实际的日志写入类FileLogger、ConsoleLogger等），并通过字典集合的方式保存categoryName和对应的Logger。

创建 Logger 需要的 LoggerInformation[]

internal readonly struct LoggerInformation{    public LoggerInformation(ILoggerProvider provider, string category) : this()    {        ProviderType = provider.GetType();        Logger = provider.CreateLogger(category);        Category = category;        ExternalScope = provider is ISupportExternalScope;    }    public ILogger Logger { get; }        public string Category { get; }        public Type ProviderType { get; }        public bool ExternalScope { get; }}

根据注册的ILoggerProvider，创建ILogger 其中的字段说明：

Logger ：具体日志类别写入途径实现类

Category ： 日志类别名称

ProviderType ： 日志提供器Type

ExternalScope ：是否支持 ExternalScope

继续看CreateLogger方法，在创建Logger之后，还调用了ApplyFilters方法：

        private (MessageLogger[] MessageLoggers, ScopeLogger[] ScopeLoggers) ApplyFilters(LoggerInformation[] loggers)        {            var messageLoggers = new List<MessageLogger>();            var scopeLoggers = _filterOptions.CaptureScopes ? new List<ScopeLogger>() : null;            foreach (var loggerInformation in loggers)            {                RuleSelector.Select(_filterOptions,                    loggerInformation.ProviderType,                    loggerInformation.Category,                    out var minLevel,                    out var filter);                if (minLevel != null && minLevel > LogLevel.Critical)                {                    continue;                }                messageLoggers.Add(new MessageLogger(loggerInformation.Logger, loggerInformation.Category, loggerInformation.ProviderType.FullName, minLevel, filter));                if (!loggerInformation.ExternalScope)                {                    scopeLoggers?.Add(new ScopeLogger(logger: loggerInformation.Logger, externalScopeProvider: null));                }            }            if (_scopeProvider != null)            {                scopeLoggers?.Add(new ScopeLogger(logger: null, externalScopeProvider: _scopeProvider));            }            return (messageLoggers.ToArray(), scopeLoggers?.ToArray());        }

由源码可以看出，

MessageLogger[] 集合取值：

在获取LoggerInformation[]后进行传参，进行遍历，根据RuleSelector过滤器，从配置文件中读取对应的日志级别，过滤器会返回获取最低级别和对应的一条过滤规则，如果配置文件中没有对应的配置，默认取全局最低级别（MinLevel）,如果读取到的日志级别大于LogLevel.Critical,则将其加入MessageLogger[]。

过滤器的规则：

选择当前记录器类型的规则，如果没有，请选择未指定记录器类型的规则

选择最长匹配类别的规则

如果没有与类别匹配的内容，则采用所有没有类别的规则

如果只有一条规则，则使用它的级别和过滤器

如果有多个规则，请选择使用最后一条。

如果没有适用的规则，请使用全局最低级别

通过MessageLogger[]添加消息日志集合

internal readonly struct MessageLogger{    public MessageLogger(ILogger logger, string category, string providerTypeFullName, LogLevel? minLevel, Func<string, string, LogLevel, bool> filter)    {        Logger = logger;        Category = category;        ProviderTypeFullName = providerTypeFullName;        MinLevel = minLevel;        Filter = filter;    }    public ILogger Logger { get; }    public string Category { get; }    private string ProviderTypeFullName { get; }    public LogLevel? MinLevel { get; }    public Func<string, string, LogLevel, bool> Filter { get; }    public bool IsEnabled(LogLevel level)    {        if (MinLevel != null && level < MinLevel)        {            return false;        }        if (Filter != null)        {            return Filter(ProviderTypeFullName, Category, level);        }        return true;    }}internal readonly struct ScopeLogger{    public ScopeLogger(ILogger logger, IExternalScopeProvider externalScopeProvider)    {        Logger = logger;        ExternalScopeProvider = externalScopeProvider;    }    public ILogger Logger { get; }    public IExternalScopeProvider ExternalScopeProvider { get; }    public IDisposable CreateScope<TState>(TState state)    {        if (ExternalScopeProvider != null)        {            return ExternalScopeProvider.Push(state);        }        return Logger.BeginScope<TState>(state);    }}

在MessageLogger[]中带有MinLevel属性和Filter委托两种过滤配置，而这两种配置的来源，在上一章中可以看到，分别是从配置文件（AddConfiguration）和直接使用委托（AddFilter）来进行配置的。

再由上面的IsEnabled方法可以看出，会先使用 MinLevel 过滤，再使用 Filter 进行过滤。所以这两者存在优先级。

ScopeLogger[ ] 取值 :

如果 ILoggerProvider实现了ISupportExternalScope接口，那么使用LoggerExternalScopeProvider作为Scope功能的实现。反之，使用ILogger作为其Scope功能的实现。

LoggerExternalScopeProvider ：

• 通过 Scope 组成了一个单向链表，每次 beginscope 向链表末端增加一个新的元素，Dispose的时候，删除链表最末端的元素。我们知道LoggerExternalScopeProvider 在系统中是单例模式，多个请求进来，加入线程池处理。通过使用AsyncLoca来实现不同线程间数据独立。

• 有两个地方开启了日志作用域：

• 通过Socket监听到请求后，将KestrelConnection加入线程池，线程池调度执行IThreadPoolWorkItem.Execute()方法。在这里开启了一次

• 在构建请求上下文对象的时候(HostingApplication.CreateContext())，开启了一次

由上源码可以得出：在工厂记录器类中，通过系统依赖注入的方式解析所有注册的ILoggerProvider，然后调用其中的CreateLogger方法实现创建一个Logger实例对象，而这个Logger实例对象会根据根据注册的ILoggerProvider创建需要的 LoggerInformation[]，并将此对象作为参数进行ApplyFilters过滤器筛选,得到对应的最低等级或过滤规则，最后通过调用Log方法日志记录的时候，会遍历MessageLogger[]集合，根据logger日志类别对应实际不同的日志写入类，调用ILoggerProvider具体实现类 (可以看下文说明) 中的Log方法。

AddProviderRegistration→CreateLoggers→LoggerInformation[]→ApplyFilters→MessageLogger[]→Log→ILoggerProvider ( 执行具体类中的Log方法 )

ILoggerFactory 来源：

应用程序在启动初始化的时候会通过注入的方式CreateDefaultBuilder→ConfigureLogging→AddLogging

public static IServiceCollection AddLogging(this IServiceCollection services, Action<ILoggingBuilder> configure){    if (services == null)    {       throw new ArgumentNullException(nameof(services));    }        services.AddOptions();    services.TryAdd(ServiceDescriptor.Singleton<ILoggerFactory, LoggerFactory>());    services.TryAdd(ServiceDescriptor.Singleton(typeof(ILogger<>), typeof(Logger<>)));        services.TryAddEnumerable(ServiceDescriptor.Singleton<IConfigureOptions<LoggerFilterOptions>>(       new DefaultLoggerLevelConfigureOptions(LogLevel.Information)));        configure(new LoggingBuilder(services));    return services;}

实现将把ILoggerFactory对象以依赖注入的方式托管到集合容器中，为程序调用提供使用。

日志记录提供器

1 ILoggerProvider 接口

创建ILogger实例的类型，根据日志类别名称创建一个新的ILogger实例

public interface ILoggerProvider : IDisposable{    ILogger CreateLogger(string categoryName);}

这个是具体的日志写入类，在工厂记录器中我们已经提到了这个，在LoggerInformation[]中会根据日志类别注册对应的ILoggerProvider，在系统中我们就可以通过ILogger同时向多个途经写入日志信息。（这也是对上一篇中留下的问题进行再次说明）

ILoogerProvider继承了IDisposable接口，如果某个具体的ILoggerProvider对象需要释放资源，就可以将相关的操作实现在Dispose方法中。

默认的实现方式为多个，官方实现的由ConsoleLoggerProvider 、DebugLoggerProvider 、EventSourceLoggerProvider、EventLogLoggerProvider 、TraceSourceLoggerProvider

以ConsoleLoggerProvider为列

    [ProviderAlias("Console")]    public class ConsoleLoggerProvider : ILoggerProvider, ISupportExternalScope    {        private readonly IOptionsMonitor<ConsoleLoggerOptions> _options;        private readonly ConcurrentDictionary<string, ConsoleLogger> _loggers;        private readonly ConsoleLoggerProcessor _messageQueue;        private IDisposable _optionsReloadToken;        private IExternalScopeProvider _scopeProvider = NullExternalScopeProvider.Instance;         public ConsoleLoggerProvider(IOptionsMonitor<ConsoleLoggerOptions> options)        {            _options = options;            _loggers = new ConcurrentDictionary<string, ConsoleLogger>();            ReloadLoggerOptions(options.CurrentValue);            _optionsReloadToken = _options.OnChange(ReloadLoggerOptions);            _messageQueue = new ConsoleLoggerProcessor();            if (RuntimeInformation.IsOSPlatform(OSPlatform.windows))            {                _messageQueue.Console = new WindowsLogConsole();                _messageQueue.ErrorConsole = new WindowsLogConsole(stdErr: true);            }            else            {                _messageQueue.Console = new AnsiLogConsole(new AnsiSystemConsole());                _messageQueue.ErrorConsole = new AnsiLogConsole(new AnsiSystemConsole(stdErr: true));            }        }        private void ReloadLoggerOptions(ConsoleLoggerOptions options)        {            foreach (var logger in _loggers)            {                logger.Value.Options = options;            }        }        public ILogger CreateLogger(string name)        {            return _loggers.GetOrAdd(name, loggerName => new ConsoleLogger(name, _messageQueue)            {                Options = _options.CurrentValue,                ScopeProvider = _scopeProvider            });        }         public void Dispose()        {            _optionsReloadToken?.Dispose();            _messageQueue.Dispose();        }         public void SetScopeProvider(IExternalScopeProvider scopeProvider)        {            _scopeProvider = scopeProvider;            foreach (var logger in _loggers)            {                logger.Value.ScopeProvider = _scopeProvider;            }        }    }

在ConsoleLoggerProvider类型定义中，标注了ProviderAliasAttribute特性，并设置别名为Console,所以在配置过滤规则的时候，可以直接使用这个名称。ILogger的创建实现了具体日志类ConsoleLogger。 

日志记录器

1 ILogger 接口

表示用于执行日志记录的类型，是系统中写入日志的统一入口。

public interface ILogger{     void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter);         bool IsEnabled(LogLevel logLevel);         IDisposable BeginScope<TState>(TState state);}

定义了三个方法，Log<TState>() 用于写入日志，IsEnabled()用于检查判断日志级别是否开启，BeginScope() 用于指日志作用域。

2 Logger 实现

ILogger执行记录接口类的具体实现Logger如下：

internal class Logger : ILogger{    public LoggerInformation[] Loggers { get; set; }    public MessageLogger[] MessageLoggers { get; set; }    public ScopeLogger[] ScopeLoggers { get; set; }    public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)    {        var loggers = MessageLoggers;        if (loggers == null)        {            return;        }        List<Exception> exceptions = null;        for (var i = 0; i < loggers.Length; i++)        {            ref readonly var loggerInfo = ref loggers[i];            if (!loggerInfo.IsEnabled(logLevel))            {                continue;            }            LoggerLog(logLevel, eventId, loggerInfo.Logger, exception, formatter, ref exceptions, state);        }        if (exceptions != null && exceptions.Count > 0)        {            ThrowLoggingError(exceptions);        }        static void LoggerLog(LogLevel logLevel, EventId eventId, ILogger logger, Exception exception, Func<TState, Exception, string> formatter, ref List<Exception> exceptions, in TState state)        {            try            {                logger.Log(logLevel, eventId, state, exception, formatter);            }            catch (Exception ex)            {                if (exceptions == null)                {                    exceptions = new List<Exception>();                }                exceptions.Add(ex);            }        }    }    public bool IsEnabled(LogLevel logLevel)    {        var loggers = MessageLoggers;        if (loggers == null)        {            return false;        }        List<Exception> exceptions = null;        var i = 0;        for (; i < loggers.Length; i++)        {            ref readonly var loggerInfo = ref loggers[i];            if (!loggerInfo.IsEnabled(logLevel))            {                continue;            }            if (LoggerIsEnabled(logLevel, loggerInfo.Logger, ref exceptions))            {                break;            }        }        if (exceptions != null && exceptions.Count > 0)        {            ThrowLoggingError(exceptions);        }        return i < loggers.Length ? true : false;        static bool LoggerIsEnabled(LogLevel logLevel, ILogger logger, ref List<Exception> exceptions)        {            try            {                if (logger.IsEnabled(logLevel))                {                    return true;                }            }            catch (Exception ex)            {                if (exceptions == null)                {                    exceptions = new List<Exception>();                }                exceptions.Add(ex);            }            return false;        }    }}

源码中MessageLogger[]在上文已经提到了，其中保存了在配置中启用的那些对应的ILogger。

需要注意的是，由于配置文件更改后，会调用ApplyFilters()方法，并为MessageLogger[]赋新值，所以在遍历之前，需要保存当前值，再进行处理。否则会出现修改异常。

在系统中统一写入日志的入口，通过日志等级作为参数调用其IsEnabled方法来确定当前日志是否执行对应具体日志的实现类，当符合条件执行具体日志输出到对应的写入途径中会调用对应的Log方法（需要提供一个EventId来标识当前日志事件）

ILogger默认的实现方式为多个，官方实现的由ConsoleLogger 、DebugLogger 、EventSourceLogger、EventLogLogger、TraceSourceLogger具体日志实现类代表不同的日志写入途径。

以上就是关于“.Net Core日志记录器实例分析”这篇文章的内容，相信大家都有了一定的了解，希望小编分享的内容对大家有帮助，若想了解更多相关的知识内容，请关注编程网精选频道。