All 15 Dependency Injection questions
More in Dependency Injection
What does GetService<T>() return compared to GetRequiredService<T>() when a service isn't registered, and which should application code generally prefer? What is the 'captive dependency' problem, and how does ASP.NET Core's DI container help catch it automatically? What are keyed services (introduced in .NET 8), and what problem do they solve compared to injecting IEnumerable<T> when you need one specific implementation? How does the DI container's disposal behavior work for IDisposable services registered as Transient, and why can this cause unexpected memory retention? How would you unit test a service or minimal API handler that depends on multiple injected interfaces, without spinning up the full DI container? How do third-party DI containers like Autofac integrate with ASP.NET Core's built-in DI abstractions, and why would a team choose one? How does ValidateOnBuild help catch dependency injection configuration errors immediately at application startup rather than at runtime?
Advertisement
ASP.NET Core › Dependency Injection

How does dependency injection integrate with minimal API endpoint handlers versus controller constructors?

Advanced

Answer

Controllers exclusively use constructor injection, resolving all dependencies once when the controller instance is created per-request. Minimal API endpoint handlers instead inject services directly as delegate parameters, automatically inferred as coming from DI (rather than route/body binding) for registered service types -- letting each individual endpoint declare exactly the specific dependencies it needs without a shared constructor.
// Controller: constructor injection
public class ProductsController(IProductService service) : ControllerBase {
    [HttpGet] public IActionResult GetAll() => Ok(service.GetAll());
}

// Minimal API: parameter injection, inferred automatically
app.MapGet("/products", (IProductService service) => service.GetAll());
Real-world example A minimal API's simple GET endpoint declares only IProductService as a dependency, while a more complex POST endpoint additionally declares ILogger, avoiding the controller pattern's tendency to inject dependencies into a shared constructor not every action uses.

Common follow-ups: Does parameter-based injection have any measurable performance difference from constructor injection?;How does explicit [FromServices] disambiguate a service parameter from a route/body parameter?

Controllers vs Minimal APIs;Configuration & Options Pattern
All 15 Dependency Injection questions