c# - 密封实现类时覆盖单个接口(interface)方法

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 真的很重，所以我想提供一个新版本的接口(interface)，使用旧版本的实例缓存对它的调用。

我现在是这样做的:

    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
    }

这有两个问题(至少):

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

有人能想出一种没有这些问题的方法吗？

Answer 1

三个选项:

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

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

就我个人而言，我喜欢将这种事情看作是一种语言特性——“除非我覆盖它，否则通过这个字段委托(delegate)给这个接口(interface)”，但显然目前还没有……