[Asp.net 5] Logging-basic architecture of the log system (I), asp. netlogging-

[Asp.net 5] Logging-basic architecture of the log system (I), asp. netlogging-

This section describes the Microsoft. Framework. Logging. Logs actions and Microsoft. Framework. Logging projects in the solution.

The relationships between all classes in the two projects are shown in:

First, we can find four core interfaces: ILogger, ILoggerFactory, ILoggerProvider, and ILogValues.

• ILogger: indicates the interface for logging. Therefore, the log writing class must implement this interface. There are two classes in the project that implement this interface: Logger and Logger <T>
• ILoggerFactory: Create an ILogger factory. It is responsible for the logic of creating a factory, but generally it is not directly created, but it is done by calling the internal ILoggerProvider.
• ILoggerProvider: You can directly create an ILogger instance and add it as an attribute to ILoggerFactory. The specific logic of ILogger is controlled by ILoggerFactory.
• ILogValues: It is input as a special object in the extension method of Logger and serves as the log data source.

The source code of the interface definition is as follows:

Public interface ILogger {void Log (LogLevel logLevel, int eventId, object state, Exception exception, Func <object, Exception, string> formatter); bool IsEnabled (LogLevel logLevel ); IDisposable BeginScopeImpl (object state );}ILogger public interface ILoggerFactory {LogLevel MinimumLevel {get; set;} ILogger CreateLogger (string categoryName); void AddProvider (ILoggerProvider );}ILoggerFactory public interface ILoggerProvider {ILogger CreateLogger (string name );}ILoggerProvider public interface ILogValues {IEnumerable <KeyValuePair <string, object> GetValues ();}ILogValues

ILogger and implementation class

Whether generic inheritance such as ILogger interface, ILogger <TCategoryName> (not defined), and Logger <T> are familiar with each other, this situation has been introduced in previous blog posts ([Asp.net 5] Localization-resx resource file managementIStringLocalizer,IStringLocalizer <T>,StringLocalizer <TResourceSource> is consistent). In actual Logger <T>, T is the sub-class of the ILogger instance. In actual mode, T contains the ILogger instance, and all external methods are only the encapsulation of the internal ILogger instance.

Public class Logger <T>: ILogger <T> {private readonly ILogger _ logger; /// <summary> // Creates a new <see cref = "Logger {T}"/>. /// </summary> /// <param name = "factory"> The factory. </param> public Logger (ILoggerFactory factory) {_ logger = factory. createLogger <T> ();} IDisposable ILogger. beginScopeImpl (object state) {return _ logger. beginScopeImpl (state);} bool ILogger. isEnabled (LogLevel logLevel) {return _ logger. isEnabled (logLevel);} void ILogger. log (LogLevel logLevel, int eventId, object state, Exception exception, Func <object, Exception, string> formatter) {_ logger. log (logLevel, eventId, state, exception, formatter );}}Logger

The Logger class also implements the ILogger interface and uses the proxy mode. However, unlike the general type of Logger <T>, the Logger class has its own internal logic. Instead, the ILogger [] _ loggers object is encapsulated internally. Make Logger more like LoggerManage. However, because Logger also implements the Logger interface, the Logger class is the agent for managing other Logger classes. The internal _ loggers of Logger are encapsulated by the LoggerFactory object. When logging, traverse the internal _ loggers object in sequence to write logs.

Internal class Logger: ILogger {private readonly LoggerFactory _ loggerFactory; private readonly string _ name; private ILogger [] _ loggers = new ILogger [0]; public Logger (LoggerFactory loggerFactory, string name) {_ loggerFactory = loggerFactory; _ name = name; var providers = loggerFactory. getProviders (); _ loggers = new ILogger [providers. length]; for (var index = 0; index! = Providers. length; index ++) {_ loggers [index] = providers [index]. createLogger (name) ;}} public void Log (LogLevel logLevel, int eventId, object state, Exception exception, Func <object, Exception, string> formatter) {if (logLevel> = _ loggerFactory. minimumLevel) {foreach (var logger in _ loggers) {logger. log (logLevel, eventId, state, exception, formatter) ;}} public bool IsEnabled (LogLevel logL Evel) {if (logLevel <_ loggerFactory. minimumLevel) {return false;} foreach (var logger in _ loggers) {if (logger. isEnabled (logLevel) {return true ;}} return false;} public IDisposable BeginScopeImpl (object state) {var loggers = _ loggers; var scope = new Scope (loggers. length); for (var index = 0; index! = Loggers. length; index ++) {scope. setDisposable (index, loggers [index]. beginScopeImpl (state);} return scope;} internal void AddProvider (ILoggerProvider provider) {var logger = provider. createLogger (_ name); _ loggers = _ loggers. concat (new [] {logger }). toArray ();} private class Scope: IDisposable {private bool _ isDisposed; private IDisposable _ disposable0; private IDisposable _ disposable1; pri Vate readonly IDisposable [] _ disposable; public Scope (int count) {if (count> 2) {_ disposable = new IDisposable [count-2];} public void SetDisposable (int index, IDisposable disposable) {if (index = 0) {_ disposable0 = disposable;} else if (index = 1) {_ disposable1 = disposable ;} else {_ disposable [index-2] = disposable;} protected virtual void Dispose (bool disposing) {if (! _ IsDisposed) {if (disposing) {if (_ disposable0! = Null) {_ disposable0.Dispose ();} if (_ disposable1! = Null) {_ disposable1.Dispose ();} if (_ disposable! = Null) {var count = _ disposable. Length; for (var index = 0; index! = Count; ++ index) {if (_ disposable [index]! = Null) {_ disposable [index]. dispose () ;}}}_ isDisposed = true ;}// This code added to correctly implement the disposable pattern. public void Dispose () {// Do not change this code. put cleanup code in Dispose (bool disposing) abve. dispose (true); // TODO: tell GC not to call its finalizer when the above finalizer is overridden. // GC. suppressFinalize (this);} internal void Add (IDisposable disposable) {throw new NotImplementedException ();}}}Logger

ILoggerFactory and implementation class

ILoggerFactory has two main functions: Add a new ILoggerProvider and create an ILogger. The only implementation class of ILoggerFactory is LoggerFactory, which simply implements the above two functions and maintains the _ loggers copy in LoggerFactory. The loggers are Logger type (non-generic type), but the categoryName is different. The Logger created through LoggerFactory is shown in:

Public class LoggerFactory: ILoggerFactory {private readonly Dictionary <string, Logger> _ loggers = new Dictionary <string, Logger> (StringComparer. ordinal); private ILoggerProvider [] _ providers = new ILoggerProvider [0]; private readonly object _ sync = new object (); public ILogger CreateLogger (string categoryName) {Logger logger; lock (_ sync) {if (! _ Loggers. tryGetValue (categoryName, out logger) {logger = new Logger (this, categoryName); _ loggers [categoryName] = logger;} return logger;} public LogLevel MinimumLevel {get; set ;}= LogLevel. verbose; public void AddProvider (ILoggerProvider provider) {lock (_ sync) {_ providers = _ providers. concat (new [] {provider }). toArray (); foreach (var logger in _ loggers) {logger. value. addProvider (provider) ;}} internal ILoggerProvider [] GetProviders () {return _ providers ;}}LoggerFactory