C# 和 Java 的三元运算符 (? :) 之间的区别

Question

我是 C# 新手，我只是遇到了一个问题。在处理三元运算符（? :）时，C# 和 Java 是有区别的。

在下面的代码段中，为什么第 4 行不起作用？编译器显示错误消息there is no implicit conversion between 'int' and 'string'。第 5 行也不行。 Lists 都是对象，不是吗？

int two = 2;
double six = 6.0;
Write(two > six ? two : six); //param: double
Write(two > six ? two : "6"); //param: not object
Write(two > six ? new List<int>() : new List<string>()); //param: not object

但是，相同的代码在 Java 中也可以工作：

int two = 2;
double six = 6.0;
System.out.println(two > six ? two : six); //param: double
System.out.println(two > six ? two : "6"); //param: Object
System.out.println(two > six ? new ArrayList<Integer>()
                   : new ArrayList<String>()); //param: Object

C# 中缺少哪些语言功能？如果有，为什么不添加？

Answer 1

关于泛型部分：

two > six ? new List<int>() : new List<string>()

在 C# 中，编译器尝试将右侧的表达式部分转换为一些通用类型；因为List<int> 和List<string> 是两种不同的构造类型，一种不能转换为另一种。

在Java中，编译器试图找到一个共同的超类型而不是转换，所以代码的编译涉及到wildcards和type erasure的隐式使用；

two > six ? new ArrayList<Integer>() : new ArrayList<String>()

具有ArrayList<?> 的编译类型（实际上，它也可以是ArrayList<? extends Serializable> 或ArrayList<? extends Comparable<?>>，取决于使用上下文，因为它们都是常见的泛型超类型）和运行时类型的原始ArrayList（因为它是常见的原始超类型）。

例如(test it yourself)，

void test( List<?> list ) {
    System.out.println("foo");
}

void test( ArrayList<Integer> list ) { // note: can't use List<Integer> here
                                 // since both test() methods would clash after the erasure
    System.out.println("bar");
}

void test() {
    test( true ? new ArrayList<Object>() : new ArrayList<Object>() ); // foo
    test( true ? new ArrayList<Integer>() : new ArrayList<Object>() ); // foo 
    test( true ? new ArrayList<Integer>() : new ArrayList<Integer>() ); // bar
} // compiler automagically binds the correct generic QED

Answer 2

给出的答案很好；我要向他们补充一点，这条 C# 规则是更通用的设计准则的结果。当被要求从几个选项之一推断表达式的类型时，C# 会选择其中最好的一个。也就是说，如果你给 C# 一些选项，比如“Giraffe, Mammal, Animal”，那么它可能会选择最一般的——动物——或者它可能会选择最具体的——长颈鹿——这取决于具体情况。但它必须选择它实际给出的选择之一。 C# 从来没有说“我的选择是在猫和狗之间，因此我会推断动物是最好的选择”。这不是给定的选择，因此 C# 无法选择它。

在三元运算符的情况下，C# 尝试选择更通用的 int 和 string 类型，但也不是更通用的类型。 C# 没有选择一开始就没有选择的类型，比如 object，而是决定不能推断出任何类型。

我还注意到，这符合 C# 的另一个设计原则：如果看起来有问题，请告诉开发人员。语言并没有说“我会猜测你的意思，如果可以的话，我会蒙混过关”。语言说“我认为你在这里写了一些令人困惑的东西，我要告诉你。”

另外，我注意到 C# 不会从 变量 推理到 赋值，而是从另一个方向推理。 C# 没有说“您正在分配给一个对象变量，因此表达式必须可转换为对象，因此我会确保它是”。相反，C# 说“这个表达式必须有一个类型，并且我必须能够推断出该类型与对象兼容”。由于表达式没有类型，所以会产生错误。

Answer 3

这很简单。 string 和 int 之间没有隐式转换。三元运算符需要最后两个操作数具有相同的类型。

试试：

Write(two > six ? two.ToString() : "6");

Answer 4

查看C# 5 语言规范第 7.14 节：条件运算符，我们可以看到以下内容：

• 如果 x 是 X 类型，y 是 Y 类型，那么

  • 如果存在从 X 到 Y，但不存在从 Y 到 X 的隐式转换（第 6.1 节），则 Y 是 条件表达式。

  • 如果存在从 Y 到 X，但不存在从 X 到 Y 的隐式转换（第 6.1 节），则 X 是 条件表达式。

  • 否则无法确定表达式类型，出现编译时错误

换句话说：它尝试查找 x 和 y 是否可以转换为 彼此，如果不能，则发生编译错误。在我们的例子中，int 和 string 没有显式或隐式转换，因此无法编译。

将此与Java 7 Language Specification section 15.25: Conditional Operator 进行对比：

• 如果第二个和第三个操作数的类型相同（可能是 null 类型），那么这就是条件表达式的类型。 （否）
• 如果第二个和第三个操作数之一是原始类型 T，而另一个的类型是对 T 应用装箱转换（第 5.1.7 节）的结果，则条件表达式的类型为 T。（ 否）
• 如果第二个和第三个操作数之一是空类型，另一个是引用类型，那么条件表达式的类型就是那个引用类型。 （否）
• 否则，如果第二个和第三个操作数具有可转换（第 5.1.8 节）为数值类型的类型，则有几种情况：（NO）
• 否则，第二个和第三个操作数分别为 S1 和 S2 类型。令 T1 为将装箱转换应用于 S1 的类型，令 T2 为将装箱转换应用于 S2 的类型。
  条件表达式的类型是将捕获转换 (§5.1.10) 应用于 lub(T1, T2) (§15.12.2.7) 的结果。 （是）

并且，查看section 15.12.2.7. Inferring Type Arguments Based on Actual Arguments，我们可以看到它试图找到一个共同的祖先，该祖先将用作用于以Object 登陆它的调用的类型。 Object 是一个可接受的参数，所以调用会起作用。

Answer 5

在 Java 和 C#（以及大多数其他语言）中，表达式的结果都有一个类型。在三元运算符的情况下，有两个可能的子表达式为结果求值，并且两者必须具有相同的类型。对于 Java，int 变量可以通过自动装箱转换为 Integer。现在由于Integer 和String 都继承自Object，因此可以通过简单的缩小转换将它们转换为相同的类型。

另一方面，在 C# 中，int 是原语，不会隐式转换为 string 或任何其他 object。