dépendances Resolve seulement de l'espace de noms spécifié

Question

, je peux enregistrer automatiquement tous les types qui mettent en œuvre des interfaces avec cette déclaration

IUnityContainer container = new UnityContainer(); 

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

Comment puis-je spécifier un espace de noms pour les interfaces et les implémentations?

i.e: seules les interfaces de Framework.RepositoryInterfaces doivent être résolues par types dans Framework.RepositoryImplementations.

Answer 1

Vous pouvez utiliser le 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; 
    } 
} 

et de l'utiliser via:

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

Answer 2

types de filtrage Essayez de l'espace de noms

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>();