Enlace de ninject con el método de extensión WhenInjectedInto

Question

Siento que me falta algo obvio. He leído varias preguntas relacionadas aquí y he leído la página de enlaces contextuales actualizada en la wiki de Ninject, pero lamentablemente todavía no funciona.

Estoy tratando de actualizar una aplicación heredada que utilizó un patrón de fábrica para usar Ninject.

Tengo 1 interfaz (IInterface) implementada por 2 clases (ClassB y ClassC). IInterface tiene un método de carga. En el método de carga de ClassB, crea una instancia de ClassC y luego ejecuta su método de carga.

Básicamente, el flujo de programa es ClassA crea ClassB y ejecuta el método de carga. En el método de carga, ClassB crea ClassC que hace algo de trabajo.

Mis enlaces son de configuración como así ...

Bind<IInterface>().To<ClassC>().WhenInjectedInto<ClassB>(); 
Bind<IInterface>().To<ClassB>().WhenInjectedInto<ClassA>(); 

Cuando se ejecuta esta falla en el método de carga de ClassB con este error ...

error al activar IInterface No hay enlaces de juego están disponibles, y la el tipo no es autoblinable.

Si trato de la siguiente ...

Bind<IInterface>().To<ClassC>().WhenInjectedInto<ClassB>(); 
Bind<IInterface>().To<ClassB>(); 

Se hace un bucle sin fin y nunca crea ClassC.

EDITAR He simplificado esto en una unidad de prueba que pasa, pero no me da los resultados que quiero ...

[TestClass] 
public class NinjectTestFixture 
{ 
    private interface IDoSomething 
    { 
     void SaySomething(); 
    } 

    private class ClassA : IDoSomething 
    { 
     public void SaySomething() 
     { 
      Console.WriteLine("Hello from Class A"); 
     } 
    } 

    private class ClassB : IDoSomething 
    { 
     private IKernel _Kernel; 

     public ClassB(IKernel kernel) 
     { 
      _Kernel = kernel; 
     } 

     public void SaySomething() 
     { 
      Console.WriteLine("Hello from Class B"); 

      var x = _Kernel.Get<IDoSomething>(); 

      x.SaySomething(); 
     } 
    } 

    private class ClassC 
    { 
     private IKernel _Kernel; 

     public ClassC(IKernel kernel) 
     { 
      _Kernel = kernel; 
     } 

     public void SaySomething() 
     { 
      Console.WriteLine("Hello from Class C"); 

      var x = _Kernel.Get<IDoSomething>(); 

      x.SaySomething(); 
     } 
    } 

    [TestMethod] 
    public void TestMethod1() 
    { 
     var kernel = new StandardKernel(); 

     kernel.Bind<IDoSomething>().To<ClassA>(); 
     kernel.Bind<IDoSomething>().To<ClassB>().WhenInjectedInto<ClassC>(); 
     kernel.Bind<ClassC>().ToSelf(); 

     var x = kernel.Get<ClassC>(); 

     x.SaySomething(); 
    } 

La salida es: Hola de Clase C Hola de Clase A

Pero quiero: Hola de la Clase C hola de Clase B hola de Clase A

Gracias

Answer 1

Usted son no inyectar en ClassC. Estás pasando el kernel y resolviendo IDoSomething directamente desde él. Existe una gran diferencia.

No pase el kernel como parámetro, ya que no es Dependency Injection, es Service Location (buen artículo sobre la diferencia: Service Locator is an Anti-Pattern).

Cambio ClassC a ser:

private class ClassC  
{   
    private IDoSomething _doSomething;   
    public ClassC(IDoSomething doSomething) 
    {    
     _doSomething = doSomething;   
    }   

    public void SaySomething()   
    {    
     Console.WriteLine("Hello from Class C");    
     //var x = _Kernel.Get<IDoSomething>();    
     _doSomething.SaySomething();   
    }  
} 

También debe realizar los mismos cambios a Clase A ni ClassB (pasa el tipo/interfaz que desea resuelto, no el núcleo).