asp.net mvc - vista - Cómo decirle a Ninject que se vincule a una implementación, no tiene una referencia a

plantillas para asp.net mvc

Question

Estoy usando NinjectMVC3 en mi proyecto ASP.NET MVC3.

Tengo 3 capas

• Foo.Web
• Foo.Services
• Foo.Data

Foo.Web hace referencia a Foo.Services pero no a Foo.Data. Uno de mis servicios se parece a esto

public class FooService : IFooService
{
    private readonly IFooRepository _fooRepository;

    public FooService(IFooRepository fooRepository)
    {
        _fooRepository = fooRepository;
    }

    // ...
}

NinjectMVC3 ejecuta este método de arranque en el inicio de Foo.Web

private static void RegisterServices(IKernel kernel)
{
    kernel.Bind<IFooService>().To<FooService>();
    kernel.Bind<IFooRepository>().To<FooRepository>();
    // Foo.Web doesn''t know what FooRepository is
}        

¿Cómo puedo inyectar dependencias de FooServices desde Foo.Web?

Answer 1

Para que te apunten en la dirección correcta, te sugiero que eches un vistazo a la arquitectura de la cebolla.

Su premisa básica es que cualquier código puede depender de capas más centrales. En su escenario (y es común para las aplicaciones MVC3 que usan el patrón Repository), su UI debe tener una referencia a la capa de servicios y es aceptable tener una referencia a la capa de datos.

Si estás dispuesto a aceptar eso (es una pastilla difícil de tragar si vienes de una configuración clásica de N niveles, lo sé), entonces tu situación se vuelve mucho más simple.

Con Ninject ahora haces algo de la siguiente manera:

En tu archivo NinjectMVC3.cs tu CreateKernel se convierte

    /// <summary>
    /// Creates the kernel that will manage your application.
    /// </summary>
    /// <returns>The created kernel.</returns>
    private static IKernel CreateKernel()
    {
        var modules = new INinjectModule[]
                          {
                              new ServiceDIModule(),
                              new RepositoryDIModule()
                          };

        var kernel = new StandardKernel(modules);

        //RegisterServices(kernel); <-- Only if you have some custom binding 
        //                              that are UI specific
        return kernel;
    }

Ahora, en la capa de servicios, agregas una referencia a Ninject (simplemente Ninject vía NuGet, no el MVC3 dropin vía NuGet) y agregas lo que llamé arriba del ServiceDIModule que se ve así:

using Ninject.Modules;

namespace MyServiceLayer
{
    public class ServiceDIModule : NinjectModule
    {
        public override void Load()
        {
            //Bind Services
            Bind<IPracticeService>().To<PracticeService>().InRequestScope();
        }
    }
}

y repite el mismo proceso para las inyecciones de Nivel de datos que pueda tener (UnitofWork, DatabaseFactory, IFooRepository, etc.)

namespace MyDataLayer
{
    public class RepositoryDIModule : NinjectModule
    {
        public override void Load()
        {
            //Bind Repos
            Bind<IFooRepository>().To<FooRepository>().InRequestScope();
        }
    }
}

Ahora tiene acceso a todos los enlaces que necesita de manera anticipada. Entonces, tu pregunta para mí realmente se reduce a un cambio en el pensamiento. Si puede aceptar (a regañadientes o no) el concepto de cebolla, su escenario se resuelve limpiamente.

También puede consultar Project Silk y CodeCampServer . Ambos implementan el concepto de "cebolla" hasta cierto punto (Silk con seguridad, estoy buscando la solución en este momento y el proyecto web de UI contiene una referencia al proyecto de datos que contiene todos los Repos)

Déjame saber lo que piensas.