C# Autofac约束绑定

我正在考虑从Ninject迁移到Autofac，但我正在努力转换一个有用的特性——通过属性约束绑定

我目前拥有此接口和实现：

public interface IRepository
{
   IEnumerable<SomeObject> Get();
}

public class DBRepository : IRepository
{
   public IEnumerable<SomeObject> Get()
   {
    // call the database
   }
}

公共接口IRepository
{
IEnumerable Get（）；
}
公共类数据库存储库：IRepository
{
公共IEnumerable Get（）
{
//调用数据库
}
}

我有一个缓存实现，它将签入缓存，如果没有找到任何内容，则调用db存储库。这将传递到构造函数中：

[DataNeeded]
public class CacheRepository : IRepository
{
    private readonly IRepository dataRepo;

    public CacheRepository(IRepository dataRepo)
    {
        this.dataRepo = dataRepo;
    }

    public IEnumerable<SomeObject> Get()
    {
        // check the cache and if nothing found:
        return this.dataRepo.Get();
    }
}

[需要数据]
公共类缓存存储库：IRepository
{
私有只读存储数据报告；
公共缓存存储库（IRepository dataRepo）
{
this.dataRepo=dataRepo；
}
公共IEnumerable Get（）
{
//检查缓存，如果未找到任何内容：
返回这个.dataRepo.Get（）；
}
}

最后，我有一个调用控制器，它将使用缓存获取对象：

[CacheNeeded]
public class HomeController : ApiController
{
    private readonly IRepository cacheRepo;

    public CacheRepository(IRepository cacheRepo)
    {
        this.cacheRepo= cacheRepo;
    }

    public IEnumerable<SomeObject> Get()
    {
       return this.cacheRepo.Get();
    }
}

[需要缓存]
公共类HomeController:ApiController
{
私有只读IRepository cacheRepo；
公共缓存存储库（IRepository cacheRepo）
{
this.cacheRepo=cacheRepo；
}
公共IEnumerable Get（）
{
返回此.cacheRepo.Get（）；
}
}

正如您所看到的，我重用了该接口，在数据存储库上添加了一个缓存层，并且该模式非常灵活。然后，我使用一些自定义属性告诉Ninject我需要某种类型的IRepository。其配置如下所示：

kernel.Bind<IRepository>().To<DbRepository>().WhenClassHas<DataNeeded>();
kernel.Bind<IRepository>().To<CacheRepository>().WhenClassHas<CacheNeeded>();

kernel.Bind（）.To（）.WhenClassHas（）；
kernel.Bind（）.To（）.WhenClassHas（）时；

---

有没有办法在Autofac中模拟这种行为

我想不出任何简洁明了的Autofac实现这种机制的方法，但也许您可以使用Autofac的一种。我会使用键控服务，在您的例子中，它是这样的：首先，您需要定义一个枚举，而不是自定义属性

enum RepositoryKind {CacheNeeded, DataNeeded}

然后将标记它们的组件注册为提供缓存或数据功能的组件，例如：

  builder.RegisterType<DbRepository>()
         .Keyed<IRepository>(RepositoryKind.CacheNeeded);

  builder.Register(c => new CacheRepository(c.ResolveKeyed<IRepository(RepositoryKind.CacheNeeded)))
         .Keyed<IRepository>(RepositoryKind.DataNeeded);

  builder.Register(c => new HomeController(c.ResolveKeyed<IRepository>(RepositoryKind.DataNeeded)));

builder.RegisterType（）
.Keyed（需要RepositoryKind.cached）；
Register（c=>newcacherepository（c.resolvedkeyed新HomeController（c.resolvedkeyed（RepositoryKind.DataNeeded））；

这种方法的优点是，您不会在控制器中显示实现细节，也不会在配置中应用缓存