System.Threading.Interlocked类提供了一些非常有用的方法来帮助编写线程安全的代码.其中一个更复杂的方法是CompareExchange,它可用于计算可从多个线程更新的运行总计.

由于使用CompareExchange有点棘手,我认为为它提供一些辅助方法是一个相当常识的想法：

// code mangled so as not to require horizontal scrolling
// (on my monitor,anyway)
public static double Aggregate
(ref double value,Func<double,double> aggregator) {
    double initial,aggregated;

    do {
        initial = value;
        aggregated = aggregator(initial);
    } while (
        initial != Interlocked.CompareExchange(ref value,aggregated,initial)
    );

    return aggregated;
}

public static double Increase(ref double value,double amount) {
    return Aggregate(ref value,delegate(double d) { return d + amount; });
}

public static double Decrease(ref double value,delegate(double d) { return d - amount; });
}

现在,也许我只是因为一般的快乐而感到愧疚(我承认,这通常是正确的);但是我觉得将上述方法提供的功能限制为仅加倍值(或者更确切地说,对于我必须为我想要支持的每种类型编写上述方法的重载版本)确实感到愚蠢.为什么我不能这样做？

// the code mangling continues...
public static T Aggregate<T>
(ref T value,Func<T,T> aggregator) where T : IEquatable<T> {
    T initial,aggregated;

    do {
        initial = value;
        aggregated = aggregator(initial);
    } while (
        !initial.Equals(
            Interlocked.CompareExchange<T>(ref value,initial)
        )
    );
}

我不能这样做因为Interlocked.CompareExchange< T>显然有一个T：class约束,我不明白为什么.也就是说,也许是因为CompareExchange已经有重载接受Int32,Int64,Double等;但这似乎不是一个很好的理由.例如,在我的情况下,能够使用Aggregate< T>是非常方便的.执行各种原子计算的方法.