4

这可能是最容易用代码解释的（这当然不是实际代码，但它具有相同的属性）：

我有一个看起来像这样的界面：

    public interface ISomeProvider
    {
        object GetFoo1(); //<-- This needs caching

        //These others don't
        object GetFoo2();
        object GetFoo3();

        //And let's say 20 more
    }

这有一个这样的实现：

    //NOTE: Sealed class otherwise we could inherit from it
    public sealed  class SuperCleverProvider : ISomeProvider
    {
        public object GetFoo1()
        {
            return "a";
        }

        public object GetFoo2()
        {
            return "b";
        }

        public object GetFoo3()
        {
            return "b";
        }
    }

现在其中一个调用，假设 GetFoo1 真的很重，所以我想提供一个新版本的接口，使用旧版本的实例缓存对它的调用。

我现在正在这样做：

    public class CachedSuperCleverProvider : ISomeProvider
    {
        private readonly SuperCleverProvider _provider;

        public CachedSuperCleverProvider(SuperCleverProvider provider)
        {
            _provider = provider;
        }

        private object UsingCache<T>(string cacheKey, Func<T> eval)
        {
            //Pretend this does caching. This is not related to the question
            throw new NotImplementedException();
        }

        public object GetFoo1()
        {
            return UsingCache("foo1", _provider.GetFoo1);
        }

        //The code below this point is what I want to get rid of
        public object GetFoo2()
        {
            return _provider.GetFoo2();
        }

        public object GetFoo3()
        {
            return _provider.GetFoo3();
        }

        //And so on for all the rest
    }

这有两个问题（至少）：

  • 每次有人向接口添加方法时，我都必须更改它，即使我不希望缓存这个新方法
  • 我得到了这个巨大的无用代码列表，它们只是调用底层实现。

谁能想到没有这些问题的方法？

4

2 回答 2

3

三个选项：

  • 自动生成类
  • 使用PostSharp或类似的东西以更基于拦截器的方式执行此操作
  • 和它一起生活

就个人而言，我可能会选择第三种选择，除非你真的发现自己经常这样做。权衡每个选项的成本——你实际上要花多少时间来添加这个代表团？

就我个人而言，我希望将这种事情视为一种语言特性——“除非我覆盖它，否则通过这个字段委托给这个界面”但显然目前不存在......

于 2011-08-19T09:27:50.607 回答
0

这是我的建议。这不是更好，但会简化包装过程。

创建一个类SomeProviderWrapper：

public class SomeProviderWrapper : ISomeProvider
{
    protected ISomeProvider WrappedProvider { get; private set; }

    protected SomeProviderWrapper(ISomeProvider wrapped)
    {
        if (wrapped == null)
            throw new ArgumentNullException("wrapped");

        WrappedProvider = wrapped;
    }

    public virtual object GetFoo1()
    {
        return WrappedProvider.GetFoo1();
    }

    public virtual object GetFoo2()
    {
        return WrappedProvider.GetFoo2();
    }

    public virtual object GetFoo3()
    {
        return WrappedProvider.GetFoo3();
    }
}

现在包装被降级到它自己的类，您可以编写缓存版本：

public class CachedSuperCleverProvider : SomeProviderWrapper
{
    public CachedSuperCleverProvider(ISomeProvider wrapped) : base(wrapped) { }

    private object UsingCache<T>(string cacheKey, Func<T> eval)
    {
        throw new NotImplementedException();
    }

    public override object GetFoo1()
    {
        return UsingCache("foo1", WrappedProvider.GetFoo1);
    }
}

这使委托代码远离您的超级聪明的提供者。您仍然需要维护委托代码，但它不会污染您的缓存提供程序的设计。

于 2011-08-19T09:30:58.747 回答