opérateur ternaires associativité en C # - je peux compter sur elle?

Question

Ahh, ne vous aimez pas juste un bon abus ternaire? :) Pensez à l'expression suivante:

true ? true : true ? false : false

Pour ceux d'entre vous qui sont maintenant tout à fait perplexes, je peux vous dire que ce évalue à true . En d'autres termes, il est équivalent à ceci:

true ? true : (true ? false : false)

Mais est-ce fiable? Puis-je être certain que, dans certaines circonstances, il ne viendra pas à ceci:

(true ? true : true) ? false : false

Certains pourraient dire - bien, il suffit d'ajouter des parenthèses ou alors ne l'utilisez pas tout à fait - après tout, il est un fait bien connu que les opérateurs ternaires sont mal

Bien sûr, ils sont, mais il y a des circonstances où ils font réellement sens. Pour les curieux - j'essorer le code qui compare deux objets par une série de propriétés. Il serait assez bien si je l'écris froid comme ceci:

obj1.Prop1 != obj2.Prop1 ? obj1.Prop1.CompareTo(obj2.Prop1) :
obj1.Prop2 != obj2.Prop2 ? obj1.Prop2.CompareTo(obj2.Prop2) :
obj1.Prop3 != obj2.Prop3 ? obj1.Prop3.CompareTo(obj2.Prop3) :
obj1.Prop4.CompareTo(obj2.Prop4)

claire et concise. Mais cela dépend de l'opérateur ternaire associativité travaillant comme dans le premier cas. Parenthèse serait tout simplement faire des spaghettis en sortir.

- est-ce spécifié nulle part? Je ne pouvais pas le trouver.

Answer 1

Oui, vous pouvez compter sur ce (non seulement en C #, mais en tout (que je connais) d'autres langues ( sauf PHP ... allez comprendre) avec un opérateur conditionnel) et votre cas d'utilisation est en fait une pratique assez courante bien que certaines personnes abhorrent.

La section appropriée dans ECMA-334 (la norme C #) est 14,13 §3:

  

L'opérateur conditionnel est droit associatif, ce qui signifie que les opérations sont groupées de droite à gauche.   [Exemple: Une expression de la forme a ? b : c ? d : e est évaluée comme a ? b : (c ? d : e). fin   par exemple]

Answer 2

Si vous devez demander, non. Toute personne lisant votre code sera juste passer par le même processus que vous avez fait, encore et encore, any temps que le code doit être regardé. Débogage tel code est pas amusant. Finalement, il vous reste plus qu'à changer d'utiliser des parenthèses de toute façon.

Re: "Essayez d'écrire la chose avec des parenthèses"

result = (obj1.Prop1 != obj2.Prop1 ? obj1.Prop1.CompareTo(obj2.Prop1) :
         (obj1.Prop2 != obj2.Prop2 ? obj1.Prop2.CompareTo(obj2.Prop2) :
         (obj1.Prop3 != obj2.Prop3 ? obj1.Prop3.CompareTo(obj2.Prop3) :
                                     obj1.Prop4.CompareTo(obj2.Prop4))))

Précision:

• "Si doivent demander, non."
• "lecture Quelqu'un votre code ..."

A la suite des conventions communes dans un projet est de savoir comment vous maintenir la cohérence, ce qui améliore la lisibilité. Il serait confié une mission d'un fou de penser que vous pouvez écrire un code lisible à tout le monde, y compris ceux qui ne connaissent même pas la langue!

Le maintien de la cohérence au sein d'un projet, cependant, est un objectif utile, et non suivant les conventions acceptées d'un projet conduit à un débat qui porte atteinte à la résolution du problème réel. Ceux qui lisent votre code devraient être au courant des conventions communes et acceptées utilisés dans le projet, et sont même susceptibles d'être quelqu'un d'autre travailler directement sur elle. S'ils ne les connaissent pas, ils devraient être leur apprentissage et doivent savoir où trouver de l'aide.

Cela dit, si l'utilisation d'expressions ternaires sans parenthèses est une convention commune et acceptée dans votre projet, utilisez-le, par tous les moyens! Que vous deviez demander indique qu'il est pas commun ou accepté dans votre projet. Si vous souhaitez modifier les conventions dans votre projet, puis faire la marque de toute évidence sans ambiguïté, vers le bas comme quelque chose à discuter avec les autres membres du projet, et de progresser. Ici, cela signifie que l'utilisation de parenthèses ou en utilisant if-else.

Un dernier point à méditer, si une partie de votre code semble intelligent pour vous:

  

Le débogage est deux fois plus dur que l'écriture du code en premier lieu. Par conséquent, si vous écrivez le code aussi intelligemment que possible, vous êtes, par définition, pas assez intelligent pour déboguer. - Brian W. Kernighan

Answer 3

L'affirmation selon laquelle les parenthèses nuire à la lisibilité du code est une hypothèse fausse. Je trouve l'expression beaucoup plus claire entre parenthèses. Personnellement, j'utiliser les parenthèses et / ou reformater sur plusieurs lignes pour améliorer la lisibilité. Reformatage sur plusieurs lignes et peut même en utilisant indenter éviter la nécessité de parenthèses. Et, oui, vous pouvez compter sur le fait que l'ordre d'association est déterministe, de droite à gauche. Cela permet l'expression d'évaluer gauche à droite de la façon attendue.

obj1.Prop1 != obj2.Prop1
     ? obj1.Prop1.CompareTo(obj2.Prop1)
     : obj1.Prop2 != obj2.Prop2
           ? obj1.Prop2.CompareTo(obj2.Prop2)
           : obj1.Prop3 != obj2.Prop3
                  ? obj1.Prop3.CompareTo(obj2.Prop3)
                  : obj1.Prop4.CompareTo(obj2.Prop4);

Answer 4

Reportez-vous à msdn: http://msdn.microsoft.com/en- nous / bibliothèque / ty67wk28% 28VS.80% 29.aspx

« Si la condition est vraie, la première expression est évaluée et devient le résultat;.. Si elle est fausse, la deuxième expression est évaluée et devient le seul résultat l'une des deux expressions est toujours évaluée »

Answer 5

x = cond1 ? result1
  : cond2 ? result2
  : cond3 ? result3
  : defaultResult;

vs

if (cond1) x = result1;
else if (cond2) x = result2;
else if (cond3) x = result3;
else x = defaultResult;

J'aime le premier.

Oui, vous pouvez compter sur associativité de l'opérateur conditionnel. Son dans le manuel, au lien aimablement fourni par dcp, a déclaré que « L'opérateur conditionnel est droit associatif », avec un exemple. Et, comme vous le suggérez et moi et autres étaient d'accord, le fait que vous pouvez compter sur elle autorise le code plus clair.