Résolution de service différente Autofac basée sur TypedParameter

Question

Y a-t-il un moyen pour qu'autofac résolve le service ayant une implémentation concrète avec le constructeur qui correspond le plus spécifiquement à un paramètre donné? Par ceci je veux dire correspondre un constructeur pour un type enfant au lieu de faire correspondre le constructeur pour le type de base.

Par exemple, je voudrais faire le test suivant passe

[TestFixture] 
public class AutofacResolvTestFixture 
{ 
    [Test] 
    public void test() 
    { 
     var cb = new ContainerBuilder(); 
     cb.RegisterType<Child1>(); 
     cb.RegisterType<Child2>(); 
     cb.RegisterType<ServiceImpl1>().As<IService>(); 
     cb.RegisterType<ServiceImpl2>().As<IService>(); 
     var container = cb.Build(); 
     var c1=container.Resolve<Child1>(); 
     var c2=container.Resolve<Child2>(); 
     var s1 = container.Resolve<IService>(new TypedParameter(c1.GetType(), c1)); 
     var s2 = container.Resolve<IService>(new TypedParameter(c2.GetType(), c2)); 
     Assert.That(s1, Is.InstanceOf<ServiceImpl1>()); 
     Assert.That(s2, Is.InstanceOf<ServiceImpl2>()); 
     Assert.That(s1.ConstructorParam, Is.SameAs(c1)); 
     Assert.That(s2.ConstructorParam, Is.SameAs(c2)); 
    } 
} 

public class baseClass {} 
public class Child1 : baseClass{} 
public class Child2 : baseClass{} 

public interface IService 
{ 
    baseClass ConstructorParam { get; } 
} 

public class ServiceImpl1 : IService 
{ 
    private baseClass _b; 
    public ServiceImpl1(baseClass b) 
    { 
     _b = b; 
    } 

    public baseClass ConstructorParam 
    { 
     get 
     { 
      return _b; 
     } 
    } 
} 


public class ServiceImpl2 : IService 
{ 
    private baseClass _b; 
    public ServiceImpl2(Child2 b) 
    { 
     _b = b; 
    } 

    public baseClass ConstructorParam 
    { 
     get 
     { 
      return _b; 
     } 
    } 
} 

Mon but est de faire IService, IEditor et être en mesure de résoudre le IEditor pour un type en passant à autofac. Je veux faire ceci pour que je puisse "surcharger" l'éditeur pour un type en héritant simplement d'IEditor et en utilisant le type de constructeur approprié pour lequel IEditor est.

Merci.

Answer 1

Jetez un oeil à ma solution à this question. Vous pouvez peut-être utiliser la même solution, avec un délégué d'usine Func<Type, IService> à la place, et avoir ServiceImplX entré au type enfant correspondant au lieu d'utiliser les enregistrements nommés.