它是原子的吗?代理

我将创建一个"long" (Int64)代理，它必须是原子的，因此它在并发应用程序中的副本本质上是安全的。我不能使用Int32，因为它跨越的范围太短了。

我知道原子性应该得到保证，只要涉及的数据可以容纳在一个双字(32位)。无论操作系统是32位还是64位

现在，考虑下面的"长"代理…

注意:我省略了几个方法，因为我不需要它们。在这种情况下，我只需要从一个真正长的

到/的基本转换。

public struct SafeLong
    : IConvertible
{
    public SafeLong(long value)
    {
        unchecked
        {
            var arg = (ulong)value;
            this._data = new byte[]
            {
                (byte)arg,
                (byte)(arg >> 8),
                (byte)(arg >> 16),
                (byte)(arg >> 24),
                (byte)(arg >> 32),
                (byte)(arg >> 40),
                (byte)(arg >> 48),
                (byte)(arg >> 56),
            };
        }
    }

    private byte[] _data;

    private long Value
    {
        get
        {
            unchecked
            {
                var lo =
                    this._data[0] |
                    this._data[1] << 8 |
                    this._data[2] << 16 |
                    this._data[3] << 24;
                var hi = 
                    this._data[4] |
                    this._data[5] << 8 |
                    this._data[6] << 16 |
                    this._data[7] << 24;
                return (long)((uint)lo | (ulong)(uint)hi << 32);
            }
        }
    }

    public static implicit operator long(SafeLong value)
    {
        return value.Value;  // implicit conversion
    }

    public static explicit operator SafeLong(long value)
    {
        return new SafeLong(value);  // explicit conversion
    }

    #region IConvertible implementation
    public TypeCode GetTypeCode()
    {
        return Type.GetTypeCode(typeof(SafeLong));
    }
    public object ToType(Type conversionType, IFormatProvider provider)
    {
        return Convert.ChangeType(this.Value, conversionType);
    }
    public long ToInt64(IFormatProvider provider)
    {
        return this.Value;
    }
    // ... OMISSIS (not implemented) ...
    #endregion
}

嗯，好像和我预期的一样，运行得很好。

这里有一个小测试:

class Program
{
    static void Main(string[] args)
    {
        var sla = (SafeLong)12345678987654321L;
        var la = (long)sla;
        Console.WriteLine(la);
        var slb = (SafeLong)(-998877665544332211L);
        var lb = (long)slb;
        Console.WriteLine(lb);
        Console.WriteLine(Marshal.SizeOf(typeof(SafeLong)));
        Console.WriteLine(Marshal.SizeOf(sla));
        Console.WriteLine(Marshal.SizeOf(slb));
        long lc = new SafeLong(556677);
        var slc = slb;
        Console.WriteLine(slc);
        slc = (SafeLong)lc;
        Console.WriteLine(slc);
        Console.WriteLine(slb);
        Console.Write("Press any key...");
        Console.ReadKey();
    }
}

SizeOf函数总是产生4字节作为代理的大小。这个值是否保证了saflong -to- safelong副本的原子性，或者这4个字节应该被解释为"真正的物理双字"?

无论长<--> SafeLong:是否具有非原子性，它都将被包含在一个安全的上下文中。

public struct SafeThing<T> where T : struct
{
    private object boxedThing;
    public SafeThing(T value)
    {
        boxedThing = value;
    }
    public T Value { get { return boxedThing == null ? default(T) : (T)boxedThing; } }
    public static implicit operator T(SafeThing<T> value)
    {
        return value.Value; 
    }
    public static implicit operator SafeThing<T>(T value)
    {
        return new SafeThing(value); 
    }
}