重构这个的更好方法？

Question

我有以下类：

public abstract class BaseClass
{
    private readonly double cachedValue;

    public BaseClass()
    {
         cachedValue = ComputeValue();
    }

    protected abstract double ComputeValue()          
}


public class ClassA : BaseClass
{
    protected override double ComputeValue()  { ... }            
}

public class ClassB : BaseClass
{
    protected override double ComputeValue()  { ... }                
}

其中 ComputeValue() 是一项耗时的计算。

问题是，ClassA 和 ClassB 中还有其他方法需要从 ComputeValue() 返回的值。我正在考虑在 BaseClass 中添加一个名为“CachedValue”的受保护属性，但我发现这种方法是多余的，并且会让其他程序员感到困惑，他们可能不知道它的存在，并可能直接调用 ComputeValue()。

第二个选项是在派生类级别使用可空类型，因为我不一定要求在 BaseClass 的构造函数中完成计算，惰性计算可能是更好的选择：

protected override double ComputeValue()  
{
    if(cachedValue.HasValue)
    {
        return (double) cachedValue;
    }

    // Do computation
    cachedValue = ...

    return cachedValue;
}        

但我觉得我可以做得更好。

您对此有何看法？

谢谢。

编辑：为了澄清，我试图通过强制使用“cachedValue”来防止 ComputeValue() 被多次调用。

Answer 1

为什么不在构造函数中采用与ComputeValue 具有相同目的的延迟，然后将值公开为受保护的只读字段？

public abstract class BaseClass {
  protected readonly double cachedValue;

  protected BaseClass(Func<double> computeValue) {
    cachedValue = computeValue();
  }
}

Answer 2

在某些时候你必须初始化这个值，这是没有办法解决的。所以我认为使用可为空值的方法是有意义的 - 我同意它比在那里拥有缓存属性要清晰得多。

您可能想向 ComputeValue 添加一个参数，强制再次计算该值：

protected override double ComputeValue(bool force)   
{ 
    if(!force && cachedValue.HasValue) 
    { 
        return cachedValue; 
    } 

    // Do computation 
    cachedValue = ... 

    return cachedValue; 
}         

Answer 3

如果您使用的是 NET 4，只需使用 Lazy。

public class ClassA
{
    Lazy<double> value = new Lazy<double>(()=>something.SomethingComplicated());

    public void AnyMethod()
    {
        double d = value.Value;
        //...
    }

}

请参阅 http://msdn.microsoft.com/en-us/library/dd642331。 aspx

更新：由于您使用的是 .NET 3.5，因此这里有一篇关于自己实现惰性的精彩文章（只有大约 20 个 LOC）：http://msdn.microsoft.com/en-us/vcsharp/bb870976.aspx

一个普遍好的建议是始终使用组合而不是继承： ）

Answer 4

另一种方法是在 Baseclass 上添加公共接口方法 GetValue，并且只允许覆盖继承类的 ComputeValue 方法 - 这样您就可以仍然可以扩展功能，但您可以在基类中控制 ComputeValue 结果的行为/上下文，即您可以像示例中那样添加记忆或根据需要进行装饰/扩展。

这遵循 非虚拟接口 (NVI) 模式 。

    public abstract class BaseClass
    {
        private double? cachedValue;

        public BaseClass()
        {
        }

        protected abstract double ComputeValue();

        public virtual double GetValue()
        {
            if (cachedValue.HasValue)
            {
                return (double)cachedValue;
            }
            else
            {
                cachedValue = ComputeValue();
                return (double)cachedValue;
            }

        }
    }

Answer 5

需要计算值的逻辑和计算值的逻辑之间是否存在相关的联系？

如果不是，或者至少没有 100% 匹配，您可以将计算逻辑放在单独的类中：CalculatorA 和 CalculatorB，它们都继承自 ICalculator 接口。然后，基类可能是访问该接口并缓存结果的唯一类。

Answer 6

我认为 ComputeValue 应该在属性 getter 中延迟调用：

public abstract class BaseClass
{
    private Func<double> _computeValue;

    private double? _cachedValue;
    protected double cachedValue
    {
       get
       {
          if(_cachedValue == null)
             _cachedValue = _computeValue();
          return (double)_cachedValue;
       }
       private set
       {
          _cachedValue = value;
       }
    }

    private BaseClass(){};
    public BaseClass(Func<double> computeValue)
    {
         _computeValue = computeValue;
    }    

}

Answer 7

为了存储/缓存计算值，您可以使用单例模式，基本上您声明一个静态字段，然后在尝试计算之前检查空值。因此，仅在第一次调用/访问方法或属性时才会计算计算值。如果某些派生类需要不同的计算值，则您可以重写基类方法/属性（需要 virtual 修饰符以确保多态性）。建议对表示类数据的元素使用属性而不是方法。

public abstract class BaseClass {
    private static double _cachedValue = null;
    public BaseClass() { }
    // base class implements a Singleton Pattern to store a computed value
    protected virtual double ComputeValue
    {
        get
        {
            if( _cachedValue == null) { _cachedValue = CalculateComputedValue; }
            return _cachedValue;
        }
    }   
    private double CalculateComputedValue() { return someComplexComputedValue; }
}

public class ClassA : BaseClass
{
    private static double _cachedValue = null;
    //this class does require calculate a specific computed value.
    protected override double ComputeValue
    { 
        get
        {
            if( _cachedValue == null) { _cachedValue = CalculateComputedValue; }
            return _cachedValue;
        }
    }
    private double CalculateComputedValue() { return someComplexComputedValue; }
}

public class ClassB : BaseClass
{
    //this class does not require to calculate compute value, inherited value is used instead.
}