C# 存储库不能用作方法的泛型类型中的类型参数

我最近遇到了一个以前从未遇到过的关于依赖关系的问题，我查了一下，发现了Ninject。我已经遵循了如何使用它的指南，并且已经达到了一个我不理解的接收和错误的程度。我通常在标题中写下错误，但完整错误如下：

'Error 1类型'MyDBFirstAP.Repository.SQLAPRepository'不能为空 用作泛型类型或方法中的类型参数“TImplementation” 'Ninject.Syntax.IBindingToSyntax.To（）'。有 没有来自的隐式引用转换 “MyDBFirstAP.Repository.SQLAPRepository”到 “MyDBFirstAP.Repository.IAPRepository.”

它发生在这里：

public class NinjectControllerFactory : DefaultControllerFactory{
    private IKernel ninjectKernel;

    public NinjectControllerFactory() {
        ninjectKernel = new StandardKernel();
        AddBindings();
    }
    protected override IController GetControllerInstance(RequestContext requestContext, Type controllerType) {
        return controllerType == null
            ? null
            : (IController)ninjectKernel.Get(controllerType);
    }
    private void AddBindings()
    {
        ninjectKernel.Bind<IAPRepository>().To<SQLAPRepository>(); // On this line
    }
}

以下是请求的SQLRepository代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using MyDBFirstAP.Models;
using MyDBFirstAP.DI;

namespace MyDBFirstAP.Repository {
    public class SQLAPRepository {
        ApplicationDbContext Database = new ApplicationDbContext();

        #region Client
        public IQueryable<Client> GetAllClients() {
            return Database.Clients;
        }    

        public Client GetClientByID(int id) {
            return Database.Clients.FirstOrDefault(c => c.ClientID == id);
        }

        public IQueryable<Client> GetClientByName(string ClientName) {

            return (from clients in Database.Clients
                    where clients.ClientName.Contains(ClientName)
                    select clients);

        }

        public void AddClient(Client client) {
            Database.Clients.Add(client);
            Database.SaveChanges();
        }

        public void UpdateClient(Client client) {
            var tmpClient = Database.Clients.FirstOrDefault(c => c.ClientID == client.ClientID);
            tmpClient.ClientName = client.ClientName;
            tmpClient.ClientAddress = client.ClientAddress;
            Database.SaveChanges();
        }
        public void DeleteClient(Client client) {
            Database.Clients.Remove(client);
            Database.SaveChanges();
        }
#endregion

        #region Supplier
        public IQueryable<Supplier> GetAllSuppliers() {
            return Database.Suppliers;
        }

        public Supplier GetSupplierByID(int id) {
            return Database.Suppliers.FirstOrDefault(s => s.SupplierID == id);
        }

        public IQueryable<Supplier> GetSupplierByName(string SupplierName) {
            return(from suppliers in Database.Suppliers
                       where suppliers.SupplierName.Contains(SupplierName)
                       select suppliers);
        }

        public void AddSupplier(Supplier supplier) {
            Database.Suppliers.Add(supplier);
            Database.SaveChanges();
        }

        public void UpdateSupplier(Supplier supplier) {
            var tmpSupplier = Database.Suppliers.FirstOrDefault(s => s.SupplierID == supplier.SupplierID);
            tmpSupplier.SupplierName = supplier.SupplierName;
            tmpSupplier.SupplierAddress = supplier.SupplierAddress;
            Database.SaveChanges();
        }

        public void DelteSupplier(Supplier supplier) {
            Database.Suppliers.Remove(supplier);
            Database.SaveChanges();
        }
        #endregion

        #region Claim
        public IQueryable<Claim> GetAllClaims() {
            return Database.Claims;
        }

        public Claim GetClaimByID (int id) {
            return Database.Claims.FirstOrDefault(c => c.ClaimID == id);
        }

        public void AddClaim(Claim claim) {
            Database.Claims.Add(claim);
            Database.SaveChanges();
        }
        public void UpdateClaim(Claim claim) {
            var tmpClaim = Database.Claims.FirstOrDefault(c => c.ClaimID == claim.ClaimID);
            tmpClaim.ClaimTotal = claim.ClaimTotal;
            tmpClaim.ClaimWIP = claim.ClaimWIP;
            tmpClaim.FK_ClientID = claim.FK_ClientID;
            tmpClaim.FK_SupplierID = claim.FK_SupplierID;
            Database.SaveChanges();
        }
        public void DeleteClaim(Claim claim) {
            Database.Claims.Remove(claim);
            Database.SaveChanges();
        }
        #endregion
    }
}

使用系统；
使用System.Collections.Generic；
使用System.Linq；
使用System.Web；
使用MyDBFirstAP.Models；
使用MyDBFirstAP.DI；
命名空间MyDBFirstAP.Repository{
公共类SQLAPRepository{
ApplicationDbContext数据库=新的ApplicationDbContext（）；
#区域客户端
公共IQueryable GetAllClients（）{
返回数据库。客户端；
}    
公共客户端GetClientByID（int id）{
返回Database.Clients.FirstOrDefault（c=>c.ClientID==id）；
}
公共IQueryable GetClientByName（字符串ClientName）{
返回（来自数据库中的客户端。客户端）
其中ClientName.Contains（ClientName）
选择客户）；
}
公共无效添加客户端（客户端）{
Database.Clients.Add（客户端）；
SaveChanges（）；
}
public void UpdateClient（客户端）{
var tmpClient=Database.Clients.FirstOrDefault（c=>c.ClientID==client.ClientID）；
tmpClient.ClientName=client.ClientName；
tmpClient.ClientAddress=client.ClientAddress；
SaveChanges（）；
}
公共无效删除客户端（客户端）{
数据库.Clients.Remove（客户端）；
SaveChanges（）；
}
#端区
#区域供应商
公共IQueryable GetAllSuppliers（）{
返回数据库。供应商；
}
公共供应商GetSupplierByID（int id）{
返回Database.Suppliers.FirstOrDefault（s=>s.SupplierID==id）；
}
公共IQueryable GetSupplierByName（字符串SupplierName）{
返回（来自数据库中的供应商。供应商
其中suppliers.SupplierName.Contains（SupplierName）
选择供应商）；
}
公共供应商（供应商）{
数据库.供应商.添加（供应商）；
SaveChanges（）；
}
公共作废更新供应商（供应商）{
var tmpSupplier=Database.Suppliers.FirstOrDefault（s=>s.SupplierID==supplier.SupplierID）；
tmpsuplier.SupplierName=supplier.SupplierName；
tmpsuplier.SupplierAddress=supplier.SupplierAddress；
SaveChanges（）；
}
公共作废DelteSupplier（供应商）{
数据库。供应商。删除（供应商）；
SaveChanges（）；
}
#端区
#区域索赔
公共IQueryable GetAllClaims（）{
返回数据库。索赔；
}
公共声明GetClaimByID（int id）{
返回Database.Claims.FirstOrDefault（c=>c.ClaimID==id）；
}
公共无效索赔（索赔）{
数据库.Claims.Add（Claims）；
SaveChanges（）；
}
公共无效更新索赔（索赔）{
var tmpClaim=Database.Claims.FirstOrDefault（c=>c.ClaimID==claim.ClaimID）；
tmpClaim.ClaimTotal=claim.ClaimTotal；
tmpClaim.ClaimWIP=claim.ClaimWIP；
tmpClaim.FK_ClientID=claim.FK_ClientID；
tmpClaim.FK_SupplierID=claim.FK_SupplierID；
SaveChanges（）；
}
公共索赔（索赔）{
数据库。索赔。删除（索赔）；
SaveChanges（）；
}
#端区
}
}

---

请有人帮我理解这个错误，并帮我修复它。谢谢。

SQLAPRepository必须实现IAPRepository

public class SQLAPRepository : IAPRepository
{
     ....
}

---

正如Radin所说，它必须实现

IAPRepository

接口。当您执行依赖项注入时，您允许在运行时使用接口的任何实现。对于生产代码，要么是显式的配置映射，要么是运行时对可用实现的某种查询

---

在TinyIoC中使用，它不需要显式类型映射。对于其他解决方案，例如，许多实现都有显式类型映射

container.RegisterType（）
你能发布SQLAPRepository代码吗？当然，我现在已经发布了。天哪。这么简单，真不敢相信我没看到。谢谢你还有一件事，你能试着向我解释一下这个错误吗？这个错误意味着运行时不知道如何将你的具体实现转换成接口实现。隐式转换存在于原语之间，如
int
到
double
，这意味着我可以将
int
转换为
double
，而无需编写专门的代码。如果要进行隐式转换，则必须重载运算符，或使类成为基类的后代，或实现相关接口。Bind尝试将SQLAPRepository转换为IAPrepository，但由于SQLAPRepository未实现IAPrepository，因此会出现错误。这是接口多态性，基本上你可以有多个实现IAPreprisory接口的类，并且可以保存在该类型的变量中。谢谢：）我明白了。我真的很感激
public class SQLAPRepository : IAPRepository
{
     ....
}