fijaciones ninject para una implementación despachador de una interfaz

Question

que tienen una interfaz:

public interface IService 
{ 
    void DoStuff(int parm1, string parm2, Guid gimmeABreakItsAnExampleK); 
} 

me gustaría configurar Ninject (v3) fijaciones para que pueda tener un método shuffle "despachador" llama a múltiples casos de IService, así:

public sealed class DispatcherService : IService 
{ 
    private IEnumerable<IService> _children; 

    public DispatcherService(IEnumerable<IService> children) 
    { 
     this._children = children.ToList(); 
    } 

    public void DoStuff(int parm1, string parm2, Guid gimmeABreakItsAnExampleK) 
    { 
     foreach(var child in this._children) 
     { 
      child.DoStuff(parm1, parm2, gimmeABreakItsAnExampleK); 
     } 
    } 
} 

Sin embargo, mis ataduras, que se parecen a esto, terminan lanzar una excepción en tiempo de ejecución que indica una dependencia cíclica:

this.Bind<IService>().To<DispatcherService>(); 

this.Bind<IService>().To<SomeOtherService>() 
    .WhenInjectedExactlyInto<DispatcherService>(); 
this.Bind<IService>().To<YetAnotherService>() 
    .WhenInjectedExactlyInto<DispatcherService>(); 

¿Esto es posible? Si es así, ¿qué estoy haciendo mal? ¿Pueden los ninja escapar de esta condena a la dependencia cíclica?

Answer 1

Si el despachador es el única IService que se va a tomar una lista de iServices como un parámetro, esto hace el trabajo (he probado):

kernel.Bind<IService>().To<DispatcherService>().When(x => x.IsUnique); 
this.Bind<IService>().To<SomeOtherService>() 
    .WhenInjectedExactlyInto<DispatcherService>(); 
this.Bind<IService>().To<YetAnotherService>() 
    .WhenInjectedExactlyInto<DispatcherService>(); 

La razón de que When cláusula funciona para este caso es que el campo IsUnique de IRequest se establece en true cuando su constructor solicita una instancia única de un servicio. Como su DispatcherService requiere un IEnumerable, el valor es false al activar DispatcherService. Eso evita que la dependencia circular ocurra.

Realmente, cualquier forma correcta de decirle al kernel que no intente inyectar el DispatcherService en sí mismo funcionaría (este es solo un ejemplo potencialmente útil).

Editar: La forma más explícita de simplemente cortocircuitando su dependencia circular parece ser esta:

kernel.Bind<IService>().To<DispatcherService>().When(
    request => request.Target.Member.DeclaringType != typeof (DispatcherService)); 

Answer 2

he de reconocer que no soy tan familiarizados con la API de Ninject, pero creo que esto haría el truco:

kernel.Bind<IService>().To<DispatcherService>(); 

kernel.Bind<IEnumerable<IService>>().ToMethod(() => new IService[] 
{ 
    kernel.Get<SomeOtherService>(), 
    kernel.Get<YetAnotherService>(), 
}); 

Answer 3

Usted podría separar los dos subconjuntos (ya sea despachador o los Receptores) de la forma de hacer una de ellas es una vinculación con nombre, y luego usar el nombre como una forma de alimentar una a la otra (NamedAttribute o en su cableado)

Answer 4

¿Por qué no deshacerse de IService en el DispatcherService y llamar ¿IDispatcherService y hace que los servicios llamados (receptores) implementen IService?