Konfigurieren von Ninject mit Asp.Net MVC & Web Api

Ich habe einige Listen geschrieben, um Ninject mit MVC und Web Api zu konfigurieren. Fügen Sie einfach die Datei (en) hinzu:

• https://Gist.github.com/odytrice/5821087 (für MVC)
• https://Gist.github.com/odytrice/584201 (für WebApi)

Um Bindungen für konkrete Typen hinzuzufügen, fügen Sie diese einfach in die Load() -Methode des MainModule ein. Sie können so viele Module erstellen, wie Sie möchten, um die Bindungen zu organisieren. Sie müssen sie jedoch auch dem Array hinzufügen, das in der Eigenschaft Modules zurückgegeben wird.

Fügen Sie dann der Application_Start() -Methode hinzu

• NinjectContainer.RegisterModules(NinjectModules.Modules) (für MVC)
• NinjectHttpContainer.RegisterModules(NinjectHttpModules.Modules) (für WebApi)

Beachten Sie, dass Sie für die MVC- und die WebApi-Registrierung dasselbe NinjectModules.Modules Verwenden können. Ich habe es nur aus Gründen der Klarheit getrennt

[~ # ~] Update [~ # ~] : Denken Sie daran, NinjectWebCommon.cs aus Ihrem Projekt zu entfernen, wenn ein neuer Kernel zur Laufzeit geladen und gebootet wird ist leider nur für mvc.

[~ # ~] Update [~ # ~] : Sie können auch verwenden

• NinjectContainer.RegisterAssembly() (für MVC)
• NinjectHttpContainer.RegisterAssembly() (für WebApi)

Dadurch wird Ihre aktuelle Baugruppe nach allen Modulen durchsucht. Auf diese Weise können Sie Ihre Module an einer beliebigen Stelle in Ihrem Projekt platzieren und es wird registriert

Mit MVC 5 und Web API 2.2 habe ich dieses Problem behoben, indem ich sichergestellt habe, dass die folgenden NuGet-Pakete enthalten sind:

• Ninject.MVC5
• Ninject.Web.WebApi.WebHost für die Web-API

Dadurch wurden andere Ninject-Abhängigkeiten installiert und ich konnte RegisterServices bis NinjectWebCommon.cs.

Hier ist die einfache Lösung, die für mich gut funktioniert:

1. Erstellen Sie in Visual Studio ein neues Webanwendungsprojekt mit dem Namen DemoApp und stellen Sie sicher, dass Sie Leere Vorlage mit MVC- und Web-API-Referenzen ausgewählt haben:

2. Führen Sie in der Package Manager-Konsole nacheinander Folgendes aus:

   Installationspaket Ninject

   Installationspaket Ninject.MVC5

3. Fügen Sie NinjectDependencyResolver.cs zum IoC-Ordner hinzu:

   using Ninject;
   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Web;
   using System.Web.Http.Dependencies;
   
   namespace DemoApp.IoC
   {
       public class NinjectDependencyResolver : IDependencyResolver, System.Web.Mvc.IDependencyResolver
       {
           private readonly IKernel kernel;
   
           public NinjectDependencyResolver(IKernel kernel)
           {
               this.kernel = kernel;
           }
   
           public IDependencyScope BeginScope()
           {
               return this;
           }
   
           public object GetService(Type serviceType)
           {
               return kernel.TryGet(serviceType);
           }
   
           public IEnumerable<object> GetServices(Type serviceType)
           {
               return kernel.GetAll(serviceType);
           }
   
           public void Dispose() { } //it is not necessary to implement any dispose logic here
       }
   }
   

4. Nehmen Sie die folgenden Änderungen in App_Start/NinjectWebCommon.cs vor:

   • Fügen Sie diese Zeilen in die CreateKernel-Methode ein:

     NinjectDependencyResolver ninjectResolver = new NinjectDependencyResolver (Kernel); DependencyResolver.SetResolver (ninjectResolver); // MVC GlobalConfiguration.Configuration.DependencyResolver = ninjectResolver; // Web API

   • Fügen Sie Ihre Bindungen in der RegisterServices-Methode wie folgt hinzu:

     kernel.Bind <IHelloService> (). To <HelloService> ();

Jetzt sollte NinjectWebCommon.cs so aussehen:

[Assembly: WebActivatorEx.PreApplicationStartMethod(typeof(DemoApp.App_Start.NinjectWebCommon), "Start")]
[Assembly: WebActivatorEx.ApplicationShutdownMethodAttribute(typeof(DemoApp.App_Start.NinjectWebCommon), "Stop")]

namespace DemoApp.App_Start
{
    using System;
    using System.Web;

    using Microsoft.Web.Infrastructure.DynamicModuleHelper;

    using Ninject;
    using Ninject.Web.Common;
    using DemoApp.IoC;
    using System.Web.Mvc;
    using System.Web.Http;
    using DemoApp.Config;

    public static class NinjectWebCommon 
    {
        private static readonly Bootstrapper bootstrapper = new Bootstrapper();

        /// <summary>
        /// Starts the application
        /// </summary>
        public static void Start() 
        {
            DynamicModuleUtility.RegisterModule(typeof(OnePerRequestHttpModule));
            DynamicModuleUtility.RegisterModule(typeof(NinjectHttpModule));
            bootstrapper.Initialize(CreateKernel);
        }

        /// <summary>
        /// Stops the application.
        /// </summary>
        public static void Stop()
        {
            bootstrapper.ShutDown();
        }

        /// <summary>
        /// Creates the kernel that will manage your application.
        /// </summary>
        /// <returns>The created kernel.</returns>
        private static IKernel CreateKernel()
        {
            var kernel = new StandardKernel();
            try
            {
                kernel.Bind<Func<IKernel>>().ToMethod(ctx => () => new Bootstrapper().Kernel);
                kernel.Bind<IHttpModule>().To<HttpApplicationInitializationHttpModule>();

                RegisterServices(kernel);

                NinjectDependencyResolver ninjectResolver = new NinjectDependencyResolver(kernel);
                DependencyResolver.SetResolver(ninjectResolver); //MVC
                GlobalConfiguration.Configuration.DependencyResolver = ninjectResolver; //Web API

                return kernel;
            }
            catch
            {
                kernel.Dispose();
                throw;
            }
        }

        /// <summary>
        /// Load your modules or register your services here!
        /// </summary>
        /// <param name="kernel">The kernel.</param>
        private static void RegisterServices(IKernel kernel)
        {
            kernel.Bind<IHelloService>().To<HelloService>();
        }        
    }
}

5. Um das Beispiel zu vervollständigen, fügen Sie einige Mvc- und Api-Controller und Code für IHelloService, HelloService hinzu:

HomeController.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using DemoApp.Config;
namespace DemoApp.Controllers
{
    public class HomeController : Controller
    {
        private IHelloService helloService;

        public HomeController(IHelloService helloService)
        {
            this.helloService = helloService;
        }

        // GET: /Home/
        public string Index()
        {
            return "home/index: " + helloService.GetMessage();
        }
    }
}

UserController.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Http;
using DemoApp.Config;
namespace DemoApp.Controllers
{
    public class UserController : ApiController
    {
        private IHelloService helloService;

        public UserController(IHelloService helloService)
        {
            this.helloService = helloService;
        }

        [HttpGet]
        public string Data()
        {
            return "api/user/data: " + helloService.GetMessage();
        }
    }
}

IHelloService.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
namespace DemoApp.Config
{
    public interface IHelloService
    {
       string GetMessage();
    }
}

HelloService.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
namespace DemoApp.Config
{
    public class HelloService : IHelloService
    {
        public string GetMessage()
        {
            return "Hi";
        }
    }
}

6. Die endgültige Struktur sollte wie folgt aussehen:

   Führen Sie nun einige Tests im Browser durch. Für mich war es:

   http: // localhost: 51156/home/index

   http: // localhost: 51156/api/user/data

Und das ist es.

Ich denke, das Problem ist, dass Sie keine ControllerFactory registrieren, die Ninject verwendet, um die Controller zu erstellen (und ihre Abhängigkeiten aufzulösen). Haben Sie bereits versucht, Ihre eigene ControllerFactory zu implementieren? Siehe auch hier http://bubblogging.wordpress.com/2012/06/04/mvc-controller-factory-ninject/ .

Hierfür gibt es eine elegantere Lösung von Nenad - ich habe 3 zusätzliche Stunden gebraucht, weil ich zuerst versucht habe, die Lösungen zu implementieren, die mit der vorhandenen Infrastruktur in Konflikt stehen. Es ist als Antwort auf eine andere Stapelüberlauf-Frage . Ich kopiere diese Antwort hier, nur für den Fall, dass es anderen hilft, meine verlorene Zeit zu sparen.

Es gibt eine Möglichkeit, denselben Container für MVC und die ASP.NET-Web-API freizugeben. Sie müssen nur beide Schnittstellen implementieren.

public class NinjectDependencyResolver : NinjectDependencyScope, IDependencyResolver, System.Web.Mvc.IDependencyResolver
   {
       private readonly IKernel kernel;

       public NinjectDependencyResolver(IKernel kernel)
           : base(kernel)
       {
           this.kernel = kernel;
       }

       public IDependencyScope BeginScope()
       {
           return new NinjectDependencyScope(this.kernel.BeginBlock());
       }
   }

In diesem Artikel finden Sie eine Lösung: Einfache Methode zum Freigeben von Abhängigkeitsauflösern zwischen MVC und Web-API