No int implicito -> breve conversione nella dichiarazione ternario

Question

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

Questo viene a mancare con:

  

Errore CS0266: Impossibile implicitamente   convertire il tipo 'int' a 'breve'. Un   Esiste conversione esplicita (sei   manca un cast?)

Qualcuno può spiegare perché è così? L'unica cosa che posso pensare è che il compilatore non guarda il secondo valore e non sa l'intervallo tra i due, nel caso che ho scritto qualcosa del tipo

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

Corretto? L'unica soluzione è un brutto cast?

Inoltre, sembra che C # non ha un tipo di suffisso per il tipo corto. Questo è un bel tomba svista IMO. In caso contrario, che sarebbe stata una soluzione di ...

Answer 1

Il compilatore ha una conversione implicita da un costante espressione di vari tipi primitivi (purché il valore rientra nell'intervallo appropriato), ma qui l'espressione non è costante - è solo un int espressione. E 'praticamente la stessa come:

short s;
s = CallSomeMethodReturningInt32();

per quanto riguarda il compilatore è interessato.

Ci sono due opzioni - si potrebbe lanciare l'intera espressione, o lanciare ciascuna delle ultime due operandi:

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

per fare il tipo di espressione short complessiva. In questo caso particolare, è un peccato che non ci sia un suffisso numerico letterale dichiarare esplicitamente un short letterale. A quanto pare i progettisti di linguaggi hanno considerato questo, ma ritenuto che fosse una situazione relativamente rara. (Penso che probabilmente sarei d'accordo.)

La parte sulle conversioni implicite costanti è dalla C # 3.0 sezione spec 6.1.8:

  

6.1.8 implicita La conversione espressione costante

     

Una costante implicita   conversione espressione permette   seguenti conversioni:

     

  
• A espressione-costante (§7.18) di tipo   int può essere convertito nel tipo sbyte,   byte, short, ushort, uint o ulong,   a condizione che il valore della    espressione-costante è all'interno della   gamma del tipo di destinazione.
  
• A    espressione-costante di tipo long può   essere convertita nel tipo ulong, a condizione   il valore della espressione-costante   non è negativo.
  

Answer 2

Perché la Cast è fatto dal compilatore , non in fase di esecuzione, non vorrei chiamarlo un brutto cast, la definirei una sintassi complicata:

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

Voglio dire, questo è il modo in cui è scritto in C #, anche se sembra brutto.

Vedere questo articolo di blog . Vedi di Marc Gravell risposta su tale questione.

Answer 3

Credo che questo abbia la stessa ragione di questo non compilerà:

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

vale a dire. che ogni volta che breve è utilizzato per qualcosa, viene promosso a int.