Dependency Injection (DI) is a design pattern that simplifies how objects and their dependencies are managed in an application. Instead of classes creating their own dependencies, DI provides those dependencies from the outside. This makes applications cleaner, testable, and maintainable.
⚙️ What is Dependency Injection?
At its core, DI is about inversion of control: your classes don’t create what they need; a container provides them. This container decides:
- How to create objects
- When to reuse objects
- How to dispose of them when no longer needed
📌 Service Lifetimes
When you register services in a DI container, you usually choose a lifetime:
- Transient – A new instance is created every time it’s requested.
- Scoped – One instance is created per request (or unit of work).
- Singleton – A single instance is shared across the entire application lifetime.
🔄 Transient
A new instance is created each time the service is requested. Best for lightweight, stateless services.
// Example in C#
services.AddTransient<IEmailService, EmailService>();
📂 Scoped
A new instance is created once per request, but reused within that request. Useful for services like database contexts.
// Example in C#
services.AddScoped<IDbContext, AppDbContext>();
♾ Singleton
A single instance is created and reused for the entire lifetime of the application. Perfect for loggers, configuration readers, and caching providers.
// Example in C#
services.AddSingleton<ILogger, Logger>();
📊 When to Use Each?
- Transient – For short-lived, stateless operations (e.g., helpers, formatters).
- Scoped – For services tied to a single request or unit of work (e.g., DbContext).
- Singleton – For shared state or expensive-to-create services (e.g., loggers, configuration, caching).
🚀 Conclusion
Dependency Injection ensures better code structure, easier testing, and improved flexibility.
Choosing the right lifetime — Transient, Scoped, or Singleton — helps you balance performance with resource management.
Techy Chalkboard in bits and pieces 