注意:这似乎在罗斯林被修复了
这个问题出现在我回答这个问题的时候，这个问题讨论了空合并运算符的结合律。
提醒一下，空合并操作符的思想是窗体的表达式
x ?? y
首先计算x，然后:
如果x的值为空，则计算y，这是表达式的最终结果
如果x的值非空，则不计算y，并且x的值是表达式的最终结果，在必要时转换为y的编译时类型
现在通常不需要转换，或者它只是从一个可空的类型到一个不可空的-通常类型是相同的，或者只是从(比如说)int?int。但是，您可以创建自己的隐式转换运算符，并在必要时使用它们。
对于简单的x ??y，我没有看到任何奇怪的行为。然而，使用(x ??y) ? ?我看到一些令人困惑的行为。
这是一个简短但完整的测试程序-结果在评论中:
using System;
public struct A
{
public static implicit operator B(A input)
{
Console.WriteLine("A to B");
return new B();
}
public static implicit operator C(A input)
{
Console.WriteLine("A to C");
return new C();
}
}
public struct B
{
public static implicit operator C(B input)
{
Console.WriteLine("B to C");
return new C();
}
}
public struct C {}
class Test
{
static void Main()
{
A? x = new A();
B? y = new B();
C? z = new C();
C zNotNull = new C();
Console.WriteLine("First case");
// This prints
// A to B
// A to B
// B to C
C? first = (x ?? y) ?? z;
Console.WriteLine("Second case");
// This prints
// A to B
// B to C
var tmp = x ?? y;
C? second = tmp ?? z;
Console.WriteLine("Third case");
// This prints
// A to B
// B to C
C? third = (x ?? y) ?? zNotNull;
}
}
所以我们有三种自定义值类型，A, B和C，以及从A到B, A到C和B到C的转换。
第二种情况和第三种情况我都能理解……但是为什么在第一种情况下会有额外的A到B的转换呢?特别是，我真的希望第一种情况和第二种情况是一样的——毕竟，它只是将一个表达式提取到一个局部变量中。
有人知道发生了什么吗?当谈到c#编译器时，我非常犹豫要不要喊“bug”，但我被难住了，不知道发生了什么……
编辑:好吧，这里有一个正在发生的事情的更糟糕的例子，多亏了配置器的答案，这让我进一步有理由认为这是一个bug。编辑:示例现在甚至不需要两个空合并操作符了…
using System;
public struct A
{
public static implicit operator int(A input)
{
Console.WriteLine("A to int");
return 10;
}
}
class Test
{
static A? Foo()
{
Console.WriteLine("Foo() called");
return new A();
}
static void Main()
{
int? y = 10;
int? result = Foo() ?? y;
}
}
它的输出是:
Foo() called
Foo() called
A to int
Foo()在这里被调用两次的事实让我非常惊讶——我看不出表达式被求值两次的任何理由。
感谢所有为分析这个问题做出贡献的人。这显然是一个编译器错误。似乎只有在合并运算符左侧涉及两个可空类型的提升转换时才会发生这种情况。
我还没有确定到底哪里出了问题，但是在编译的“可空化降低”阶段的某个时候——在初始分析之后，但在代码生成之前——我们减少了表达式
result = Foo() ?? y;
从上面的例子到道德等价物:
A? temp = Foo();
result = temp.HasValue ?
new int?(A.op_implicit(Foo().Value)) :
y;
显然这是不正确的;正确的下放方式是
result = temp.HasValue ?
new int?(A.op_implicit(temp.Value)) :
y;
到目前为止，根据我的分析，我最好的猜测是可空优化器在这里偏离了轨道。我们有一个可空优化器，它可以查找我们知道可空类型的特定表达式不可能为空的情况。考虑一下下面的天真分析:我们可能首先会说
result = Foo() ?? y;
和
A? temp = Foo();
result = temp.HasValue ?
(int?) temp :
y;
然后我们可以说
conversionResult = (int?) temp
和
A? temp2 = temp;
conversionResult = temp2.HasValue ?
new int?(op_Implicit(temp2.Value)) :
(int?) null
但优化器可以介入并说:“哇，等一下，我们已经检查过temp不为空;没有必要仅仅因为我们调用了一个提升的转换运算符而第二次检查它为空”。我们让他们把它优化到
new int?(op_Implicit(temp2.Value))
我的猜测是，我们在某处缓存(int?)Foo()的优化形式是新的int?(op_implicit(Foo().Value))，但这实际上不是我们想要的优化形式;我们希望将Foo()的优化形式替换为-temporary-然后转换。
c#编译器中的许多错误都是错误缓存决策的结果。一句话:每次缓存一个事实以供以后使用时，如果相关的东西发生了变化，就可能会造成不一致。在这种情况下，初始分析后的相关变化是，对Foo()的调用应该始终作为一个临时对象的取回来实现。
我们在c# 3.0中对可空重写传递做了大量的重组。这个错误在c# 3.0和4.0中重现，但在c# 2.0中没有，这意味着这个错误可能是我的错。对不起!
我将把一个错误输入到数据库中，我们将看看是否可以在语言的未来版本中修复这个问题。再次感谢大家的分析;这很有帮助!
更新:我重写了可空优化器从头罗斯林;它现在做得更好，避免了这些奇怪的错误。关于Roslyn中的优化器如何工作的一些想法，请参阅我的系列文章，从这里开始:https://ericlippert.com/2012/12/20/nullable-micro-optimizations-part-one/
感谢所有为分析这个问题做出贡献的人。这显然是一个编译器错误。似乎只有在合并运算符左侧涉及两个可空类型的提升转换时才会发生这种情况。
我还没有确定到底哪里出了问题，但是在编译的“可空化降低”阶段的某个时候——在初始分析之后，但在代码生成之前——我们减少了表达式
result = Foo() ?? y;
从上面的例子到道德等价物:
A? temp = Foo();
result = temp.HasValue ?
new int?(A.op_implicit(Foo().Value)) :
y;
显然这是不正确的;正确的下放方式是
result = temp.HasValue ?
new int?(A.op_implicit(temp.Value)) :
y;
到目前为止，根据我的分析，我最好的猜测是可空优化器在这里偏离了轨道。我们有一个可空优化器，它可以查找我们知道可空类型的特定表达式不可能为空的情况。考虑一下下面的天真分析:我们可能首先会说
result = Foo() ?? y;
和
A? temp = Foo();
result = temp.HasValue ?
(int?) temp :
y;
然后我们可以说
conversionResult = (int?) temp
和
A? temp2 = temp;
conversionResult = temp2.HasValue ?
new int?(op_Implicit(temp2.Value)) :
(int?) null
但优化器可以介入并说:“哇，等一下，我们已经检查过temp不为空;没有必要仅仅因为我们调用了一个提升的转换运算符而第二次检查它为空”。我们让他们把它优化到
new int?(op_Implicit(temp2.Value))
我的猜测是，我们在某处缓存(int?)Foo()的优化形式是新的int?(op_implicit(Foo().Value))，但这实际上不是我们想要的优化形式;我们希望将Foo()的优化形式替换为-temporary-然后转换。
c#编译器中的许多错误都是错误缓存决策的结果。一句话:每次缓存一个事实以供以后使用时，如果相关的东西发生了变化，就可能会造成不一致。在这种情况下，初始分析后的相关变化是，对Foo()的调用应该始终作为一个临时对象的取回来实现。
我们在c# 3.0中对可空重写传递做了大量的重组。这个错误在c# 3.0和4.0中重现，但在c# 2.0中没有，这意味着这个错误可能是我的错。对不起!
我将把一个错误输入到数据库中，我们将看看是否可以在语言的未来版本中修复这个问题。再次感谢大家的分析;这很有帮助!
更新:我重写了可空优化器从头罗斯林;它现在做得更好，避免了这些奇怪的错误。关于Roslyn中的优化器如何工作的一些想法，请参阅我的系列文章，从这里开始:https://ericlippert.com/2012/12/20/nullable-micro-optimizations-part-one/
如果你看一下左分组情况下生成的代码，它实际上是这样做的(csc /optimize-):
C? first;
A? atemp = a;
B? btemp = (atemp.HasValue ? new B?(a.Value) : b);
if (btemp.HasValue)
{
first = new C?((atemp.HasValue ? new B?(a.Value) : b).Value);
}
另一个发现，如果你首先使用，如果a和b都为空并返回c，它将生成一个快捷方式。然而，如果a或b非空，它将重新计算a作为隐式转换到b的一部分，然后返回a或b中哪一个非空。
来自c# 4.0规范，§6.1.4:
如果可空转换是从S?T ?：
如果源值为空(HasValue属性为false)，则结果为类型为T?的空值。
否则，转换被计算为从S?到S，然后是从S到T的基本转换，然后是从T到T的换行(§4.1.10)。
这似乎解释了第二种展开-包裹组合。
c# 2008和2010编译器生成非常相似的代码，但是这看起来像是c# 2005编译器(8.00.50727.4927)的回归，后者为上述代码生成如下代码:
A? a = x;
B? b = a.HasValue ? new B?(a.GetValueOrDefault()) : y;
C? first = b.HasValue ? new C?(b.GetValueOrDefault()) : z;
我想知道这是不是由于类型推断系统的额外魔力?
