可空枚举类型在用作泛型时不能分配给空

Question

我使用的是 C# 9，但遇到了这个奇怪的问题，所以我在下面写了一个简单的示例来演示它。我需要将可空枚举的值设置为空，但是通过泛型类型执行此操作时出现错误。如果我将枚举类型硬编码到类中它可以正常工作，所以我不确定为什么当相同类型用作泛型时它不起作用。似乎TOption? 被视为TOption 忽略了可为空的部分，这将使此错误变得有意义，因为它会尝试将 null 分配给不可为空的值类型。

这是可空类型、值类型和编译器假设之间的奇怪冲突吗？当Option 用作泛型类型时，TOption? 不应该与Option? 完全相同吗？

请注意，我不能将TOption 约束为在我的实际情况下解决此问题的值类型，并且我认为此约束不是必需的。我不需要 TOption 成为值类型，我只需要该字段可以为空——不管它是类还是结构。

关于将Option? 放入TOption，我仍然需要将其视为不可为空的字段。所以我不能这样做，我需要泛型中的实际类型，但我需要能够区分该类型的不可空和可空字段——独立于结构或类的类型。我应该指出，我使用的是可为空的引用类型，因此除非用? 指定，否则类将被视为不可为空。

public class Program
{
    public static void Main(string[] args)
    {
        var test = new Test<Option>();
        test.Option1 = null;
        test.Option2 = null; // Cannot convert null to 'Program.Option' because it is a non-nullable value type
    }

    public enum Option { A, B, C }

    public class Test<TOption>
    {
        public Option Option0 { get; set; }
        public Option? Option1 { get; set; }
        public TOption? Option2 { get; set; }
    }
}

Answer 1

这个失败的原因和我给here的解释很相似。虽然在这种情况下有一种解决方法，但在您的情况下，您实际上想要一个可为空的值类型，这使得这相当不可能。

T? 对 CLR 意味着两个非常不同的东西，具体取决于 T 是什么。如果T 是值类型，则表示Nullable<T>。如果T 是一个引用类型，那么就CLR 而言，T? 实际上与T 相同（带有一些属性）。

那么当编译器编译你的代码时，它会说Option2 是什么类型的？换句话说，如果您使用反射检查typeof(Test<>) 的成员（注意开放类型），Option2 属性的类型是什么？

在您的理想世界中，当TOption 是值类型时，您会希望Option2 的类型为Nullable<TOption>，而当TOption 是引用类型时，您希望TOption 的类型为TOption。但是如果我们要检查typeof(Test<>) 的属性类型，我们会得到哪种类型？不可能两者都，对吗？

实际上，编译器选择TOption 作为Option2 的类型，并将Option2 的类型视为可为空的，但请记住，它也可能是不可为空的值类型。

这就是为什么仅仅通过T? 无法实现“可空值和引用类型”的原因。

一个相当丑陋的解决方法是创建自己的Nullable<T>，它不会将T 限制为值类型：

struct MyNullable<T> where T: notnull {
    private T value;
    
    public bool HasValue {
        get;
    }
    
    public T Value { 
        get {
            if (HasValue) {
                return value;
            } else {
                throw new InvalidOperationException("Value is not present!");
            }
        } 
    }
    
    public MyNullable(T t) {
        value = t;
        HasValue = t != null;
    }
}

现在你可以这样做了：

public class Test<TOption>
{
    public Option Option0 { get; set; }
    public Option? Option1 { get; set; }
    public MyNullable<TOption> Option2 { get; set; }
}

Answer 2

Nullable<T> 要求 T 是值类型（请参阅documentation），但这不能由编译器从您的泛型类型派生而来。所以你需要帮助他使用约束：

public class Test<TOption> where TOption : struct
{
    public Option? Option1 { get; set; }
    public TOption? Option2 { get; set; }
}

编辑：正如您现在所说，您不能依赖 TOption 作为值类型，您需要通过在泛型类型实例化而不是定义中指定 Nullable 来重构整个事物：

public class Program
{
    public static void Main(string[] args)
    {
        var test = new Test<Option?>();
        test.Option1 = null;
        test.Option2 = null;
    }

    public enum Option { A, B, C }

    public class Test<TOption>
    {
        public Option? Option1 { get; set; }
        public TOption Option2 { get; set; }
    }
}

Answer 3

在不限制struct 或使用default 的情况下，您可以获得最接近您想要的内容，它在泛型参数中提供可空类型（可能适合您，也可能不适合您）

var test = new Test<Option?>
{
    Option1 = null,
    Option2 = null // works
};

Console.WriteLine(test.Option2.HasValue);

这样做的问题是，泛型类仍然不知道它是在内部被限制为结构还是类，这可能仍然会以各种方式限制您，具体取决于此处的用例。

所以根据您更新的要求，如果您不能使用可为空的类型；您需要一个可为空的通用实例属性；并且您不能限制为结构，那么您可能需要重新考虑您的问题。 CLR 在编译时无法确定您提供的泛型参数可以为空，因此会产生编译器错误。

Answer 4

为什么不这样呢？

   public class Program
    {
        public enum EnumOption { A, B, C }
        public class ClassOption { public int A { get; set; } }
        public interface InterfaceOption { public int A { get; set; } }
        public struct StructOption { int A; }

        public class Test<TOption>
        {
            public TOption GenericOption { get; set; }
        }
        

       // main entry
        public static void Main(string[] args)
        {
            // reference type  type 
            new Test<ClassOption>().GenericOption = null;
            new Test<InterfaceOption>().GenericOption = null;
            // nullable value type
            new Test<StructOption?>().GenericOption = null;
            new Test<EnumOption?>().GenericOption = null;
            new Test<int?>().GenericOption = null;

            // non nullable value type, use default for init/comparison
            new Test<StructOption?>().GenericOption = default;
            new Test<EnumOption?>().GenericOption = default;
            new Test<int?>().GenericOption = default;
        }

    }