Diferença entre C # e operador ternário de Java (? :)

Sou um novato em C # e acabei de encontrar um problema. Há uma diferença entre C # e Java ao lidar com o operador ternário (? : ).

No segmento de código a seguir, por que a 4ª linha não funciona? O compilador mostra uma mensagem de erro de there is no implicit conversion between 'int' and 'string'. A 5ª linha não funciona tão bem. Ambos Listsão objetos, não são?

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

No entanto, o mesmo código funciona em 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

Qual recurso de linguagem está faltando no C #? Se houver, por que não foi adicionado?

Olhando através da seção 7.14 de especificação da linguagem C # 5: Operador condicional , podemos ver o seguinte:

• Se x tiver o tipo X e y tiver o tipo Y, então

  • Se uma conversão implícita (§6.1) existe de X para Y, mas não de Y para X, então Y é o tipo da expressão condicional.

  • Se uma conversão implícita (§6.1) existe de Y para X, mas não de X para Y, então X é o tipo da expressão condicional.

  • Caso contrário, nenhum tipo de expressão pode ser determinado e ocorre um erro em tempo de compilação

Em outras palavras: ele tenta descobrir se xey podem ou não ser convertidos um para o outro e se não, ocorre um erro de compilação. No nosso caso intestring não tem nenhuma conversão explícita ou implícita por isso não irá compilar.

Compare isso com a seção 15.25 da Especificação da linguagem Java 7: Operador condicional :

• Se o segundo e o terceiro operandos tiverem o mesmo tipo (que pode ser do tipo nulo), esse é o tipo da expressão condicional. ( NÃO )
• Se um dos segundo e terceiro operandos for do tipo primitivo T, e o tipo do outro for o resultado da aplicação da conversão de boxing (§5.1.7) para T, então o tipo da expressão condicional é T. ( NÃO )
• Se um dos segundo e terceiro operandos for do tipo nulo e o tipo do outro for um tipo de referência, então o tipo da expressão condicional é esse tipo de referência. ( NÃO )
• Caso contrário, se o segundo e o terceiro operandos têm tipos que são conversíveis (§5.1.8) para tipos numéricos, então há vários casos: ( NÃO )
• Caso contrário, o segundo e o terceiro operandos são dos tipos S1 e S2, respectivamente. Seja T1 o tipo que resulta da aplicação da conversão de boxe em S1 e seja T2 o tipo que resulta da aplicação de conversão de boxe em S2.
  O tipo da expressão condicional é o resultado da aplicação da conversão de captura (§5.1.10) para lub (T1, T2) (§15.12.2.7). ( SIM )

E, olhando a seção 15.12.2.7. Inferindo argumentos de tipo com base em argumentos reais , podemos ver que ele tenta encontrar um ancestral comum que servirá como o tipo usado para a chamada que o faz chegar Object. Object é um argumento aceitável para que a chamada funcione.

As respostas dadas são boas; Eu acrescentaria a eles que essa regra do C # é uma consequência de uma diretriz de design mais geral. Quando solicitado a inferir o tipo de uma expressão a partir de uma das várias opções, o C # escolhe a melhor delas . Ou seja, se você der ao C # algumas opções como "Girafa, Mamífero, Animal", ele pode escolher a mais geral - Animal - ou pode escolher a mais específica - Girafa - dependendo das circunstâncias. Mas ele deve escolher uma das escolhas que realmente foi dado . C # nunca diz "minhas escolhas são entre gato e cachorro, portanto, vou deduzir que Animal é a melhor escolha". Essa não foi uma escolha dada, então C # não pode escolhê-la.

No caso do operador ternário, C # tenta escolher o tipo mais geral de int e string, mas nenhum é o tipo mais geral. Em vez de escolher um tipo que não era uma escolha em primeiro lugar, como objeto, C # decide que nenhum tipo pode ser inferido.

Também observo que isso está de acordo com outro princípio de design do C #: se algo parecer errado, diga ao desenvolvedor. A linguagem não diz "Vou adivinhar o que você quis dizer e continuar confuso, se puder". A linguagem diz: "Acho que você escreveu algo confuso aqui e vou falar sobre isso".

Além disso, observo que C # não raciocina da variável para o valor atribuído , mas sim a outra direção. C # não diz "você está atribuindo a uma variável de objeto, portanto, a expressão deve ser conversível em objeto, portanto, certificarei que seja". Em vez disso, C # diz "esta expressão deve ter um tipo e devo ser capaz de deduzir que o tipo é compatível com o objeto". Como a expressão não possui um tipo, é produzido um erro.

Em relação à parte dos genéricos:

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

No C #, o compilador tenta converter as partes da expressão à direita em algum tipo comum; desde List<int>eList<string> são dois tipos construídos distintos, um não pode ser convertido no outro.

Em Java, o compilador tenta encontrar um supertipo comum em vez de converter, portanto, a compilação do código envolve o uso implícito de curingas e eliminação de tipo ;

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

tem o tipo de compilação de ArrayList<?>(na verdade, pode ser também ArrayList<? extends Serializable>ou ArrayList<? extends Comparable<?>>, dependendo do contexto de uso, uma vez que ambos são supertipos genéricos comuns) e o tipo de tempo de execução bruto ArrayList(já que é o supertipo bruto comum).

Por exemplo (teste você mesmo) ,

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

Em Java e C # (e na maioria das outras linguagens), o resultado de uma expressão tem um tipo. No caso do operador ternário, existem duas subexpressões possíveis avaliadas para o resultado e ambas devem ser do mesmo tipo. No caso do Java, uma intvariável pode ser convertida em Integerautoboxing. Agora, uma vez que ambos Integere Stringherdam de Object, eles podem ser convertidos para o mesmo tipo por uma conversão de estreitamento simples.

Por outro lado, em C #, an inté um primitivo e não há conversão implícita para stringou qualquer outro object.

Isso é muito simples. Não há conversão implícita entre string e int. o operador ternário precisa que os dois últimos operandos tenham o mesmo tipo.

Experimentar:

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