rozwiązać problemów z zależnościami tylko z określonych nazw

Question

mogę automatycznie rejestrować wszystkie typy, które implementują interfejsy z tym stwierdzeniem

IUnityContainer container = new UnityContainer(); 

container.RegisterTypes(
    AllClasses.FromAssembliesInBasePath(), 
    WithMappings.FromMatchingInterface, 
    WithName.Default, 
    WithLifetime.Transient); 
ICustomer result = container.Resolve<ICustomer>(); 

Jak mogę podać nazw dla interfejsów i wdrożeń?

tj .: tylko interfejsy w Framework.RepositoryInterfaces powinny zostać rozwiązane według typów w Framework.RepositoryImplementations.

Answer 1

Można użyć RegistrationConvention:

public class NamespaceRegistrationConvention : RegistrationConvention 
{ 
    private readonly IEnumerable<Type> _typesToResolve; 
    private readonly string _namespacePrefixForInterfaces; 
    private readonly string _namespacePrefixForImplementations; 

    public NamespaceRegistrationConvention(IEnumerable<Type> typesToResolve, string namespacePrefixForInterfaces, string namespacePrefixForImplementations) 
    { 
     _typesToResolve = typesToResolve; 
     _namespacePrefixForInterfaces = namespacePrefixForInterfaces; 
     _namespacePrefixForImplementations = namespacePrefixForImplementations; 
    } 

    public override IEnumerable<Type> GetTypes() 
    { 
     // Added the abstract as well. You can filter only interfaces if you wish. 
     return _typesToResolve.Where(t => 
      ((t.IsInterface || t.IsAbstract) && t.Namespace.StartsWith(_namespacePrefixForInterfaces)) || 
      (!t.IsInterface && !t.IsAbstract && t.Namespace.StartsWith(_namespacePrefixForImplementations))); 
    } 

    public override Func<Type, IEnumerable<Type>> GetFromTypes() 
    { 
     return WithMappings.FromMatchingInterface; 
    } 

    public override Func<Type, string> GetName() 
    { 
     return WithName.Default; 
    } 

    public override Func<Type, LifetimeManager> GetLifetimeManager() 
    { 
     return WithLifetime.Transient; 
    } 

    public override Func<Type, IEnumerable<InjectionMember>> GetInjectionMembers() 
    { 
     return null; 
    } 
} 

i użyć go poprzez:

container.RegisterTypes(new NamespaceRegistrationConvention(AllClasses.FromAssembliesInBasePath(), "Framework.RepositoryInterfaces", "Framework.RepositoryImplementations"); 
ICustomer result = container.Resolve<ICustomer>(); 

Answer 2

rodzaje filtrowania Spróbuj według nazw

IUnityContainer container = new UnityContainer(); 

container.RegisterTypes(
    AllClasses.FromAssembliesInBasePath().Where(
    t => t.Namespace.StartsWith("Framework.RepositoryImplementations") || 
    t.Namespace.StartsWith("Framework.RepositoryInterfaces")), 
    WithMappings.FromMatchingInterface, 
    WithName.Default, 
    WithLifetime.Transient); 

ICustomer result = container.Resolve<ICustomer>();