当实现类被密封时覆盖单个接口方法

Question

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

我有一个看起来像这样的接口：

    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
    }

这有两个问题（至少）：

• 每次有人向接口添加一个方法时，我都必须去更改它，即使我不希望缓存这个新方法，
• 我也会得到这么大的结果仅调用底层实现的无用代码列表。

谁能想出一种不存在这些问题的方法吗？

Answer 1

三个选项：

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

我个人而言，我可能会选择第三种选择，除非您真的发现自己经常这样做。权衡每个选项的成本 - 您实际上要花费多少时间来添加此委托？

就我个人而言，我希望将此类事情视为一种语言功能 - “通过此字段委托此接口，除非我覆盖它”，但显然目前不存在......

Answer 2

这就是我的建议。虽然并没有好多少，但会简化包装过程。

创建一个类 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);
    }
}

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