这个类结构能更好地表示吗？

Question

public class Foo<T> { internal Foo() { } }
public sealed class Foo_SByte : Foo<SByte> { }
public sealed class Foo_Byte : Foo<Byte> { }
public sealed class Foo_Short : Foo<Int16> { }
public sealed class Foo_UShort : Foo<UInt16> { }
public sealed class Foo_Int : Foo<Int32> { }
public sealed class Foo_UInt : Foo<UInt32> { }
public sealed class Foo_Long : Foo<Int64> { }
public sealed class Foo_ULong : Foo<UInt64> { }
public sealed class Foo_Char : Foo<Char> { }
public sealed class Foo_Float : Foo<Single> { }
public sealed class Foo_Double : Foo<Double> { }
public sealed class Foo_Bool : Foo<Boolean> { }
public sealed class Foo_Decimal : Foo<Decimal> { }
public sealed class Foo_String: Foo<string> { }
public class Foo_Struct<T> : Foo<T> where T : struct { }
public class Foo_Enum<T> : Foo<T> where T : Enum { }

// Now T is immutable

我的目标是将Foo限制在所有潜在的值类型上，这在语义上(可能是错误的)假设相当于说“所有不可变类型”。

换句话说，我不想让T成为一个参考类型。

实现在Bars.之间不改变我只想保证T只限于不可变类型。

我有没有漏掉(不包括我所知道的简单类型)？

有更好的办法吗？

编辑：好的，我完全实现了。现在，Foo<T>的所有使用都保证是不可变的。(如果没有，请告诉我我错过了哪种类型。或者试图从傻瓜那里继承来证明我错了)。

Answer 1

不可能在编译时或运行时检查不可变性。可以得到的最接近的方法是检测类型是否具有复制语义(也就是说，如果赋值x = y将导致x具有一个独立于y被更改的值--某种程度上，请继续读下去)，因为实际上具有(内部)复制语义的类型列表在C#中受到限制。因此，您可以对其进行运行时检查：

class Foo<T> {
    public Foo() {
        if (!(typeof(T).IsValueType || typeof(T) == typeof(string))) {
            throw new ArgumentException($"{typeof(T)} does not have copy semantics.");
        }
    }
}

从概念上讲，每次实例化Foo<T>时都会发生这种检查，但实际上JIT可以对其进行优化。

注意，仅仅拥有副本语义仍然不能保证状态的正确性。特别是，用户定义的值类型可以引用实例之外的状态。简单的例子：

struct SneakyStruct {
    static int i = 0;
    public int Value => i++;    
}

事实上，您可以复制SneakyStruct，并且无法从外部修改状态，这对保证每次获得相同的Value仍然没有帮助。当然，这个例子是故意的，但是