Castillo de Windsor - ¿Cómo asignar instancia de nombre en la inyección de constructor

Question

tal vez esto es fácil, pero buscando en el internet ya dame un dolor de cabeza

aquí está el problema:

interface IValidator 
{ 
    void Validate(object obj); 
} 

public class ValidatorA : IValidator 
{ 
    public void Validate(object obj) { } 
} 

public class ValidatorB : IValidator 
{ 
    public void Validate(object obj) { } 
} 


interface IClassA { } 
interface IClassB { } 

public class MyBaseClass 
{ 
    protected IValidator validator; 

    public void Validate() 
    { 
     validator.Validate(this); 
    } 
} 

public class ClassA : MyBaseClass, IClassA 
{ 
    //problem: validator should ValidatorA 
    public ClassA(IValidator validator) { } 
} 

public class ClassB : MyBaseClass, IClassB 
{ 
    //problem: validator should ValidatorB 
    public ClassB(IValidator validator) { } 
} 

public class OtherClass 
{ 
    public OtherClass(IClassA a, IClassB b) { } 
} 


//on Main 
var oc = container.Resolve<OtherClass>(); 

Alguna idea?

EDITAR

Me he registrado y ValidatorAValidatorB con Named, ahora el problema de cómo el castillo de Windsor puede inyectar los validador correctamente a la ClassA y ClassB, hay una manera de hacer eso? o hay alguna mejor solucion?

si alguien piensa que el diseño de mi clase es incorrecto, por favor, abro para cualquier consejo. Hasta ahora creo que es correcto. Sí, el validador tiene una configuración específica para una Clase específica. pero hay razones por las que se abstrae:

1. El validador es un objeto complejo, en algún momento debe conectarse a la base de datos, así que DEBO pasar la interfaz en lugar de la implementación al constructor para probar la unidad.
2. No hay manera de usar interfaz diferente para cualquiera de Validador, porque el único método que he utilizado es Validate
3. creo MyBaseClass.Validate() una plantilla común método patrón no es así?

Answer 1

Sin entrar en los detalles de su arquitectura elegida sólo se centra en la configuración del contenedor Windsor:

Si se ha registrado múltiples nombrado aplicación de una interfaz dada (IValidator), puede especificar cuál te desea utilizar al registrarse las clases de consumo (ClassA, ClassB) con el uso de ServiceOverrides:

los siguientes proveedores contenedor de configuración una OtherClass con ClassA ejemplo con una instancia ValidatorA y ClassB con un ValidatorB:

var container = new WindsorContainer(); 

container.Register(Component.For<IClassA>().ImplementedBy<ClassA>() 
    .DependsOn(ServiceOverride.ForKey<IValidator>().Eq("ValidatorA"))); 
container.Register(Component.For<IClassB>().ImplementedBy<ClassB>() 
    .DependsOn(ServiceOverride.ForKey<IValidator>().Eq("ValidatorB"))); 

container.Register(Component.For<IValidator>().ImplementedBy<ValidatorA>() 
    .Named("ValidatorA")); 
container.Register(Component.For<IValidator>().ImplementedBy<ValidatorB>() 
    .Named("ValidatorB")); 

container.Register(Component.For<OtherClass>().ImplementedBy<OtherClass>()); 

var oc = container.Resolve<OtherClass>(); 

Answer 2

Parece que usted está tratando de poner parejas apretadas (ClassA con ValidatorA, ClassB con ValidatorB) como los tipos independientes en un recipiente común. Esto es inutil. Si debe confiar en un acoplamiento ajustado como este, olvide la inyección de dependencia en este aspecto y simplemente haga una referencia de los tipos.

Esto tendría más sentido si pudiera implementar un validador común para todas las clases. Por ejemplo, haga que las clases sean responsables de proporcionar reglas de validación, y deje que Validator haga cumplir las reglas. O tal vez simplemente incluya toda la validación dentro de sus clases, que probablemente sea el escenario más sensato aquí.

MyBaseClass.Validate() parecen inversión de control, pero no como un método de plantilla.