Ich benutze Ninjec, Ninject.Web.MVC und Ninject.Web.Common

Wenn ich meine MVC-Anwendung starte, erhalte ich folgenden Bindungsfehler:

Was mache ich falsch an meiner Bindung?

Fehler beim Aktivieren von DbConnection

Es sind keine passenden Bindungen verfügbar, und der Typ ist nicht selbstbindbar.

Aktivierungspfad:

4) Einfügen der Abhängigkeit DbConnection in den Parameter existingConnection des Konstruktors vom Typ DbContext

3) Einfügen der Abhängigkeit DbContext in den Parameter dbContext des Konstruktors vom Typ GenericRepository {User}

2) Einfügen der Abhängigkeit IGenericRepository {User} in das Parameter-Repo des Konstruktors vom Typ HomeController

1) Anfrage für HomeController

Vorschläge:

1) Stellen Sie sicher, dass Sie eine Bindung für DbConnection definiert haben.

2) Wenn die Bindung in einem Modul definiert wurde, stellen Sie sicher, dass das Modul in den Kernel geladen wurde.

3) Stellen Sie sicher, dass Sie nicht versehentlich mehr als einen Kernel erstellt haben.

4) Wenn Sie Konstruktorargumente verwenden, stellen Sie sicher, dass der Parametername mit dem Parameternamen des Konstruktors übereinstimmt.

5) Wenn Sie das automatische Laden von Modulen verwenden, stellen Sie sicher, dass der Suchpfad und die Filter korrekt sind.

public interface IGenericRepository<T> where T : class
{
}

public class GenericRepository<T> : IGenericRepository<T> where T : class
{
        public GenericRepository(TLPContext dbContext)
        {
            DbContext = dbContext;
        }

        protected TLPContext DbContext { get; private set; }
}

[assembly: WebActivator.PreApplicationStartMethod(typeof(TLP.App_Start.NinjectWebCommon), "Start")]
[assembly: WebActivator.ApplicationShutdownMethodAttribute(typeof(TLP.App_Start.NinjectWebCommon), "Stop")]

namespace TLP.App_Start
{
    using Microsoft.Web.Infrastructure.DynamicModuleHelper;
    using Ninject;
    using Ninject.Web.Common;
    using System;
    using System.Web;
    using TLP.DataAccess;
    using TLP.DataAccess.Contract;
    using TLP.DataAccess.Implementation;

    public static class NinjectWebCommon
    {
        private static readonly Bootstrapper bootstrapper = new Bootstrapper();
        public static void Start()
        {
            DynamicModuleUtility.RegisterModule(typeof(OnePerRequestHttpModule));
            DynamicModuleUtility.RegisterModule(typeof(NinjectHttpModule));
            bootstrapper.Initialize(CreateKernel);
        }

        public static void Stop()
        {
            bootstrapper.ShutDown();
        }

        private static IKernel CreateKernel()
        {
            var kernel = new StandardKernel();
            kernel.Bind<Func<IKernel>>().ToMethod(ctx => () => new Bootstrapper().Kernel);
            kernel.Bind<IHttpModule>().To<HttpApplicationInitializationHttpModule>();
            kernel.Bind<TLPContext>();
            kernel.Bind(typeof(IGenericRepository<>)).To(typeof(GenericRepository<>));
            return kernel;
        }
    }
}


[DbModelBuilderVersion(DbModelBuilderVersion.V5_0)]
    public class TLPContext : DbContext
    {
        public TLPContext()
            : base("DefaultConnection")
        {
            // We do not want implicit uncontrollable lazy loading, instead we use the explicit Load method
            this.Configuration.LazyLoadingEnabled = false;
        }

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();

            // Primary key
            modelBuilder.Entity<User>().HasKey(p => p.UserId);
            modelBuilder.Entity<User>().Property(p => p.FirstName).HasMaxLength(30).IsRequired();
            modelBuilder.Entity<User>().Property(p => p.RegisteredAt).IsRequired();
        }

        public DbSet<User> Users { get; set; }
    }