En el pasado, utilicé swiftsuspenders que es un controlador de ActionScript 3 IoC. Básicamente, la primera versión de switfsuspender tenía algo similar al núcleo Ninject que se llamaba inyector.

Si quería crear un inyector de aplicación (con las asignaciones más relevantes que se utilizarán en toda la aplicación), tenía que inyectar el inyector en las clases de la aplicación.

Ahora me pregunto cuál es la práctica de usar kernel.get <> entre varias clases en la aplicación. ¿Debo inyectar el núcleo mismo?

Personalmente prefiero usar kernel.inject, pero si puedo hacer kernel.inject, probablemente pueda inyectar las dependencias manualmente, lo que probablemente sea mejor (beso).

Los casos de prueba son agradables, pero están lejos de los problemas prácticos reales, así que espero que me puedan ayudar a aclarar este punto. Gracias

Edit: Noté que algunas personas hablan sobre "contenedor raíz", parece que es el concepto que estoy buscando. ¿Cómo debo configurar un contenedor raíz y dejar que las otras clases de aplicación lo sepan?

Edit2 Código de muestra (por favor, perdone los errores, es solo por ejemplo):

class SomeClass
{
    public SomeClass()
    {
        Command cmd = new Command();

        cmd.execute();
    }

}

class SomeOtherClass:ISomeOtherClass
{
 public void allright()
 {
    //right
 }
}

class Command
{
   ISomeOtherClass dependency;

   void execute()
   {
    dependency.allright();
   }

}


Program.Main()
{
    IKernel kernel = new StandardKernel();

    kernel.Bind<SomeClass>().ToSelf().InSingletonScope();
    kernel.Bind<ISomeOtherClass>().To<SomeOtherClass>();

    SomeClass sc = kernel.Get<SomeClass>();
}

No probé esto todavía, porque todavía estoy luchando con algunos problemas de inicialización, pero mi pregunta es, ¿cómo puede saber la clase de comando sobre SomeOtherClass? Mi hipótesis actual es inyectar el núcleo en SomeClass y usar el método Inject.