C# 访问器应该使用私有变量还是动态计算？

Question

哪种编程实践更好？为什么？

我有一个这样的类：

class data {

    public double time { get; internal set; }
    public double count { get; internal set; }
    public average_count { ... }

}

其中average_count应该是read_only并给出计数/时间的计算。

将访问器编写为：

public average_count { get {

    return (time == 0) ? 0 : (count / time);

}}

或者我应该这样做：

private _avg_count;

public average_count {
    get 
    {
        return _avg_count;
    }

    internal set
    {
        return _avg_count;
    }
}

在时间和计数设置访问器中时，_avg_count 在哪里更新？

看起来第一个更容易阅读，但如果经常访问average_count可能会更慢。编译器优化会使差异变得微不足道吗？

Answer 1

即时执行会产生更具可读性的代码。预先计算可能会提高性能，但只有在以下情况下才应该这样做：(a) 有必要，并且 (b) 您已经进行了分析并且它会产生影响。

最重要的是，只有在绝对必要时才应该牺牲可读性和可维护性来提高性能。

Answer 2

这是一个看似简单的问题，却几乎无法回答。原因是什么是“正确的”取决于许多因素。

1.性能

在他的回答中Skilldrick 建议您优先选择可读性强的内容，而不是性能最佳的内容，作为一般规则：

[R]可读性和可维护性应该
仅为了性能而牺牲
当绝对必要时。

我反驳说，这仅在典型的业务应用程序中是正确的，其中性能和功能是两个明显可区分的特征。在某些高性能软件场景中，这并不是一件容易说的事情，因为性能和功能可能变得密不可分——也就是说，你的程序完成其任务的好坏取决于它执行的牢固程度（这是这种情况）我目前的工作地点是一家做算法交易的公司）。

所以这是你的判断。最好的建议是只要有一点线索就进行分析；如果在您的情况下为了性能而牺牲可读性是合适的，那么您应该这样做。

2.内存使用

0xA3 建议一种相当优雅的方法，提供某种折衷方案：仅根据需要计算值，然后缓存它。

当然，这种方法的缺点是需要更多的内存来维护。 int? 需要的内存量与 int 加上 bool 基本相同（由于对齐问题，实际上可能意味着 64 位）而不仅仅是 40）。如果您有大量此 data 类的实例，并且内存在您的目标平台上是稀缺资源，那么每个实例再增加 32 位来膨胀您的类型可能不是最明智的举动。

3. 可维护性

也就是说，我总体上同意其他人所说的，在其他条件相同的情况下，你最好在可读性方面犯错误，这样你将来重新访问代码时就可以理解它。然而，解决这个问题的各种方法都不是特别复杂。

最重要的是，只有您知道自己的具体情况，因此您最有能力决定在这里做什么。

Answer 3

这取决于您调用 average_count 的频率以及修改 count 和 time 的频率。对于此类优化，我建议您使用分析器。

Answer 4

如果性能至关重要并且您需要频繁访问该属性，您还有另一个选择：在需要时计算结果，然后缓存结果。该模式看起来像这样：

class Foo
{
    int? _cachedResult = null;

    int _someProperty;
    public int SomeProperty
    {
        get { return _someProperty; }
        set { _someProperty = value; _cachedResult = null; }
    }

    int _someOtherProperty;
    public int SomeOtherProperty
    {
        get { return _someOtherProperty; }
        set { _someOtherProperty = value; _cachedResult = null; }
    }

    public int SomeDerivedProperty
    {
        get
        {
            if (_cachedResult == null)
                _cachedResult = someExpensiveCalculation();

            return (int)_cachedResult;
        }
    }
}

Answer 5

在这个简单的情况下，我肯定会先实现计算版本；然后根据需要进行优化。如果存储该值，则如果该值所依赖的任何值发生更改，则还需要额外的代码来重新计算该值，这可能会导致错误。

不要过早优化。

Answer 6

我会选择你的第一个选择。这些是内存中的对象，因此您正在执行的操作的计算速度将非常快。此外，如果您为此创建了专用属性（例如，average_count），那么您将必须添加更多代码来在设置器中重新计算时间和计数。

作为旁注（因为您询问的是最佳实践），您应该在 C# 中使用 Pascal 大小写，即首字母大写且无下划线。

Answer 7

<块引用>

编译器优化会使差异变得微不足道吗？

取决于你认为“重要”的是什么。读取变量相当快。除两个数相当快。事实上，根据 RAM 缓存中的内容，读取变量可能比执行除法花费更长的时间。

使用第一种方法。如果它看起来很慢，那么考虑第二个。

Answer 8

如果您关心线程安全，那么执行第二个选项可能比第一个选项更容易。

private double _avg_count;
static readonly object avgLock = new object();

public double time { get; internal set; }
public double count { get; internal set; }


public double average_count {
    get 
    {
        return _avg_count;
    }


}

private void setAverageCount()
{
    _avg_count = time == 0 ? 0 : (count / time);
}


 public void Increment()
 {
     lock (avgLock)
     {
         count += 1;
         setAverageCount();
     }


 }


 public void EndTime(double time)
 {
     lock (avgLock)
     {
         time = time;
         setAverageCount();

     }
 }