Perché posso passare 1 come breve, ma non la variabile int i?

Perché la prima e la seconda scrittura funzionano ma non l'ultima? Esiste un modo per consentirli tutti e 3 e rilevare se fosse 1, (int) 1 o se sono passato? E davvero perché uno è permesso ma l'ultimo? Il secondo è permesso ma non l'ultimo mi fa davvero impazzire.

Demo per mostrare l'errore di compilazione

using System;
class Program
{
    public static void Write(short v) { }
    static void Main(string[] args)
    {
        Write(1);//ok
        Write((int)1);//ok
        int i=1;
        Write(i);//error!?
    }
}

I primi due sono espressioni costanti, l'ultimo no.

La specifica C # consente una conversione implicita da int a short per le costanti, ma non per altre espressioni. Questa è una regola ragionevole, poiché per le costanti il ​​compilatore può garantire che il valore si adatti al tipo di destinazione, ma non per le espressioni normali.

Questa regola è in linea con le linee guida secondo cui le conversioni implicite dovrebbero essere senza perdita.

6.1.8 Conversioni implicite di espressioni costanti

Una conversione di espressione costante implicita consente le seguenti conversioni:

• Un'espressione-costante (§7.18) di tipo intpuò essere convertito nel tipo sbyte, byte, short, ushort, uint, oppure ulong, a condizione che il valore della costante espressione rientra nell'intervallo del tipo di destinazione.
• Una costante-espressione di tipo longpuò essere convertito nel tipo ulong, a condizione che il valore della costante espressione non è negativo.

(Citato da C # Language Specification Versione 3.0)

Non vi è alcuna conversione implicita da inta shortcausa della possibilità di troncamento. Tuttavia, un'espressione costante può essere trattata come di tipo target dal compilatore .

1? Non è un problema: è chiaramente un shortvalore valido . i? Non tanto - potrebbe essere un valore> short.MaxValueper esempio, e il compilatore non può verificarlo nel caso generale.

un int letterale può essere implicitamente convertito in short. Mentre:

Non è possibile convertire in modo implicito tipi numerici non letterali di dimensioni di archiviazione più grandi in brevi

Quindi, i primi due funzionano perché è consentita la conversione implicita di valori letterali.

Credo che sia perché stai passando una letterale / costante nei primi due, ma non c'è una conversione automatica del tipo quando passi un numero intero nel terzo.

Modifica: qualcuno mi ha battuto!

Perché non ci sarà alcuna conversione implicita tra tipo non letterale in short di dimensioni maggiori.

La conversione implicita è possibile solo per l'espressione costante.

public static void Write(short v) { }

Dove stai passando integervalore come argomentoshort

int i=1;
Write(i);  //Which is Nonliteral here

Il compilatore ti ha spiegato perché il codice fallisce:

cannot convert `int' expression to type `short'

Quindi, ecco la domanda che dovresti porre: perché questa conversione fallisce? Ho cercato su Google "c # convert int short" e sono finito sulla pagina MS C # per la shortparola chiave:

http://msdn.microsoft.com/en-us/library/ybs77ex4(v=vs.71).aspx

Come dice questa pagina, i cast impliciti da un tipo di dati più grande shortsono consentiti solo per i letterali. Il compilatore può dire quando un valore letterale è fuori portata, ma non diversamente, quindi ha bisogno di rassicurazione che hai evitato un errore fuori portata nella logica del tuo programma. Questa rassicurazione è fornita da un cast.

Write((short)i)

La conversione da int -> short potrebbe comportare il troncamento dei dati. Ecco perchè.