Non int implicite -> courte conversion dans la déclaration ternaire

Question

short s;
s = (EitherTrueOrFalse()) ? 0 : 1;

échoue avec:

  

CS0266 d'erreur: Impossible implicitement   convertir type « int » à « court ». Un   conversion explicite existe (êtes-vous   manque un casting?)

Quelqu'un peut-il expliquer pourquoi il en est ainsi? La seule chose que je peux penser est que le compilateur ne regarde pas la deuxième valeur et ne connaît pas la gamme entre les deux, dans le cas que j'ai écrit quelque chose comme

short s;
s = (EitherTrueOrFalse()) ? 0 : 65000;

Correct? La seule solution est avec un casting laid?

, il semble également C # ne dispose pas d'un suffixe de type pour le type court. C'est une surveillance assez graves OMI. Dans le cas contraire, cela aurait été une solution ...

Answer 1

Le compilateur a une conversion implicite d'un constante expression à divers types primitifs (tant que la valeur est dans la plage appropriée), mais ici l'expression est pas constante - il est juste un int expression. Il est à peu près la même chose que:

short s;
s = CallSomeMethodReturningInt32();

dans la mesure où le compilateur est concerné.

Il y a deux options - vous pourriez lancer toute expression, ou jeter chacun des deux derniers opérandes:

short s = (EitherTrueOrFalse()) ? (short) 0 : (short) 1;

pour le type d'ensemble d'expression short. Dans ce cas particulier, il est dommage qu'il n'y ait pas un suffixe littéral numérique de déclarer explicitement une short littérale. Apparemment, les concepteurs de langage ont bien examiné, mais ont estimé qu'il était une situation relativement rare. (Je pense que je serais probablement d'accord.)

La partie sur les conversions implicites constantes est de la section de spécification C # 3.0 6.1.8:

  

6.1.8 conversions d'expression constante Implicite

     

Une constante implicite   conversion d'expression permet de   suivant les conversions:

     

  
• A expression constante (§7.18) de type   int peut être convertie en type sbyte,   byte, short, ushort, uint ou ulong,   à condition que la valeur de la    expression constante est dans le   plage du type de destination.
  
• A    expression constante de type long peut   convertir au type ulong, à condition que   la valeur du expression constante   n'est pas négatif.
  

Answer 2

Parce que la cast est fait par le compilateur , pas à l'exécution, je ne dirais pas un casting laid, je l'appellerais une syntaxe compliquée:

s = (EitherTrueOrFalse()) ? (short)0 : (short)1;

Je veux dire, c'est la façon dont il est écrit en C #, même si elle est moche.

Voir cette article de blog . Voir la réponse Marc Gravell sur cette question.

Answer 3

Je suppose que cela a la même raison que cela ne compile pas:

short s1 = GetShort1();
short s2 = GetShort2();
short s3 = s1 + s2;

i.e.. que chaque fois court est utilisé pour quelque chose, il est promu int.