Asp.net mvc 4 Castle windsor电线通用存储，有2种类型

嗨，我正在尝试更改这里的代码示例

在他的示例中，他使用结构图，当我将其转换为windsor时，我可以使用以下命令使其与一个存储库一起工作

        container.Register(Component.For<IUnitOfWorkFactory>().ImplementedBy<EFUnitOfWorkFactory>(),
            Component.For<IUnitOfWork>().ImplementedBy<EFUnitOfWork>(),
            Component.For<Model.Repositories.IPeopleRepository>().ImplementedBy<PeopleRepository>().LifestyleTransient());

container.Register（Component.For（）.ImplementedBy（），
Component.For（）.ImplementedBy（），
Component.For（）.ImplementedBy（）.LifestyleTransient（））；

但我真正想做的是将所有基于irepository的接口映射到它们的实现。 这是IRepository，T是实体，K是主键类型

public interface IRepository<T, K> where T : class
{
}

公共接口i假设，其中T:class
{
}

它的实施非常困难

public abstract class Repository<T> : IRepository<T, int>, IDisposable where T :      DomainEntity<int>
{
}

公共抽象类存储库：IRepository，IDisposable其中T:DomainEntity
{
}

我的控制器将接口ipeoperepository作为构造函数参数

public interface IPeopleRepository : IRepository<Person, int>
{
}

public class PeopleRepository : Repository<Person>, IPeopleRepository
{
}

公共接口IPeopRepository:IRepository
{
}
公共类PeopleRepository:Repository，iOpleRepository
{
}

我想用一个寄存器来注册所有存储库，类似这样的，但它不匹配，我得到了错误服务“spanjaars.ContactManager45.Model.repositories.ipeoperepository”，该服务未注册

container.Register(Component.For(typeof(IRepository<,>))
                             .ImplementedBy(typeof(Repository<>))
                             .LifestylePerWebRequest());

container.Register（Component.For（typeof（IRepository））
.ImplementedBy（类型（存储库））
.LifestylePerWebRequest（））；

---

关于这件事，我遗漏了什么？这是因为我的irepository有两种泛型类型吗？

为了将所有基于irepository的接口映射到它们的实现。应该使用WithService.AllInterfaces（）

此注册将解决您的问题

container.Register(
    Classes.FromThisAssembly()
        .BasedOn(typeof(IRepository<,>))
        .WithService.AllInterfaces()
        .LifestylePerWebRequest());

container.Register(
类。FromThisAssembly（）
.BasedOn（类型（假定））
.WithService.AllInterfaces（）
.LifestylePerWebRequest（））；

有一些测试来测试它。我声称它们是绿色的

[TestClass]
public class InstallerTest
{
    private IWindsorContainer container;

    [TestInitialize]
    public void Init()
    {
        container = new WindsorContainer().Install(new Installer());
    }

    [TestMethod]
    public void ResilveTest_ResolvesViaIRepository()
    {
        // act
        var repository = container.Resolve<IRepository<Person, int>>();
        // assert
        repository.Should().BeOfType<PeopleRepository>();
    }

    [TestMethod]
    public void ResilveTest_ResolvesViaIPeopleRepository()
    {
        // act
        var repository = container.Resolve<IPeopleRepository>();
        // assert
        repository.Should().BeOfType<PeopleRepository>();
    }
}

public class Installer : IWindsorInstaller
{
    public void Install(IWindsorContainer container, IConfigurationStore store)
    {
        container.Register(
            Classes.FromThisAssembly()
                .BasedOn(typeof(IRepository<,>))
                .WithService.AllInterfaces()
                .LifestylePerThread());
    }
}

[TestClass]
公共类安装测试
{
私人集装箱；
[测试初始化]
公共void Init（）
{
容器=新WindsorContainer（）.Install（新安装程序（））；
}
[测试方法]
公共无效ResilveTest_ResolvesViaResposition（）
{
//表演
var repository=container.Resolve（）；
//断言
repository.Should（）.BeOfType（）；
}
[测试方法]
公共无效恢复测试_Resolvesviaipeoperposition（）
{
//表演
var repository=container.Resolve（）；
//断言
repository.Should（）.BeOfType（）；
}
}
公共类安装程序：IWindsorInstaller
{
public void安装（IWindsorContainer、IConfigurationStore）
{
集装箱。登记(
类。FromThisAssembly（）
.BasedOn（类型（假定））
.WithService.AllInterfaces（）
.LifestylePerThread（））；
}
}