为什么从 <T> 到 <U> 的隐式转换运算符接受 <T?>？

Question

这是一种我无法理解的奇怪行为。在我的示例中，我有一个类Sample<T> 和一个从T 到Sample<T> 的隐式转换运算符。

private class Sample<T>
{
   public readonly T Value;

   public Sample(T value)
   {
      Value = value;
   }

   public static implicit operator Sample<T>(T value) => new Sample<T>(value);
}

当为T 使用可空值类型（例如int?）时会出现问题。

{
   int? a = 3;
   Sample<int> sampleA = a;
}

这里是关键部分：
在我看来，这不应该编译，因为Sample<int> 定义了从int 到Sample<int> 的转换，但不是从int? 到Sample<int>。 但它编译并运行成功！（我的意思是调用转换运算符并将3 分配给readonly 字段。）

而且情况变得更糟。这里没有调用转换运算符，sampleB 将被设置为null：

{
   int? b = null;
   Sample<int> sampleB = b;
}

一个很好的答案可能会分为两部分：

1. 为什么第一个sn-p中的代码会编译？
2. 我可以阻止代码在这种情况下编译吗？

Answer 1

你可以看看编译器是如何降低这段代码的：

int? a = 3;
Sample<int> sampleA = a;

转入this：

int? nullable = 3;
int? nullable2 = nullable;
Sample<int> sample = nullable2.HasValue ? ((Sample<int>)nullable2.GetValueOrDefault()) : null;

因为Sample<int> 是一个类，它的实例可以被分配一个空值，并且使用这样一个隐式运算符，一个可以为空的对象的基础类型也可以被分配。所以像这样的分配是有效的：

int? a = 3;
int? b = null;
Sample<int> sampleA = a; 
Sample<int> sampleB = b;

如果Sample<int> 是struct，那当然会报错。

编辑： 那么为什么这可能呢？我在规范中找不到它，因为它是故意违反规范的，这只是为了向后兼容。你可以在code阅读它：

故意违反规范：
本机编译器允许“解除”转换，即使转换的返回类型不是不可为空的值类型。例如，如果我们有一个从 struct S 到 string 的转换，那么从 S 的“提升”转换？ to string 被原生编译器认为存在，语义为“s.HasValue ? (string)s.Value : (string)null”。为了向后兼容，Roslyn 编译器会延续此错误。

这就是 Roslyn 中的 implemented 的“错误”：

否则，如果转换的返回类型是可为空的值类型、引用类型或指针类型P，那么我们将其降低为：

temp = operand
temp.HasValue ? op_Whatever(temp.GetValueOrDefault()) : default(P)

因此，根据spec，对于给定的用户定义转换运算符T -> U，存在一个提升运算符T? -> U?，其中T 和U 是不可为空的值类型。但是，由于上述原因，U 是引用类型的转换运算符也实现了这种逻辑。

PART 2 在这种情况下如何防止代码编译？嗯，有办法。您可以专门为可空类型定义一个额外的隐式运算符，并用属性Obsolete 装饰它。这需要将类型参数T 限制为struct：

public class Sample<T> where T : struct
{
    ...

    [Obsolete("Some error message", error: true)]
    public static implicit operator Sample<T>(T? value) => throw new NotImplementedException();
}

该运算符将被选为可空类型的第一个转换运算符，因为它更具体。

如果你不能做出这样的限制，你必须为每个值类型分别定义每个运算符（如果你真的确定你可以利用反射和使用模板生成代码）：

[Obsolete("Some error message", error: true)]
public static implicit operator Sample<T>(int? value) => throw new NotImplementedException();

如果在代码中的任何地方引用都会出错：

错误 CS0619 'Sample.implicit operator Sample(int?)' 已过时：'一些错误消息'

Answer 2

我认为它是提升转换运算符的作用。规范说：

给定一个用户定义的转换运算符，该运算符从 非可空值类型 S 到不可空值类型 T，提升 存在从 S 转换的转换运算符？到T?。这解除了 转换运算符从 S?到 S 然后 用户定义的从 S 到 T 的转换，然后是 T 的换行 到 T?，除了一个空值 S?直接转换为空值 T？。

这里好像不适用，因为虽然S 类型在这里是值类型（int），但T 类型不是值类型（Sample 类）。然而，Roslyn 存储库中的 this issue 声明它实际上是规范中的错误。 Roslyn code 文档证实了这一点：

如上所述，这里我们与规范不同，分为两个 方法。首先，如果正常形式是，我们只检查提升形式 不适用。其次，我们应该只应用提升语义 如果转换参数和返回类型都不可为空 值类型。

实际上本地编译器决定是否检查一个提升 形式基于：

• 我们最终要从可空值类型转换的类型吗？
• 转换的参数类型是不可为空的值类型吗？
• 我们最终要转换为可空值类型、指针类型还是引用类型的类型？

如果所有这些问题的答案都是“是”，那么我们提升为 nullable 并查看结果运算符是否适用。

如果编译器遵循规范 - 在这种情况下它会如您预期的那样产生错误（在某些旧版本中确实如此），但现在不会。

总结一下：我认为编译器使用了隐式运算符的提升形式，根据规范这应该是不可能的，但是编译器在这里与规范不同，因为：

• 它被认为是规范中的错误，而不是编译器中的错误。
• 旧的、pre-roslyn 编译器已经违反了规范，保持向后兼容性很好。

正如第一个引用中描述的提升运算符如何工作的描述（此外，我们允许 T 成为引用类型） - 您可能会注意到它准确描述了您的案例中发生的情况。 null 值 S (int?) 直接分配给 T (Sample) 没有转换运算符，非 null 被解包到 int 并通过你的运算符运行（包装到 T? 是如果T 是引用类型，显然不需要）。

Answer 3

为什么第一个sn-p中的代码会编译？

来自Nullable<T> 源代码的代码示例，可以在here 找到：

[System.Runtime.Versioning.NonVersionable]
public static explicit operator T(Nullable<T> value) {
    return value.Value;
}

[System.Runtime.Versioning.NonVersionable]
public T GetValueOrDefault(T defaultValue) {
    return hasValue ? value : defaultValue;
}

结构Nullable<int> 具有重写的显式运算符以及方法GetValueOrDefault 编译器使用这两者之一将int? 转换为T。

之后它运行implicit operator Sample<T>(T value)。

大概的情况是这样的：

Sample<int> sampleA = (Sample<int>)(int)a;

如果我们在Sample<T> 隐式运算符中打印typeof(T)，它将显示：System.Int32。

在您的第二种情况下，编译器不使用implicit operator Sample<T>，而是简单地将null 分配给sampleB。