ASP.NET Core 2中ILogger<T>解析机制及与ILoggerFactory的关联疑问

Great question! This is one of those "hidden" but clever parts of ASP.NET Core's logging system that feels like magic until you peek under the hood. Let me break down the implicit association step by step:

1. The Pre-Registered Open Generic Service #

First off, you don't need to register closed ILogger<T> types because ASP.NET Core's default service setup already registers an open generic ILogger<> service for you. Here's what happens behind the scenes when AddLogging() is called (this happens automatically as part of web host initialization):

• The framework registers ILoggerFactory as a singleton LoggerFactory instance.
• It maps the open generic ILogger<> to the concrete Logger<T> implementation.

This open generic registration tells the DI container: "For any ILogger<SomeType> someone requests, hand them a Logger<SomeType> instance."

2. Logger Relies on ILoggerFactory #

The Logger<T> class's constructor depends directly on ILoggerFactory. When the DI container creates a Logger<T> instance, it injects the pre-configured ILoggerFactory (the one you added providers to via AddProvider() or extensions like AddConsole()).

Here's a simplified look at Logger<T>'s core logic:

public class Logger<T> : ILogger<T>
{
    private readonly ILogger _logger;

    public Logger(ILoggerFactory factory)
    {
        _logger = factory.CreateLogger(typeof(T).FullName);
    }

    // All ILogger<T> methods delegate to the underlying _logger instance
}

3. The Link Between DI Resolution and CreateLogger #

When you request an ILogger<T> via DI (e.g., in a controller constructor), here's the full flow:

1. The DI container looks up the open generic registration for ILogger<> and knows to instantiate Logger<T>.
2. It injects the registered ILoggerFactory into Logger<T>'s constructor.
3. Logger<T> calls ILoggerFactory.CreateLogger() with the fully qualified name of T to get a non-generic logger that uses all your registered providers.
4. That underlying logger handles routing logs to your configured providers (console, file, etc.).

4. Where to Find the Actual Implementation #

If you want to dig into the source code:

• The open generic registration lives in LoggingServiceCollectionExtensions.AddLogging().
• The Logger<T> class is part of the Microsoft.Extensions.Logging.Abstractions package, under the Microsoft.Extensions.Logging namespace.
• LoggerFactory.CreateLogger() handles aggregating all registered providers to create a composite logger that routes logs to each configured provider.

In short, the "implicit logic" is just the DI container handling open generic resolution combined with Logger<T> delegating to ILoggerFactory under the hood. You don't see it because the framework wires all this up automatically when you start your app.

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