Por que posso passar 1 como uma variável curta, mas não a variável int i?

Por que a primeira e a segunda gravação funcionam, mas não a última? Existe uma maneira de permitir todos os 3 e detectar se foi 1, (int) 1 ou eu passei? E realmente por que um é permitido, mas o último? O segundo sendo permitido, mas não o último, realmente me impressiona.

Demonstração para mostrar erro de compilação

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!?
    }
}

Os dois primeiros são expressões constantes, o último não.

A especificação C # permite uma conversão implícita de int para abreviação de constantes, mas não para outras expressões. Essa é uma regra razoável, pois para constantes, o compilador pode garantir que o valor se encaixe no tipo de destino, mas não para expressões normais.

Esta regra está alinhada com a diretriz de que conversões implícitas devem ser sem perdas.

6.1.8 Conversões implícitas de expressão constante

Uma conversão implícita de expressão constante permite as seguintes conversões:

• Uma expressão constante (§7.18) de tipo intpode ser convertido no tipo sbyte, byte, short, ushort, uint, ou ulong, desde que o valor da constante de expressão está dentro do intervalo do tipo de destino.
• Uma expressão constante do tipo longpode ser convertida em tipo ulong, desde que o valor da expressão constante não seja negativo.

(Citado em C # Language Specification versão 3.0)

Não há conversão implícita de intpara shortdevido à possibilidade de truncamento. No entanto, uma expressão constante pode ser tratada como sendo do tipo de destino pelo compilador .

1? Não é um problema: é claramente um shortvalor válido . i? Nem tanto - pode haver algum valor> short.MaxValuepor exemplo, e o compilador não pode verificar isso no caso geral.

um int literal pode ser implicitamente convertido em short. Enquanto que:

Você não pode converter implicitamente tipos numéricos não literais de tamanho de armazenamento maior para curto

Portanto, os dois primeiros funcionam porque a conversão implícita de literais é permitida.

Eu acredito que é porque você está passando literal / constante nos dois primeiros, mas não há conversão automática de tipo ao passar um número inteiro no terceiro.

Edit: Alguém me venceu a isso!

Porque não haverá conversão implícita entre o tipo Não Literal e o tamanho menor .

A conversão implícita é possível apenas para expressão constante.

public static void Write(short v) { }

Onde você está passando integervalor como argumento parashort

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

O compilador lhe disse por que o código falha:

cannot convert `int' expression to type `short'

Então, eis a pergunta que você deve fazer: por que essa conversão falha? Pesquisei "c # convert int short" e acabei na página do MS C # da shortpalavra-chave:

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

Como diz esta página, as transmissões implícitas de um tipo de dados maior shortsão permitidas apenas para literais. O compilador pode dizer quando um literal está fora do intervalo, mas não o contrário, portanto, é necessário garantir que você evitou um erro fora do intervalo na lógica do programa. Essa garantia é fornecida por um elenco.

Write((short)i)

A conversão de int -> short pode resultar em truncamento de dados. É por isso.