What is the recommended way of using the ILogger in Minimal APIs?

[KennethHoff]

Using Microsoft.Extensions.Logging, you are more-or-less required (For good reason) to use ILogger<T> - and bind that to the context in which you are logging (ILogger<AccountController> for MVC applications etc..), but in Minimal APIs the context is untyped.

Therefore, how do I inject the ILogger into my endpoint?

The following throws a No Service for type 'Microsoft.Extensions.Logging.Logger' has been registered. exception:

app.MapGet("/Greeting", (ILogger logger, string name) =>
{
    logger.LogInformation("Does this work?");
    return $"hello {name}";
});

What I have to do is something akin to this:

//							    vvv What is T here?
app.MapGet("/Greeting", (ILogger<T> logger, string name) =>
{
    logger.LogInformation("Does this work?");
    return $"hello {name}";
});

I can only assume there is some other way to do this, but my Google-Fu is failing me today.

I understand that ILoggerProvider exists, but that feels wrong, but is that the "go-to" way of doing this?

[martincostello]

One way of achieving this is to use the app.Logger property captured into the closure of your handler method. In this case the logger source will just be the name of your app.

app.MapGet("/greet", () =>
{
    app.Logger.LogDebug("Returning greeting");
    return "Hello";
});

This is simple, but has the disadvantage of capturing state via the closure, but also means all of your logging has the same source name.

You could also manually register ILogger yourself and give it a custom name at the time of construction:

builder.Services.AddTransient<ILogger>(p =>
{
    var loggerFactory = p.GetRequiredService<ILoggerFactory>();
    // You could also use the HttpContext to make the name dynamic for example
    return loggerFactory.CreateLogger("my logger");
});

If you want to use ILogger<T> just like you're used to with MVC controllers based on a type, then another option is to refactor to wrap your logic in classes registered in DI and then have "minimal" handler methods, similar to this:

builder.Services.AddSingleton<MyService>();

var app = builder.Build();

app.MapGet("/stuff", async (MyService service) =>
    await service.GetStuff());

class MyService
{
    private _logger;

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

    public Task<string> GetStuff()
    {
        _logger.LogDebug("Getting stuff");
        return Task.FromResult("Hello");
    }
}

[grrttedwards]

Can you show a more complex example than a parameterless GET using an instance method? If the request contains a body, or a parameter (query or path), do you have to wire the request handler signature and pass it through to the inner service? i.e.

app.MapPost("/stuff", async ([FromBody] SomeRequestBody body, MyService service) =>
    await service.DoStuff(body));
...
class MyService
{
    public Task<string> DoStuff(SomeRequestBody body)

I considered the following, but the typing doesn't make sense

app.MapPost("/stuff", (MyService service) => service.DoStuff);
...
class MyService
{
    public Task<string> DoStuff([FromBody] SomeRequestBody body)

and the documentation for an instance method route handler is untenable...

[martincostello]

It's not much different to the get example if you're using DI:

using Microsoft.AspNetCore.Mvc;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddSingleton<MyService>();

var app = builder.Build();

app.MapPost("/stuff", async ([FromBody] Person body, MyService service) =>
    await service.PostStuff(body));

app.Run();

class MyService
{
    private ILogger _logger;

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

    public Task<string> PostStuff(Person body)
    {
        _logger.LogDebug("Request from {Name}", body.Name);
        return Task.FromResult($"Hello {body.Name}");
    }
}

record Person(string Name);

If you manually constructed the service, then it would be something like this:

using Microsoft.AspNetCore.Mvc;

var builder = WebApplication.CreateBuilder(args);

var app = builder.Build();

var service = new MyService(app.Logger);

app.MapPost("/stuff", service.PostStuff);

app.Run();

class MyService
{
    private ILogger _logger;

    public MyService(ILogger logger)
    {
        _logger = logger;
    }

    public Task<string> PostStuff([FromBody] Person body)
    {
        _logger.LogDebug("Request from {Name}", body.Name);
        return Task.FromResult($"Hello {body.Name}");
    }
}

record Person(string Name);

[gfoidl]

You can also use ILoggerFactory and then create instances via ILogger logger = loggerFactory.CreateLogger("...");.

For larger projects that use minimal APIs I use a CQRS based approach, endpoint just delegates to a handler and in that handler a typed logger can be injected via DI -- similar to the last approach shown in #49882 (comment)