Dependency injection is a key part of modern software development. It helps create flexible, testable, and maintainable code by separating concerns. In ASP.NET Core, services are injected into classes to keep things loosely coupled. But what do you do when you need multiple versions of the same service? That’s where keyed services come into play, offering a smart way to handle this challenge.

Getting Started with Keyed Services

To explore keyed services, start by creating an ASP.NET Core Web API project in Visual Studio 2022. Open the IDE, select “Create new project,” and choose “ASP.NET Core Web API” from the options. During setup, give your project a name and pick a location. For this example, opt for minimal APIs by unchecking “Use controllers” and leave other options like authentication and HTTPS disabled.

This setup provides a clean canvas to implement and test keyed services without the complexity of full MVC controllers. Once the project is ready, you can focus on registering multiple implementations of a single interface and managing them using keys.

Why Use Keyed Services

Traditional dependency injection injects a single implementation for each service interface. But sometimes, you need different versions. For example, you might have different payment processors or data repositories. Using keyed services, you can register multiple implementations and assign each a unique key. This makes it easy to select the right one at runtime.

Keyed services simplify your code by avoiding cumbersome conditional statements or complex factory patterns. They also make testing easier because you can inject specific implementations based on the key. Overall, keyed services help keep your codebase clean, organized, and scalable.

Implementing keyed services involves registering each implementation with a unique identifier, then resolving the correct one when needed. This approach is particularly useful in large applications or when integrating third-party services with similar interfaces.

Implementing Keyed Services in Practice

To set this up, define an interface for your service and create multiple classes implementing it. Register each class with the dependency injection container, associating each with a unique key. During service resolution, you can fetch the specific implementation by its key, ensuring your application uses the right version.

This method allows for flexible configuration. For example, based on user preferences or environment settings, your app can select the appropriate service implementation dynamically. This pattern enhances the adaptability of your application without complicating your code.

Using keyed services in ASP.NET Core leads to more maintainable and testable code. It helps you avoid cluttered conditionals and keeps your service registrations clear and manageable. As a result, your application becomes more robust and easier to extend in the future.

Inspired by

• https://www.infoworld.com/article/4075743/how-to-use-keyed-services-in-asp-net-core.html

Sources

• microsoft.com