Microsoft Logger是否支持数据库日志？Worker Services日志实现求助

核心结论 #

.NET官方的Microsoft.Extensions.Logging本身没有内置数据库日志提供器，但可以通过两种方式实现：一是通过桥接Serilog复用其数据库Sink（解决你之前的冲突问题），二是完全自定义日志提供器。

方案一：解决Serilog与Microsoft ILogger的冲突（推荐） #

你之前遇到的冲突是因为直接混用了Serilog和Microsoft的ILogger接口，正确的做法是将Serilog作为Microsoft日志体系的后端，代码中依然使用熟悉的Microsoft.Extensions.Logging.ILogger<T>，避免类型冲突。

步骤1：安装必要包 #

Install-Package Serilog
Install-Package Serilog.Sinks.MsSqlServer
Install-Package Serilog.Extensions.Hosting

步骤2：配置Serilog并集成到Worker Service #

在Program.cs中先配置Serilog，再通过UseSerilog()将其设为Microsoft日志的输出后端：

using Serilog;
using WorkerServiceDemo;

var config = new ConfigurationBuilder()
    .AddJsonFile("appsettings.json")
    .Build();

// 配置Serilog写入数据库
Log.Logger = new LoggerConfiguration()
    .ReadFrom.Configuration(config)
    .WriteTo.MsSqlServer(
        connectionString: config.GetConnectionString("LogDb"),
        tableName: "Logs",
        autoCreateSqlTable: true) // 自动创建日志表
    .CreateLogger();

try
{
    Log.Information("Worker服务启动中");
    var host = Host.CreateDefaultBuilder(args)
        .UseSerilog() // 关键：将Serilog集成到Microsoft日志体系
        .ConfigureServices(services =>
        {
            services.AddHostedService<Worker>();
        })
        .Build();

    await host.RunAsync();
}
catch (Exception ex)
{
    Log.Fatal(ex, "Worker服务意外终止");
}
finally
{
    Log.CloseAndFlush();
}

步骤3：业务代码中正常使用Microsoft ILogger #

Worker.cs中依然注入Microsoft.Extensions.Logging.ILogger<Worker>，完全不需要修改业务代码：

using Microsoft.Extensions.Logging;

namespace WorkerServiceDemo;

public class Worker : BackgroundService
{
    private readonly ILogger<Worker> _logger;

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

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            _logger.LogInformation("Worker运行中：{Time}", DateTimeOffset.Now);
            await Task.Delay(1000, stoppingToken);
        }
    }
}

方案二：完全自定义Microsoft日志提供器 #

如果不想依赖Serilog，可以通过实现ILogger和ILoggerProvider来构建自己的数据库日志逻辑。

步骤1：定义日志实体与数据库上下文 #

// 日志实体，对应数据库表结构
public class LogEntry
{
    public int Id { get; set; }
    public DateTime Timestamp { get; set; }
    public string LogLevel { get; set; }
    public string Message { get; set; }
    public string? Exception { get; set; }
    public string Category { get; set; }
}

// EF Core数据库上下文
public class LogDbContext : DbContext
{
    public LogDbContext(DbContextOptions<LogDbContext> options) : base(options) { }
    public DbSet<LogEntry> Logs { get; set; }
}

步骤2：实现自定义ILogger #

public class DbLogger : ILogger
{
    private readonly string _categoryName;
    private readonly IDbContextFactory<LogDbContext> _dbContextFactory;
    private readonly IOptions<DbLoggerOptions> _options;

    public DbLogger(string categoryName, IDbContextFactory<LogDbContext> dbContextFactory, IOptions<DbLoggerOptions> options)
    {
        _categoryName = categoryName;
        _dbContextFactory = dbContextFactory;
        _options = options;
    }

    public IDisposable BeginScope<TState>(TState state) => NullScope.Instance;

    public bool IsEnabled(LogLevel logLevel) => logLevel >= _options.Value.MinLevel;

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

        using var dbContext = _dbContextFactory.CreateDbContext();
        dbContext.Logs.Add(new LogEntry
        {
            Timestamp = DateTime.UtcNow,
            LogLevel = logLevel.ToString(),
            Message = formatter(state, exception),
            Exception = exception?.ToString(),
            Category = _categoryName
        });
        dbContext.SaveChangesAsync().Wait(); // 注意：生产环境建议用异步队列批量写入，避免阻塞
    }
}

// 日志配置选项
public class DbLoggerOptions
{
    public LogLevel MinLevel { get; set; } = LogLevel.Information;
}

步骤3：实现ILoggerProvider #

[ProviderAlias("Db")]
public class DbLoggerProvider : ILoggerProvider
{
    private readonly IDbContextFactory<LogDbContext> _dbContextFactory;
    private readonly IOptions<DbLoggerOptions> _options;
    private readonly ConcurrentDictionary<string, DbLogger> _loggers = new();

    public DbLoggerProvider(IDbContextFactory<LogDbContext> dbContextFactory, IOptions<DbLoggerOptions> options)
    {
        _dbContextFactory = dbContextFactory;
        _options = options;
    }

    public ILogger CreateLogger(string categoryName)
    {
        return _loggers.GetOrAdd(categoryName, name => new DbLogger(name, _dbContextFactory, _options));
    }

    public void Dispose() => _loggers.Clear();
}

步骤4：注册服务与日志提供器 #

在Program.cs中注册自定义日志组件：

using Microsoft.EntityFrameworkCore;
using WorkerServiceDemo;

var builder = Host.CreateDefaultBuilder(args);

builder.ConfigureServices((context, services) =>
{
    // 注册数据库上下文工厂
    services.AddDbContextFactory<LogDbContext>(options =>
        options.UseSqlServer(context.Configuration.GetConnectionString("LogDb")));

    // 配置日志选项
    services.Configure<DbLoggerOptions>(options =>
        options.MinLevel = LogLevel.Information);

    // 添加自定义日志提供器
    services.AddLogging(logging =>
    {
        logging.AddConsole(); // 保留控制台日志
        logging.AddProvider(new DbLoggerProvider(
            services.BuildServiceProvider().GetRequiredService<IDbContextFactory<LogDbContext>>(),
            services.BuildServiceProvider().GetRequiredService<IOptions<DbLoggerOptions>>()));
    });

    services.AddHostedService<Worker>();
});

var host = builder.Build();
await host.RunAsync();

注意事项 #

1. 自定义方案中，直接同步写入数据库会影响性能，生产环境建议添加异步日志队列（比如用BackgroundService批量处理日志）。
2. 两种方案都需要确保数据库连接字符串配置正确，且数据库有写入权限。

内容的提问来源于stack exchange，提问作者Jonathan Wood