by Last Updated on June 10, 2026 by Aram
Newsletter Sponsor
React and React Native: Build cross-platform JavaScript and TypeScript apps for web and mobile, the 6th edition.
This is a comprehensive guide for building modern web and mobile applications with confidence. Covering React, React Native, TypeScript, testing, performance optimization, and AI-assisted development, it combines practical examples with real-world best practices to help developers create scalable, production-ready applications.
👉 Get the book from Amazon
Dependency Injection (DI) is one of the most important features in ASP.NET Core. Unlike older frameworks where DI often required third-party libraries and additional configuration, ASP.NET Core includes a built-in dependency injection container as a first-class citizen.
DI helps developers create loosely coupled, testable, and maintainable applications. It manages object creation, handles dependency lifecycles, and makes applications easier to extend as they grow.
While the framework makes dependency injection easy to use, using it incorrectly can lead to memory issues, runtime exceptions, hidden dependencies, and poor application design.
As a first-class citizen, Dependency Injection is built natively inside ASP .NET Core
Whether you’re building APIs, web applications, microservices, or enterprise systems, these 12 rules will help you get the most out of dependency injection in ASP.NET Core.
1. Use Transient for Stateless and Short-Lived Services
Transient services are created every time they are requested from the dependency injection container.
They are ideal for lightweight services that do not maintain any internal state between operations.
Common examples include:
• Data mappers
• Validators
• Utility services
• Helper classes
• Formatting services
Example:
builder.Services.AddTransient();
A new instance of EmailFormatter will be created every time it is injected.
Use transient services when object creation is inexpensive and no state needs to be shared.
2. Use Scoped for Per-Request Services
Scoped services are created once per HTTP request and shared throughout that request.
This is the most common lifetime used in ASP.NET Core applications.
A perfect example is Entity Framework Core’s DbContext.
builder.Services.AddScoped();
Every component participating in the same request receives the same DbContext instance.
Benefits include:
• Consistent data tracking within a request
• Better transaction management
• Reduced resource consumption
If a service represents work performed during a single request, scoped is usually the right choice.
3. Use Singleton for Shared Application-Wide Services
Singleton services are created only once during the application’s lifetime.
Every consumer receives the same instance.
Examples include:
• Configuration providers
• Caching services
• Logging infrastructure
• Feature flag providers
builder.Services.AddSingleton();
Singletons should be thread-safe because multiple requests may access them simultaneously.
Avoid storing request-specific data inside singleton services.
4. Inject Interfaces Instead of Concrete Implementations
Depend on abstractions, not implementations.
Instead of injecting concrete classes directly:
public class OrderService
{
public OrderService(PaymentService paymentService)
{
}
}
Prefer:
public class OrderService
{
public OrderService(IPaymentService paymentService)
{
}
}
Benefits include:
• Easier unit testing
• Better maintainability
• Flexible implementations
• Improved adherence to SOLID principles
Interfaces reduce coupling and make your codebase easier to evolve.
5. Keep Dependencies Minimal
A constructor with ten dependencies is usually a warning sign.
Example:
public OrderService(
ILogger logger,
IEmailService emailService,
ICacheService cacheService,
IRepository repository,
IMapper mapper,
IConfiguration configuration,
...)
Large dependency lists often indicate that a class has too many responsibilities.
Ask yourself:
Can this service be split into smaller services?
Following the Single Responsibility Principle often results in cleaner dependency graphs and easier maintenance.
6. Avoid Injecting Transient Services into Singletons
This lifetime mismatch can create unexpected behavior.
Consider:
builder.Services.AddTransient(); builder.Services.AddSingleton ();
If ReportGenerator depends on IUserService, the transient service effectively behaves like a singleton because it gets created only once when the singleton is constructed.
This can introduce bugs and lifecycle inconsistencies.
Always review lifetime compatibility when designing your services.
7. Use IServiceScopeFactory When a Singleton Needs a Scoped Service
Sometimes a singleton legitimately needs access to a scoped service.
A common example is a background service that requires database access.
Instead of injecting the scoped service directly, create a scope:
public class BackgroundWorker
{
private readonly IServiceScopeFactory _scopeFactory;
public BackgroundWorker(IServiceScopeFactory scopeFactory)
{
_scopeFactory = scopeFactory;
}
public void Execute()
{
using var scope = _scopeFactory.CreateScope();
var dbContext =
scope.ServiceProvider.GetRequiredService();
// Use DbContext safely
}
}
This ensures the scoped service is created and disposed correctly.
8. Organize Registrations Using Extension Methods
As applications grow, Program.cs can quickly become difficult to manage.
Instead of registering everything in one file:
builder.Services.AddScoped(); builder.Services.AddScoped (); builder.Services.AddScoped ();
Move registrations into extension methods:
builder.Services.AddApplicationServices(); builder.Services.AddInfrastructureServices();
Benefits include:
• Cleaner Program.cs
• Better project organization
• Easier maintenance
• Improved readability
This approach becomes especially valuable in large enterprise applications.
9. Validate Dependency Injection During Startup
Dependency injection errors often remain hidden until a specific endpoint or feature is executed.
Enable validation during development:
builder.Host.UseDefaultServiceProvider(options =>
{
options.ValidateScopes = true;
options.ValidateOnBuild = true;
});
Benefits include:
• Early detection of configuration errors
• Faster debugging
• Safer deployments
Finding DI problems during startup is far better than discovering them in production.
10. Avoid GetService() and the Service Locator Pattern
The service locator pattern hides dependencies and makes code harder to understand.
Avoid:
var service = serviceProvider.GetService();
Prefer constructor injection:
public NotificationService(IEmailService emailService)
{
}
Constructor injection clearly communicates what a class requires to function.
It improves:
• Readability
• Testability
• Maintainability
Hidden dependencies often become technical debt over time.
11. Prevent Circular Dependencies
Circular dependencies occur when services depend on each other directly or indirectly.
Example:
OrderService
-> PaymentService
-> OrderService
ASP.NET Core will throw an exception because it cannot resolve the dependency chain.
Circular dependencies usually indicate a design issue.
Solutions include:
• Extracting shared logic into a separate service
• Introducing domain events
• Refactoring responsibilities
Breaking the cycle often leads to a cleaner architecture.
12. Use IOptions for Configuration Settings
Avoid injecting IConfiguration throughout your application.
Instead, bind configuration sections to strongly typed classes.
Configuration:
{
"EmailSettings": {
"Host": "smtp.example.com",
"Port": 587
}
}
Options class:
public class EmailSettings
{
public string Host { get; set; }
public int Port { get; set; }
}
Registration:
builder.Services.Configure( builder.Configuration.GetSection("EmailSettings"));
Injection:
public class EmailService
{
public EmailService(IOptions settings)
{
}
}
Benefits include:
• Strong typing
• Better validation
• Cleaner code
• Improved maintainability
This is the recommended approach for configuration management in modern ASP.NET Core applications.
Final Thoughts
Dependency Injection is much more than a framework feature. It is a foundational design principle that influences the maintainability, scalability, and testability of your entire application.
Choosing the correct service lifetime, keeping dependencies focused, avoiding lifetime mismatches, and following established DI patterns can prevent many of the issues developers encounter as applications grow.
The best ASP.NET Core applications are not the ones with the most services registered. They are the ones where every dependency has a clear purpose, the correct lifetime, and a well-defined responsibility.
Master these 12 dependency injection rules, and you’ll build ASP.NET Core applications that are cleaner, easier to maintain, and ready to scale.
Bonus
Have a melodious learning while enjoying the tunes of Luigi Boccherini’s Minuet
Luigi Boccherini – Minuet – String Quintet
