Używam Ninjec, Ninject.Web.MVC i Ninject.Web.Common

Po uruchomieniu aplikacji mvc otrzymuję ten błąd wiązania:

Co się mylę w mojej oprawie?

Błąd aktywacji DbConnection

Brak dostępnych pasujących powiązań, a typ nie jest samowiążący.

Ścieżka aktywacji:

4) Wstrzyknięcie zależności DbConnection do istniejącego parametruPołączenie konstruktora typu DbContext

3) Wstrzyknięcie zależności DbContext do parametru dbContext konstruktora typu GenericRepository {User}

2) Wstrzyknięcie zależności IGenericRepository {User} do parametru repo konstruktora typu HomeController

1) Wniosek o kontroler HomeController

Propozycje:

1) Upewnij się, że zdefiniowałeś powiązanie dla DbConnection.

2) Jeśli powiązanie zostało zdefiniowane w module, upewnij się, że moduł został załadowany do jądra.

3) Upewnij się, że nie przypadkowo utworzyłeś więcej niż jedno jądro.

4) Jeśli używasz argumentów konstruktora, upewnij się, że nazwa parametru jest zgodna z nazwą parametru konstruktora.

5) Jeśli używasz automatycznego ładowania modułów, upewnij się, że ścieżka wyszukiwania i filtry są poprawne.

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; }
    }