c# - 使用泛型和 StructureMap 实现策略模式

Question

我正在尝试使用 SM 和泛型在我的存储库层中实现策略模式。为此，我有一个接口(interface) IPocoRepository，它有一个使用 Entity Framework 的具体实现。我已经设法在我的 Bootstrapper 文件中连接起来:

For(typeof(IPocoRepository<>)).Use(typeof(EntityFrameworkRepository<>));

当我尝试为此接口(interface)实现缓存时出现问题。在我的缓存类中，我想要一个基本存储库类的实例，这样我就可以保持我的设计干燥。让我概述一下这三个文件的外观:

public interface IPocoRepository<T>
{
    IQueryable<T> GetAll();
    ...


public class EntityFrameworkRepository<T> : IPocoRepository<T> where T : class
{
    public IQueryable<T> GetAll()
    {
        ...

public class CachedRepository<T> : IPocoRepository<T> where T : class
{
    private IPocoRepository<T> _pocoRepository;

    public CachedRepository(IPocoRepository<T> pr)
    {
        _pocoRepository = pr;
    }

    public IQueryable<T> GetAll()
    {
        var all = (IQueryable<T>)CacheProvider.Get(_cacheKey);
        if (!CacheProvider.IsSet(_cacheKey))
        {
            all = _pocoRepository.GetAll();
            ...

编辑:我希望 StructureMap 在请求 IPocoRepository 时返回 CachedRepository，除非在 CachedRepository 中请求 - 然后我希望它返回 EntityFrameworkRepository。

我知道在处理非泛型类时这很简单:

For<ICountyRepository>().Use<CachedCountyRepository>()
.Ctor<ICountyRepository>().Is<CountyRepository>();

我尝试搜索文档以了解如何执行此操作，但找不到任何内容。任何帮助将不胜感激!

Answer 1

好的，这并不难。您可以使用类型拦截器。鉴于您有以下类(class):

public interface IRepository<T>{}

public class Repository<T>:IRepository<T>{}

public class RepositoryCache<T> : IRepository<T>
{
    private readonly IRepository<T> _internalRepo;

    public RepositoryCache(IRepository<T> internalRepo)
    {
        _internalRepo = internalRepo;
    }

    public IRepository<T> InternalRepo
    {
        get { return _internalRepo; }
    }
}

然后您需要创建一个类型拦截器。为此，您可以使用 StructureMap 提供的可配置“MatchedTypeInterceptor”。拦截器将需要查找您的存储库，然后找出泛型类型参数是什么。一旦它有了类型参数，它就可以声明它需要的缓存类型并对其进行初始化。作为初始化的一部分，它将在其构造函数中获取原始存储库。然后拦截器会将完成的缓存返回给从 ioc 上下文请求的任何内容。这是测试中的完整序列。

这可以移出到您的注册表中，我只是将它们放在一起作为一个最小示例。

    [Test]
    public void doTest()
    {
        MatchedTypeInterceptor interceptor = new MatchedTypeInterceptor(
             x => x.FindFirstInterfaceThatCloses(typeof (IRepository<>)) != null);

        interceptor.InterceptWith(original =>
        {
            Type closedType = original.GetType()
                 .FindFirstInterfaceThatCloses(typeof(IRepository<>));

            var genericParameters = closedType.GetGenericArguments();

            var closedCacheType = typeof(RepositoryCache<>)
                 .MakeGenericType(genericParameters);

            return Activator.CreateInstance(closedCacheType, new[] {original});
        });

        ObjectFactory.Initialize(x =>
        {
            x.For(typeof (IRepository<>)).Use(typeof (Repository<>));
            x.RegisterInterceptor(interceptor);
        });

        var test = ObjectFactory.GetInstance<IRepository<int>>();

        Assert.That(test is RepositoryCache<int>);
    }