.Net Core日志记录之自定义日志组件

下面是关于“.Net Core日志记录之自定义日志组件”的完整攻略。

1. 简介

.Net Core提供了强大的日志记录功能，方便开发人员在应用程序运行时监测和跟踪代码中的问题。通常的做法是使用内置的日志记录器，如Microsoft.Extensions.Logging.Console、Microsoft.Extensions.Logging.Debug等日志记录器，这些记录器可以将日志输出到控制台、调试窗口等目标。

不过，有些时候，我们需要自定义一个日志记录器，以满足特定的需求，例如将日志记录到数据库、将日志记录到文件中等。本文将介绍如何使用自定义日志组件在.Net Core中记录日志。

2. 创建自定义日志组件

首先，我们需要创建一个自定义的日志组件，并实现ILogger接口中的方法。

public class MyLogger : ILogger
{
    private readonly string _categoryName;
    private readonly Func<string, LogLevel, bool> _filter;

    public MyLogger(string categoryName, Func<string, LogLevel, bool> filter)
    {
        _categoryName = categoryName;
        _filter = filter;
    }

    public IDisposable BeginScope<TState>(TState state)
    {
        return NoopDisposable.Instance;
    }

    public bool IsEnabled(LogLevel logLevel)
    {
        return logLevel != LogLevel.None && _filter(_categoryName, logLevel);
    }

    public void Log<TState>(LogLevel logLevel, EventId eventId, TState state,
        Exception exception, Func<TState, Exception, string> formatter)
    {
        if (!IsEnabled(logLevel))
        {
            return;
        }

        // Perform logging...
    }

    private class NoopDisposable : IDisposable
    {
        public static NoopDisposable Instance = new NoopDisposable();

        public void Dispose()
        {
        }
    }
}

在上面的例子中，我们创建了一个名为MyLogger的类，它实现了ILogger接口中定义的所有方法。其中，BeginScope()方法返回了一个空的NoopDisposable对象，IsEnabled()方法用于检测当前日志级别是否被启用，Log()方法则是实际的日志记录逻辑。

请注意，在Log()方法中，我们使用了一个名为formatter的函数委托，它将state和exception转换为一个字符串。我们可以使用这个委托来自定义日志输出格式。

3. 注册自定义日志组件

接下来，我们需要将自定义的日志组件注册到DI容器中。可以在应用程序启动时，通过CreateLogger()方法将日志组件注入到容器中，例如：

public static IWebHost BuildWebHost(string[] args) =>
    WebHost.CreateDefaultBuilder(args)
           .ConfigureLogging(logging =>
           {
               logging.ClearProviders();
               logging.AddConsole();
               logging.AddDebug();
               logging.AddProvider(new MyLoggerProvider());
           })
           .UseStartup<Startup>()
           .Build();

在这个例子中，我们使用logging.AddProvider()方法将自定义的日志组件MyLoggerProvider注入到容器中。

4. 创建日志提供程序

接着，我们需要创建一个实现了ILoggerProvider接口的日志提供程序，它负责创建MyLogger实例并将其提供给ILoggerFactory。

public class MyLoggerProvider : ILoggerProvider
{
    private readonly Func<string, LogLevel, bool> _filter;
    private readonly ConcurrentDictionary<string, MyLogger> _loggers = new ConcurrentDictionary<string, MyLogger>();

    public MyLoggerProvider()
    {
    }

    public MyLoggerProvider(Func<string, LogLevel, bool> filter)
    {
        _filter = filter;
    }

    public ILogger CreateLogger(string categoryName)
    {
        return _loggers.GetOrAdd(categoryName, CreateLoggerImplementation);
    }

    public void Dispose()
    {
        _loggers.Clear();
    }

    private MyLogger CreateLoggerImplementation(string name)
    {
        return new MyLogger(name, _filter);
    }
}

在上面的例子中，我们创建了一个名为MyLoggerProvider的类，它实现了ILoggerProvider接口中定义的所有方法。在CreateLogger()方法中，我们使用了一个线程安全的字典来缓存MyLogger实例，以便在需要时进行检索和重用。

5. 使用自定义日志组件

现在，我们已经创建了一个自定义的日志组件，并将其注册到了应用程序中。接下来，我们可以使用这个日志组件来记录日志信息了。

在代码中使用自定义日志组件时，你可以像使用其他内置日志记录器一样使用它：

public class MyController : Controller
{
    private readonly ILogger _logger;

    public MyController(ILogger<MyController> logger)
    {
        _logger = logger;
    }

    public IActionResult Index()
    {
        _logger.LogInformation("This is an information message...");
        _logger.LogError("This is an error message...");
        return View();
    }
}

在上面的例子中，我们在MyController控制器中注入了一个MyLogger实例，并使用_logger.LogInformation()和_logger.LogError()方法记录一些日志信息。

6. 示例

下面举两个简单的例子，以便更好地理解如何使用自定义日志组件。

6.1 记录日志到文件

如果你希望将日志记录到文件中，你可以在自定义日志组件中实现相应的逻辑：

public class FileLogger : ILogger
{
    private readonly string _categoryName;
    private readonly Func<string, LogLevel, bool> _filter;
    private readonly string _filePath;

    public FileLogger(string categoryName, Func<string, LogLevel, bool> filter, string filePath)
    {
        _categoryName = categoryName;
        _filter = filter;
        _filePath = filePath;
    }

    public IDisposable BeginScope<TState>(TState state)
    {
        return NoopDisposable.Instance;
    }

    public bool IsEnabled(LogLevel logLevel)
    {
        return logLevel != LogLevel.None && _filter(_categoryName, logLevel);
    }

    public void Log<TState>(LogLevel logLevel, EventId eventId, TState state,
        Exception exception, Func<TState, Exception, string> formatter)
    {
        if (!IsEnabled(logLevel))
        {
            return;
        }

        var message = $"[{DateTime.Now}] {logLevel}: {formatter(state, exception)}{Environment.NewLine}";
        File.AppendAllText(_filePath, message);
    }

    private class NoopDisposable : IDisposable
    {
        public static NoopDisposable Instance = new NoopDisposable();

        public void Dispose()
        {
        }
    }
}

在上面的例子中，我们创建了一个名为FileLogger的日志组件，它将日志记录到指定的文件中。在Log()方法中，我们使用了File.AppendAllText()方法，将日志信息写入到文件中。

为了使用自定义的文件日志组件，你需要创建一个相应的ILoggerProvider实现：

public class FileLoggerProvider : ILoggerProvider
{
    private readonly Func<string, LogLevel, bool> _filter;
    private readonly string _filePath;
    private readonly ConcurrentDictionary<string, FileLogger> _loggers = new ConcurrentDictionary<string, FileLogger>();

    public FileLoggerProvider(string filePath)
    {
        _filePath = filePath;
    }

    public FileLoggerProvider(Func<string, LogLevel, bool> filter, string filePath)
    {
        _filter = filter;
        _filePath = filePath;
    }

    public ILogger CreateLogger(string categoryName)
    {
        return _loggers.GetOrAdd(categoryName, CreateLoggerImplementation);
    }

    public void Dispose()
    {
        _loggers.Clear();
    }

    private FileLogger CreateLoggerImplementation(string name)
    {
        return new FileLogger(name, _filter, _filePath);
    }
}

在上面的例子中，我们创建了一个名为FileLoggerProvider的日志提供程序，它负责创建FileLogger实例，并将其提供给ILoggerFactory。你只需要将FileLoggerProvider注入到DI容器中，然后就可以在代码中使用它了。

6.2 记录日志到数据库

如果你希望将日志记录到数据库中，你可以在自定义日志组件中实现相应的逻辑：

public class DbLogger : ILogger
{
    private readonly string _categoryName;
    private readonly Func<string, LogLevel, bool> _filter;
    private readonly string _connectionString;

    public DbLogger(string categoryName, Func<string, LogLevel, bool> filter, string connectionString)
    {
        _categoryName = categoryName;
        _filter = filter;
        _connectionString = connectionString;
    }

    public IDisposable BeginScope<TState>(TState state)
    {
        return NoopDisposable.Instance;
    }


    public bool IsEnabled(LogLevel logLevel)
    {
        return logLevel != LogLevel.None && _filter(_categoryName, logLevel);
    }

    public void Log<TState>(LogLevel logLevel, EventId eventId, TState state,
        Exception exception, Func<TState, Exception, string> formatter)
    {
        if (!IsEnabled(logLevel))
        {
            return;
        }

        using (var conn = new SqlConnection(_connectionString))
        {
            conn.Open();
            var cmd = new SqlCommand("INSERT INTO Log([Timestamp], LogLevel, Message, Exception) VALUES(@Timestamp, @LogLevel, @Message, @Exception)", conn);
            cmd.Parameters.AddWithValue("@Timestamp", DateTime.Now);
            cmd.Parameters.AddWithValue("@LogLevel", logLevel.ToString());
            cmd.Parameters.AddWithValue("@Message", formatter(state, exception));
            cmd.Parameters.AddWithValue("@Exception", (object)exception ?? DBNull.Value);
            cmd.ExecuteNonQuery();
        }
    }

    private class NoopDisposable : IDisposable
    {
        public static NoopDisposable Instance = new NoopDisposable();

        public void Dispose()
        {
        }
    }
}

在上面的例子中，我们创建了一个名为DbLogger的日志组件，它将日志记录到指定的数据库中。在Log()方法中，我们使用了SqlConnection和SqlCommand类将日志信息写入到数据库中。

为了使用自定义的数据库日志组件，你需要创建一个相应的ILoggerProvider实现：

public class DbLoggerProvider : ILoggerProvider
{
    private readonly Func<string, LogLevel, bool> _filter;
    private readonly string _connectionString;
    private readonly ConcurrentDictionary<string, DbLogger> _loggers = new ConcurrentDictionary<string, DbLogger>();

    public DbLoggerProvider(string connectionString)
    {
        _connectionString = connectionString;
    }

    public DbLoggerProvider(Func<string, LogLevel, bool> filter, string connectionString)
    {
        _filter = filter;
        _connectionString = connectionString;
    }

    public ILogger CreateLogger(string categoryName)
    {
        return _loggers.GetOrAdd(categoryName, CreateLoggerImplementation);
    }

    public void Dispose()
    {
        _loggers.Clear();
    }

    private DbLogger CreateLoggerImplementation(string name)
    {
        return new DbLogger(name, _filter, _connectionString);
    }
}

在上面的例子中，我们创建了一个名为DbLoggerProvider的日志提供程序，它负责创建DbLogger实例，并将其提供给ILoggerFactory。你只需要将DbLoggerProvider注入到DI容器中，然后就可以在代码中使用它了。

7. 结论

本文介绍了如何使用自定义日志组件在.Net Core应用程序中记录日志信息。我们创建了一个名为MyLogger的日志组件，并将其注册到DI容器中，然后在代码中使用它来记录日志信息。我们还提供了两个简单的示例，以便更好地理解如何编写自定义日志组件。希望这篇文章能够帮助你更好地理解.Net Core中的日志记录功能。

阅读剩余 86%

本站文章如无特殊说明，均为本站原创，如若转载，请注明出处：.Net Core日志记录之自定义日志组件 - Python技术站