Master in these Hidden Dependency Injection (DI) Features in .NET Core 🚀

Hello, .NET enthusiasts! 👋 Dependency Injection (DI) is one of the cornerstone features of .NET Core that makes applications modular, testable, and maintainable. You’ve probably used DI to register and resolve services, but did you know there are several lesser-known yet powerful features of DI in .NET Core?

In this blog, we’ll explore some of these hidden gems, from conditional service registration to service provider scopes, and how they can make your DI container even more powerful. Let’s dive in! 🌊

---

1. Conditional Service Registration 🛠️

Have you ever needed to register a service based on some runtime conditions? With .NET Core, you can use IServiceCollection extensions to conditionally register services.

Example: Register a service only if another one hasn’t been registered

if (!services.Any(s => s.ServiceType == typeof(IMyService)))
{
    services.AddSingleton<IMyService, MyService>();
}

This ensures your application doesn’t accidentally overwrite an existing registration.

---

2. Named or Keyed Service Resolution 🎯

While not natively built into .NET Core DI, you can implement named or keyed service resolution by registering services with a factory pattern or a dictionary. This is particularly useful when you have multiple implementations of the same interface.

Example: Resolving a service by name

services.AddSingleton<Dictionary<string, IMyService>>(provider => new()
{
    { "ServiceA", new ServiceA() },
    { "ServiceB", new ServiceB() }
});

public class MyConsumer
{
    private readonly IMyService _service;
    public MyConsumer(Dictionary<string, IMyService> services, string key)
    {
        _service = services[key];
    }
}

This approach allows you to pick the service implementation at runtime based on a string key.

---

3. Service Lifetimes Explained 🕒

While many developers know about transient, scoped, and singleton lifetimes, the nuances of their behavior in specific scenarios are often overlooked.

• Transient: A new instance is created every time it’s requested. Best for lightweight, stateless services.
• Scoped: A single instance is created per scope. This is particularly useful in web applications where a scope is created per request.
• Singleton: A single instance is created and shared across the application’s lifetime.

Fun Fact:

Scoped services behave like singletons when resolved from a singleton. Be cautious about injecting IServiceScopeFactory or scoped services into singletons!

---

4. Service Provider Validation ✅

By default, .NET Core DI throws an exception if it detects missing dependencies during runtime. However, you can proactively validate your DI setup at startup using ServiceProviderOptions.ValidateOnBuild.

Example: Validate service registration on application startup

var serviceProvider = services.BuildServiceProvider(new ServiceProviderOptions
{
    ValidateScopes = true,
    ValidateOnBuild = true
});

This catches misconfigurations early, saving you debugging headaches later. 🧠

---

5. Generic Type Registrations 💡

Sometimes, you need to register services with a generic type. For example, if you’re building a repository pattern, you can register all repositories generically.

Example: Generic repository registration

services.AddTransient(typeof(IRepository<>), typeof(Repository<>));

This allows you to inject IRepository<T> for any type T in your application.

Wrapping Up 🏁

Dependency Injection in .NET Core is more than just registering services—it’s a flexible, powerful tool for creating maintainable applications. By exploring these lesser-known features, you can take your DI game to the next level, making your code more modular, efficient, and fun to work with. 💪

So, what’s your favorite DI trick in .NET Core? Let me know! 👇 And happy coding! 😊