Aucune correspondance, les liaisons sont disponibles, et le type n'est pas auto-bindable dans Ninject

Je suis en utilisant Ninjec, Ninject.Web.MVC et Ninject.Web.Commune

Lorsque je démarre mon application mvc, j'obtiens cette erreur de liaison:

Que dois-je mal dans ma liaison?

Erreur lors de l'activation DbConnection

Pas de correspondance liaisons sont disponibles, et le type n'est pas auto-liables.

Chemin d'Activation:

4) d'Injection de dépendance DbConnection en paramètre
existingConnection de constructeur de type DbContext

3) d'Injection de dépendance DbContext dans le paramètre dbContext de
constructeur de type GenericRepository{Utilisateur}

2) Injection de dépendance IGenericRepository{Utilisateur} en paramètre
pensions de constructeur de type HomeController

1) Demande de HomeController

Suggestions:

1) vérifiez que vous avez défini une liaison pour DbConnection.

2) Si la liaison a été définie dans un module, vérifiez que le module
a été chargé dans le noyau.

3) s'Assurer que vous n'avez pas accidentellement créé plus d'un noyau.

4) Si vous utilisez des arguments du constructeur, s'assurer que le paramètre
le nom correspond à l'constructeurs nom du paramètre.

5) Si vous utilisez le module automatique de chargement, vérifiez le chemin de recherche
et les filtres sont corrects.

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

OriginalL'auteur Elisabeth | 2013-02-12