All 16 Dependency Injection questions
More in Dependency Injection
What does GetService<T>() return compared to GetRequiredService<T>() when a service isn't registered? What is the difference between Singleton, Scoped, and Transient service lifetimes in ASP.NET Core's DI container? How do you register multiple implementations of the same interface, and how do you resolve all of them together? How does the DI container handle constructor injection when a class has multiple constructors? How do you register a service using a factory delegate instead of a simple type mapping, when construction requires custom logic? How do third-party DI containers like Autofac integrate with ASP.NET Core's built-in DI abstractions? How does ASP.NET Core's DI container support injecting a logger via ILogger<T>, and how is the generic type parameter used? What is dependency injection, and why does it make a codebase easier to test and maintain? What is the 'captive dependency' problem, and how does the DI container help catch it? What are keyed services (introduced in .NET 8), and what problem do they solve compared to multiple unnamed registrations?
Advertisement
Back to results for “Dependencies”
.NET › Dependency Injection

What is the difference between constructor injection and service location (using IServiceProvider directly to resolve dependencies)?

Intermediate

Answer

Constructor injection explicitly declares a class's dependencies in its constructor signature, making them visible and enforced at compile time -- the preferred approach since it makes dependencies discoverable and testable. Service location instead has code call IServiceProvider.GetService<T>() imperatively wherever a dependency is needed, hiding the actual dependencies inside method bodies (an anti-pattern generally discouraged, since it obscures a class's true requirements and makes unit testing harder, though occasionally necessary for truly dynamic runtime resolution scenarios).
// Preferred: constructor injection, dependencies explicit
public class OrderService {
    public OrderService(IEmailSender emailSender) { ... }  // clear requirement
}

// Anti-pattern: service location, hidden dependency
public class OrderService {
    public void Process(IServiceProvider provider) {
        var emailSender = provider.GetService<IEmailSender>();  // hidden, hard to test
    }
}
Real-world example A code review rejects a pull request that resolves services via IServiceProvider.GetService<T>() inside a method body, requesting the dependency be moved to the constructor instead so it's visible in the class's public API and easily mockable in tests.

Common follow-ups: When is service location actually the pragmatic right choice (like plugin systems)?;How does this relate to the broader Service Locator anti-pattern debate?

Testing in .NET (xUnit Integration & Unit Testing);Dependency Injection
All 16 Dependency Injection questions