更好的重構方法？

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

另一種方法是對Baseclass添加一個公共接口方法GetValue，只允許覆蓋ComputeValue繼承類的方法 - 這種方式仍然可以擴展功能，但您可以控制基類中ComputeValue結果的行爲/上下文，即可以像在示例中那樣添加記憶或根據需要裝飾/擴展。

這跟在Non-Virtual interface (NVI) pattern之後。

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 2

爲什麼不在構造函數中使用與ComputeValue具有相同目的的delagate，然後將該值作爲protected readonly字段公開？

public abstract class BaseClass { 
    protected readonly double cachedValue; 

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

Answer 3

在需要計算值的邏輯和計算值的邏輯之間是否存在相關鏈接？

如果不是，或者至少沒有100％匹配，則可以將計算邏輯放在單獨的類中：CalculatorA和CalculatorB，它們都從接口ICalculator繼承。然後Base類可以是唯一訪問此接口並緩存結果的類。

Answer 4

在某些時候，你將不得不初始化這個值，這是沒有辦法的。所以我認爲使用可空值的方法是有道理的 - 我同意它比在那裏有一個緩存屬性更清晰。

你可能雖然想添加一個參數ComputeValue迫使值再次計算：

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

    // Do computation 
    cachedValue = ... 

    return cachedValue; 
}   

Answer 5

我覺得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 6

如果你在NET 4just使用Lazy<T>。

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 7

爲了存儲/緩存計算值，你可以使用Singleton Pattern，基本上你聲明瞭一個靜態字段，然後在嘗試之前檢查null值 計算。所以只有在方法或屬性第一次被調用/加入時纔會計算出計算值。如果某個派生類需要不同的計算值，那麼您將覆蓋基類方法/屬性（虛擬修飾符用於確保多態性）。對於表示類的一種數據的元素，建議使用屬性而不是方法。

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. 
}