Différence entre C # et l'opérateur ternaire de Java (? :)

Je suis un débutant en C # et je viens de rencontrer un problème. Il y a une différence entre C # et Java lorsqu'il s'agit de l'opérateur ternaire ( ? :).

Dans le segment de code suivant, pourquoi la 4ème ligne ne fonctionne-t-elle pas? Le compilateur affiche un message d'erreur de there is no implicit conversion between 'int' and 'string'. La 5ème ligne ne fonctionne pas aussi bien. Les deux Listsont des objets, n'est-ce pas?

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

Cependant, le même code fonctionne 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

Quelle fonctionnalité de langage en C # est manquante? Le cas échéant, pourquoi n'est-il pas ajouté?

En parcourant la section 7.14 de la spécification du langage C # 5: Opérateur conditionnel, nous pouvons voir ce qui suit:

• Si x a le type X et y le type Y alors

  • S'il existe une conversion implicite (§6.1) de X en Y, mais pas de Y en X, alors Y est le type de l'expression conditionnelle.

  • S'il existe une conversion implicite (§6.1) de Y en X, mais pas de X en Y, alors X est le type de l'expression conditionnelle.

  • Sinon, aucun type d'expression ne peut être déterminé et une erreur de compilation se produit

En d' autres termes: il essaie de trouver si oui ou non x et y peuvent être convertis en eachother et sinon, une erreur de compilation se produit. Dans notre cas intet stringn'ont pas de conversion explicite ou implicite donc il ne se compilera pas.

Comparez cela avec la section 15.25 de la spécification du langage Java 7: Opérateur conditionnel :

• Si les deuxième et troisième opérandes ont le même type (qui peut être le type nul), alors c'est le type de l'expression conditionnelle. ( NON )
• Si l'un des deuxième et troisième opérandes est de type primitif T, et que le type de l'autre est le résultat de l'application de la conversion boxing (§5.1.7) en T, alors le type de l'expression conditionnelle est T. ( NON )
• Si l'un des deuxième et troisième opérandes est de type nul et que le type de l'autre est un type référence, le type de l'expression conditionnelle est ce type référence. ( NON )
• Sinon, si les deuxième et troisième opérandes ont des types convertibles (§5.1.8) en types numériques, alors il y a plusieurs cas: ( NON )
• Sinon, les deuxième et troisième opérandes sont respectivement de types S1 et S2. Soit T1 le type qui résulte de l'application de la conversion de boxe à S1, et soit T2 le type qui résulte de l'application de la conversion de boxe à S2.
  Le type de l'expression conditionnelle est le résultat de l'application de la conversion de capture (§5.1.10) en lub (T1, T2) (§15.12.2.7). ( OUI )

Et, en regardant la section 15.12.2.7. Inférence d'arguments de type basés sur des arguments réels, nous pouvons voir qu'il essaie de trouver un ancêtre commun qui servira de type utilisé pour l'appel avec lequel il aboutitObject . Object est un argument acceptable pour que l'appel fonctionne.

Les réponses données sont bonnes; J'ajouterais que cette règle de C # est une conséquence d'une directive de conception plus générale. Lorsqu'on lui a demandé de déduire le type d'une expression à partir de l'un des nombreux choix, C # choisit le meilleur d'entre eux . Autrement dit, si vous donnez à C # des choix tels que "Girafe, Mammifère, Animal", il peut choisir le plus général - Animal - ou il peut choisir le plus spécifique - Girafe - selon les circonstances. Mais il doit choisir l' un des choix qui lui a été fait . C # ne dit jamais "mes choix sont entre le chat et le chien, donc je vais en déduire que l'animal est le meilleur choix". Ce n'était pas un choix donné, donc C # ne peut pas le choisir.

Dans le cas de l'opérateur ternaire, C # essaie de choisir le type le plus général d'int et de chaîne, mais le type le plus général n'est pas non plus. Plutôt que de choisir un type qui n'était pas un choix en premier lieu, comme object, C # décide qu'aucun type ne peut être déduit.

Je note également que cela est conforme à un autre principe de conception de C #: si quelque chose ne va pas, dites-le au développeur. Le langage ne dit pas "Je vais deviner ce que vous vouliez dire et me débrouiller si je peux". Le langage dit "Je pense que vous avez écrit quelque chose de déroutant ici, et je vais vous en parler."

De plus, je note que C # ne raisonne pas de la variable à la valeur assignée , mais plutôt dans l'autre sens. C # ne dit pas "vous assignez à une variable objet donc l'expression doit être convertible en objet, donc je vais m'assurer que c'est". Au contraire, C # dit "cette expression doit avoir un type, et je dois être capable de déduire que le type est compatible avec object". Comme l'expression n'a pas de type, une erreur est générée.

Concernant la partie génériques:

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

En C #, le compilateur essaie de convertir les parties d'expression de droite en un type commun; puisque List<int>et List<string>sont deux types construits distincts, l'un ne peut pas être converti en l'autre.

En Java, le compilateur essaie de trouver un supertype commun au lieu de le convertir, donc la compilation du code implique l'utilisation implicite de caractères génériques et l' effacement de type ;

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

a le type de compilation de ArrayList<?> (en fait, cela peut être aussi ArrayList<? extends Serializable>ou ArrayList<? extends Comparable<?>>, selon le contexte d'utilisation, car ils sont tous les deux des supertypes génériques communs) et le type d'exécution de raw ArrayList(puisque c'est le supertype raw commun).

Par exemple (testez-le vous-même) ,

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

En Java et C # (et dans la plupart des autres langages), le résultat d'une expression a un type. Dans le cas de l'opérateur ternaire, il existe deux sous-expressions possibles évaluées pour le résultat et les deux doivent avoir le même type. Dans le cas de Java, une intvariable peut être convertie en un Integerpar autoboxing. Maintenant, puisque les deux Integeret Stringhéritent de Object, ils peuvent être convertis au même type par une simple conversion de rétrécissement.

Par contre, en C #, an intest une primitive et il n'y a pas de conversion implicite enstring ou autre object.

C'est assez simple. Il n'y a pas de conversion implicite entre string et int. l'opérateur ternaire a besoin que les deux derniers opérandes aient le même type.

Essayer:

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