日志框架 ​

public readonly struct EventId
{
    public int Id { get; }
    public string? Name { get; }
    public EventId(int id, string? name = null)
    public override string ToString()
    ...
}

public enum LogLevel
{
    Trace = 0,
    Debug = 1,
    Information = 2,
    Warning = 3,
    Error = 4,
    Critical = 5,
    None = 6,
}

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

public static class LoggerExtensions
{
    public static IDisposable BeginScope(this ILogger logger, string messageFormat, params object[] args);
    public static void Log(this ILogger logger, LogLevel logLevel, string message, params object[] args);
    public static void Log(this ILogger logger, LogLevel logLevel, EventId eventId, string message, params object[] args);
    public static void Log(this ILogger logger, LogLevel logLevel, Exception exception, string message, params object[] args);
    public static void Log(this ILogger logger, LogLevel logLevel, EventId eventId, Exception exception, string message, params object[] args)
}

public static class LoggerExtensions
(
    public static void LogDebug(this ILogger logger, EventId eventId, Exception exception, string message, params object[] args); 
    public static void LogDebug(this ILogger logger, EventId eventId, string message, params object[] args);
    public static void LogDebug(this ILogger logger, string message, params object[] args);
}

public static class LoggerFactoryExtensions
{
    public static ILogger<T> CreateLogger<T>(this ILoggerFactory factory);
    public static ILogger CreateLogger(this ILoggerFactory factory, Type type);
}

public static class LoggingServiceCollectionExtensions
{
    public static IServiceCollection AddLogging(this IServiceCollection services) => AddLogging(services, builder => { });

    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;
    }
}

class Program
{
    static void Main(string[] args)
    {
        var logger = new ServiceCollection()
            .AddLogging(builder => builder.AddConsole())
            .BuildServiceProvider()
            .GetService<ILogger<Program>>();

        // logger.Log(LogLevel.Information,1,"test log");
        logger.LogInformation("server time is {0}", DateTime.Now);

        Console.ReadKey();
    }
}

static async Task Main(string[] args)
{
    var logger = new ServiceCollection()
        .AddLogging(builder => builder
            .AddConsole(options => options.IncludeScopes = true))
        .BuildServiceProvider()
        .GetService<ILogger<Program>>();
    
    using (logger.BeginScope($"Test Transaction[{Guid.NewGuid()}]"))
    {
        var stopwatch = Stopwatch.StartNew();
        await Task.Delay(500);
        logger.LogInformation("Operation-0 completes at {0}", stopwatch.Elapsed);
        await Task.Delay(300);
        logger.LogWarning("Operation-1 completes at {O}", stopwatch.Elapsed);
    }

    Console.ReadKey();
}

public void Get([FromServices] ILogger<TestController> logger)
{
    logger.LogWarning("log warning");
    logger.LogError("log error");
}

static void Main(string[] args)
{
    var logger = new ServiceCollection()
        .AddLogging(builder => builder
            .SetMinimumLevel(LogLevel.Debug)
            .AddConsole())
        .BuildServiceProvider()
        .GetService<ILogger<Program>>();
    
    logger.LogDebug("server time is {0}", DateTime.Now);

    Console.ReadKey();
}

static void Main(string[] args)
{
    var loggerFactory = new ServiceCollection()
        .AddLogging(builder => builder
            .AddFilter((category, level) => category switch
            {
                "Colin" => level >= LogLevel.Debug,
                "Robin" => level >= LogLevel.Warning,
                _ => level >= LogLevel.Information
            })
            .AddConsole())
        .BuildServiceProvider()
        .GetService<ILoggerFactory>();

    var colinLogger = loggerFactory.CreateLogger("Colin");
    var robinLogger = loggerFactory.CreateLogger("Robin");
    var defaultLogger = loggerFactory.CreateLogger("Default");
    
    colinLogger.LogDebug("Debug log");
    robinLogger.LogWarning("warning log");
    defaultLogger.LogInformation("Information log");

    Console.ReadKey();
}

static void Main(string[] args)
{
    var config = new ConfigurationBuilder()
        .AddJsonFile("appsettings.json")
        .Build();

    var loggerFactory = new ServiceCollection()
        .AddLogging(builder => builder
            .AddConfiguration(config)
            .AddConsole()
            .AddDebug())
        .BuildServiceProvider()
        .GetService<ILoggerFactory>();

    var colinLogger = loggerFactory.CreateLogger("Colin");
    var robinLogger = loggerFactory.CreateLogger("Robin");
    colinLogger.LogWarning("colin warning");
    robinLogger.LogError("robin error");

    Console.ReadKey();
}

private static Action<ILogger, string, string, DateTime, Exception> _log;
private static ILogger _logger;

static void Main(string[] args)
{
    _log = LoggerMessage.Define<string, string, DateTime>(LogLevel.Information, 1,
        "SayHi is invoked.\r\nArguments:name={name}\r\nReturn value:{returnValue}\r\nTime:{time}");
    _logger = new ServiceCollection()
        .AddLogging(builder => builder.AddConsole())
        .BuildServiceProvider()
        .GetService<ILogger<Program>>();

    SayHi("Colin");
    SayHi("Robin");

    Console.ReadKey();
}

static string SayHi(string name)
{
    var returnValue = $"Hi {name}";
    _log(_logger, name, returnValue, DateTime.Now, null);
    return returnValue;
}