Auflösen benannter Abhängigkeiten mit Dependency Resolver

Question

Ich habe festgestellt, dass, wenn ich meine Abhängigkeiten über benannte Überschreibungen registrieren Dependency Resolver Mühe, Komponenten richtig aufzulösen. Scheint wie die erste Instanz zur Verfügung gestellt wird. Mit ctor injection ist alles in Ordnung.

Beispiel:

Registrierung

RegisterProvider<IAccountProvider, AccountProvider>(); 
RegisterProvider<IAccountProvider, CustomAccountProvider>("customAccountProvider"); 

Auflösung

var instance = DependecyResolver.Current.GetService<IAccountProvider>(); 

Kann nicht customAccountProvider Instanz abzurufen. Es bezieht sich immer auf die erste registrierte Komponente, die benannte Einschränkungen ignoriert.

Answer 1

Wenn Sie mehrere Implementierungen der gleichen Komponente haben, müssen Sie sie benennen oder sie mit Markierungsschnittstelle markieren. Hier ist ein Codebeispiel mit der Benennung der Instanzen:

using System; 
using System.Linq; 
using System.Reflection; 
using Castle.Facilities.TypedFactory; 
using Castle.MicroKernel; 
using Castle.MicroKernel.Registration; 
using Castle.Windsor; 

namespace ResolvingNamedInctances 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      var container = new WindsorContainer(); 
      container.AddFacility<TypedFactoryFacility>(); 

      container.Register(Component.For<ITypedFactoryComponentSelector>().ImplementedBy<AccountProviderTypeSelector>()); 
      container.Register(Component.For<IAccountProviderSelector>().AsFactory(typeof(AccountProviderTypeSelector))); 


      container.Register(Component.For<IAccountProvider>().ImplementedBy<DefaultAccountProvider>().Named("default")); 
      container.Register(Component.For<IAccountProvider>().ImplementedBy<CustomAccountProvider>().Named("custom")); 

      // uncomment this line in MVC app and use DependencyResolver instead of container 
      //DependencyResolver.SetResolver(new WindsorDependencyResolver(container.Kernel)); 

      var accountProviderSelector = container.Resolve<IAccountProviderSelector>(); 

      var defaultAccountProvider = accountProviderSelector.GetAccountProvider(); // default 
      defaultAccountProvider.Provide(); 


      var customAccountProvider = accountProviderSelector.GetAccountProvider("custom"); 
      customAccountProvider.Provide(); 

      Console.ReadLine(); 
     } 
    } 

    public class AccountProviderTypeSelector : ITypedFactoryComponentSelector 
    { 
     public Func<IKernelInternal, IReleasePolicy, object> SelectComponent(MethodInfo method, Type type, object[] arguments) 
     { 

      string providerName = arguments.Length > 0 ? (string)arguments[0] : "default"; 
      return (k, r) => k.GetHandlers(typeof(IAccountProvider)) 
       .Where(
        h => 
        { 

         return h.ComponentModel.Name == providerName; 
        }) 
       .Select(h => (IAccountProvider)k.Resolve(
        h.ComponentModel.Name, 
        typeof(IAccountProvider), 
        new Arguments { }, 
        r)) 
      .FirstOrDefault(); 
     } 
    } 

    public interface IAccountProviderSelector 
    { 
     IAccountProvider GetAccountProvider(); 
     IAccountProvider GetAccountProvider(string nameIdentifier); 
    } 

    public interface IAccountProvider 
    { 
     void Provide(); 
    } 

    public class DefaultAccountProvider : IAccountProvider 
    { 
     public void Provide() 
     { 
      Console.WriteLine("Working in default AccountProvider"); 
     } 
    } 

    public class CustomAccountProvider : IAccountProvider 
    { 
     public void Provide() 
     { 
      Console.WriteLine("Working in standart CustomAccountProvider"); 
     } 
    } 
}