Diferencia entre C # y el operador ternario de Java (? :)

Soy un novato de C # y acabo de encontrar un problema. Existe una diferencia entre C # y Java cuando se trata del operador ternario ( ? :).

En el siguiente segmento de código, ¿por qué no funciona la cuarta línea? El compilador muestra un mensaje de error de there is no implicit conversion between 'int' and 'string'. La quinta línea no funciona tan bien. Ambos Listson objetos, ¿no?

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

Sin embargo, el mismo código funciona en 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

¿Qué característica de lenguaje en C # falta? Si existe, ¿por qué no se agrega?

Mirando a través de la sección 7.14 de la Especificación del lenguaje C # 5: Operador condicional , podemos ver lo siguiente:

• Si x tiene el tipo X e y tiene el tipo Y, entonces

  • Si existe una conversión implícita (§6.1) de X a Y, pero no de Y a X, entonces Y es el tipo de expresión condicional.

  • Si existe una conversión implícita (§6.1) de Y a X, pero no de X a Y, entonces X es el tipo de expresión condicional.

  • De lo contrario, no se puede determinar ningún tipo de expresión y se produce un error en tiempo de compilación.

En otras palabras: trata de encontrar si xey se pueden convertir entre sí o no y, de no ser así, se produce un error de compilación. En nuestro caso int, y stringno tienen la conversión explícita o implícita por lo que no se compilará.

Compare esto con la sección 15.25 de la Especificación del lenguaje Java 7: Operador condicional :

• Si el segundo y tercer operandos tienen el mismo tipo (que puede ser el tipo nulo), ese es el tipo de expresión condicional. ( NO )
• Si uno de los operandos segundo y tercero es de tipo primitivo T, y el tipo del otro es el resultado de aplicar conversión de boxeo (§5.1.7) a T, entonces el tipo de expresión condicional es T. ( NO )
• Si uno de los operandos segundo y tercero es de tipo nulo y el tipo del otro es un tipo de referencia, entonces el tipo de la expresión condicional es ese tipo de referencia. ( NO )
• De lo contrario, si el segundo y tercer operandos tienen tipos que son convertibles (§5.1.8) a tipos numéricos, entonces hay varios casos: ( NO )
• De lo contrario, el segundo y tercer operandos son de los tipos S1 y S2 respectivamente. Sea T1 el tipo que resulta de aplicar la conversión de boxeo a S1, y sea T2 el tipo que resulta de aplicar la conversión de boxeo a S2.
  El tipo de expresión condicional es el resultado de aplicar la conversión de captura (§5.1.10) a lub (T1, T2) (§15.12.2.7). ( SI )

Y, mirando la sección 15.12.2.7. Inferir argumentos de tipo basados ​​en argumentos reales , podemos ver que intenta encontrar un ancestro común que sirva como el tipo utilizado para la llamada con la que aterriza Object. Object es un argumento aceptable para que la llamada funcione.

Las respuestas dadas son buenas; Les agregaría que esta regla de C # es una consecuencia de una guía de diseño más general. Cuando se le pide que infiera el tipo de expresión a partir de una de varias opciones, C # elige la mejor de ellas . Es decir, si le da a C # algunas opciones como "Jirafa, Mamífero, Animal", entonces podría elegir la más general - Animal - o podría elegir la más específica - Jirafa - dependiendo de las circunstancias. Pero debe elegir una de las opciones que realmente se le dieron . C # nunca dice "mis opciones son entre gato y perro, por lo tanto, deduciré que Animal es la mejor opción". Esa no fue una opción dada, por lo que C # no puede elegirla.

En el caso del operador ternario, C # intenta elegir el tipo más general de int y string, pero tampoco el tipo más general. En lugar de elegir un tipo que no era una opción en primer lugar, como object, C # decide que no se puede inferir ningún tipo.

También observo que esto está de acuerdo con otro principio de diseño de C #: si algo parece mal, dígaselo al desarrollador. El lenguaje no dice "Voy a adivinar lo que quisiste decir y seguir adelante si puedo". El lenguaje dice "Creo que has escrito algo confuso aquí, y te lo voy a contar".

Además, observo que C # no razona de la variable de hasta el valor asignado , sino más bien la otra dirección. C # no dice "estás asignando a una variable de objeto, por lo tanto, la expresión debe ser convertible en objeto, por lo tanto, me aseguraré de que lo sea". Más bien, C # dice que "esta expresión debe tener un tipo, y debo poder deducir que el tipo es compatible con el objeto". Dado que la expresión no tiene tipo, se produce un error.

Respecto a la parte de genéricos:

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

En C #, el compilador intenta convertir las partes de expresión de la derecha a algún tipo común; dado que List<int>y List<string>son dos tipos construidos distintos, uno no se puede convertir en el otro.

En Java, el compilador intenta encontrar un supertipo común en lugar de convertir, por lo que la compilación del código implica el uso implícito de comodines y borrado de tipos ;

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

tiene el tipo de compilación de ArrayList<?>(en realidad, puede ser también ArrayList<? extends Serializable>o ArrayList<? extends Comparable<?>>, dependiendo del contexto de uso, ya que ambos son supertipos genéricos comunes) y el tipo de tiempo de ejecución de raw ArrayList(ya que es el supertipo raw común).

Por ejemplo (pruébelo usted mismo) ,

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

Tanto en Java como en C # (y la mayoría de los otros lenguajes), el resultado de una expresión tiene un tipo. En el caso del operador ternario, existen dos posibles subexpresiones evaluadas para el resultado y ambas deben tener el mismo tipo. En el caso de Java, una intvariable se puede convertir en un Integerautoboxing. Ahora, dado que ambos Integery Stringheredan Object, se pueden convertir al mismo tipo mediante una simple conversión de restricción.

Por otro lado, en C #, an intes una primitiva y no hay conversión implícita a stringni ninguna otra object.

Esto es bastante sencillo. No hay conversión implícita entre string e int. el operador ternario necesita que los dos últimos operandos tengan el mismo tipo.

Tratar:

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