How to register multiple implementations of the same interface in AspNet Core

2025-01-26 (Last Modified: 2025-01-26)

Successful the planet of ASP.Nett Center, dependency injection is a cornerstone of gathering versatile and maintainable purposes. A communal script includes registering aggregate implementations of the aforesaid interface, permitting you to swap implementations primarily based connected configuration oregon another runtime elements. This station volition delve into the intricacies of registering aggregate interface implementations, exploring assorted strategies and champion practices to empower you with the cognition to leverage this almighty characteristic efficaciously.

Knowing the Demand for Aggregate Implementations

Wherefore would you demand aggregate implementations of the aforesaid interface? See a script wherever you person an interface IPaymentGateway. You mightiness person antithetic implementations similar StripePaymentGateway, PayPalPaymentGateway, and OfflinePaymentGateway. Registering aggregate implementations permits you to easy control betwixt these gateways primarily based connected person preferences, situation configurations, oregon equal A/B investigating.

This flexibility is important for contemporary purposes that demand to accommodate to altering concern necessities oregon combine with divers 3rd-organization providers. It promotes modularity, testability, and maintainability, finally starring to cleaner and much strong codification.

Different illustration might beryllium an interface for sending notifications, INotificationService, with implementations similar EmailNotificationService and SMSNotificationService. This permits you to easy control notification strategies oregon equal usage some concurrently.

Utilizing Named Registrations

1 simple attack to registry aggregate implementations is by utilizing named registrations. This method assigns a alone sanction to all implementation, permitting you to resoluteness them particularly once wanted. Present’s however you tin accomplish this:

providers.AddTransient<IPaymentGateway>(sp => fresh StripePaymentGateway()); providers.AddTransient<IPaymentGateway>(sp => fresh PayPalPaymentGateway());

Past, once you demand a circumstantial implementation, you tin petition it by its sanction:

// Constructor injection national MyController(IPaymentGateway stripeGateway, IPaymentGateway payPalGateway) { // ... }

Nevertheless, this attack tin go cumbersome once dealing with galore implementations. It besides requires guide direction of the names, expanding the hazard of errors.

Leveraging Mill Strategies

Mill strategies supply a much elegant manner to grip aggregate registrations. You tin make a mill that determines which implementation to instrument primarily based connected circumstantial standards:

companies.AddTransient<IPaymentGateway>(sp => { var configuration = sp.GetService<IConfiguration>(); var paymentMethod = configuration["PaymentMethod"]; if (paymentMethod == "Stripe") instrument fresh StripePaymentGateway(); other if (paymentMethod == "PayPal") instrument fresh PayPalPaymentGateway(); other instrument fresh OfflinePaymentGateway(); // Default });

This attack centralizes the logic for selecting implementations and makes it simpler to negociate analyzable situations.

Running with Generics and Unfastened Generics

Once dealing with akin implementations that disagree lone by the kind they grip, generics message a almighty resolution. Unfastened generics let you to registry a azygous implementation for each varieties that instrumentality a circumstantial interface:

companies.AddTransient(typeof(IRepository<>), typeof(EfRepository<>));

This registers EfRepository<T> for immoderate T that besides implements different interface, for illustration, IEntity. This attack importantly reduces boilerplate codification and improves maintainability.

Champion Practices and Issues

Intelligibly papers which implementation is utilized for which intent.
See utilizing a devoted configuration conception for managing implementation action.

A fine-structured configuration makes it simpler to control implementations with out modifying codification. This is peculiarly crucial successful environments similar exhibition, wherever codification modifications mightiness beryllium much restrictive.

Troubleshooting Communal Points

Conflicting Registrations: Treble-cheque your registrations to guarantee you’re not by accident overriding implementations.
Incorrect Solution: Confirm that you are resolving the accurate implementation utilizing the due sanction oregon standards.
Life Mismatch: Guarantee that the life of your registered implementations aligns with your exertion’s necessities.

Cautiously managing lifetimes (transient, scoped, singleton) prevents surprising behaviour and assets leaks. Selecting the due life relies upon connected the circumstantial wants of your implementation.

For much successful-extent accusation connected dependency injection successful ASP.Nett Center, cheque retired the authoritative Microsoft documentation.

[Infographic illustrating antithetic registration strategies]

FAQ

Q: What is the champion manner to grip galore implementations of the aforesaid interface?

A: For a ample figure of implementations, see utilizing a operation of mill strategies and configuration to negociate the action procedure effectively. This permits for dynamic solution primarily based connected runtime situations.

Selecting the correct scheme for registering aggregate implementations of the aforesaid interface successful ASP.Nett Center relies upon connected your circumstantial wants. By knowing the strategies mentioned successful this article, you tin make much versatile, maintainable, and scalable functions. Retrieve to see components similar the figure of implementations, the complexity of the action logic, and the general structure of your exertion once making your determination. For additional exploration connected dealing with analyzable dependencies, cheque retired this adjuvant assets: Stack Overflow: ASP.Nett Center Dependency Injection. Besides, see this article connected champion practices: Champion Practices for Dependency Injection successful ASP.Nett Center. Eventually, dive deeper into the taxable with this insightful weblog station: Precocious Dependency Injection Methods. Experimentation with these approaches, and take the 1 that champion fits your task. By mastering these strategies, you tin harness the afloat powerfulness of dependency injection successful your ASP.Nett Center functions.

Question & Answer :
I person providers that are derived from the aforesaid interface.

national interface IService { } national people ServiceA : IService { } national people ServiceB : IService { } national people ServiceC : IService { }

Sometimes, another IoC containers similar Unity let you to registry factual implementations by any Cardinal that distinguishes them.

Successful ASP.Nett Center, however bash I registry these providers and resoluteness them astatine runtime based mostly connected any cardinal?

I don’t seat immoderate Adhd Work strategies that return a cardinal oregon sanction parameter, which would sometimes beryllium utilized to separate the factual implementation.

national void ConfigureServices(IServiceCollection providers) { // However bash I registry providers of the aforesaid interface? } national MyController:Controller { national void DoSomething(drawstring cardinal) { // However bash I resoluteness the work by cardinal? } }

Is the Mill form the lone action present?

Update1
I person gone although the article present that reveals however to usage the mill form to acquire work cases once we person aggregate factual implementations. Nevertheless, it is inactive not a absolute resolution. Once I call the _serviceProvider.GetService() technique, I can’t inject information into the constructor.

For illustration see this:

national people ServiceA : IService { backstage drawstring _efConnectionString; ServiceA(drawstring efconnectionString) { _efConnecttionString = efConnectionString; } } national people ServiceB : IService { backstage drawstring _mongoConnectionString; national ServiceB(drawstring mongoConnectionString) { _mongoConnectionString = mongoConnectionString; } } national people ServiceC : IService { backstage drawstring _someOtherConnectionString national ServiceC(drawstring someOtherConnectionString) { _someOtherConnectionString = someOtherConnectionString; } }

However tin _serviceProvider.GetService() inject the due transportation drawstring? Successful Unity, oregon immoderate another IoC room, we tin bash that astatine kind registration. I tin usage IOption, nevertheless, that volition necessitate maine to inject each settings. I can not inject a peculiar transportation drawstring into the work.

Besides line that I americium making an attempt to debar utilizing another containers (together with Unity) due to the fact that past I person to registry every part other (e.g., Controllers) with the fresh instrumentality arsenic fine.

Besides, utilizing the mill form to make work situations is towards DIP, arsenic it will increase the figure of dependencies a case has particulars present.

Truthful, I deliberation the default DI successful ASP.Nett Center is lacking 2 issues:

The quality to registry situations utilizing a cardinal
The quality to inject static information into constructors throughout registration

I did a elemental workaround utilizing Func once I recovered myself successful this occupation.

Firstly state a shared delegate:

national delegate IService ServiceResolver(drawstring cardinal);

Past successful your Startup.cs, setup the aggregate factual registrations and a guide mapping of these varieties:

companies.AddTransient<ServiceA>(); providers.AddTransient<ServiceB>(); companies.AddTransient<ServiceC>(); providers.AddTransient<ServiceResolver>(serviceProvider => cardinal => { control (cardinal) { lawsuit "A": instrument serviceProvider.GetService<ServiceA>(); lawsuit "B": instrument serviceProvider.GetService<ServiceB>(); lawsuit "C": instrument serviceProvider.GetService<ServiceC>(); default: propulsion fresh KeyNotFoundException(); // oregon possibly instrument null, ahead to you } });

And usage it from immoderate people registered with DI:

national people User { backstage readonly IService _aService; national User(ServiceResolver serviceAccessor) { _aService = serviceAccessor("A"); } national void UseServiceA() { _aService.DoTheThing(); } }

Support successful head that successful this illustration the cardinal for solution is a drawstring, for the interest of simplicity and due to the fact that OP was asking for this lawsuit successful peculiar.

However you may usage immoderate customized solution kind arsenic cardinal, arsenic you bash not normally privation a immense n-lawsuit control rotting your codification. Relies upon connected however your app scales.