Partilhar via

10 Conversões

  • Artigo

10.1 Generalidades

Uma conversão faz com que uma expressão seja convertida ou tratada como sendo de um tipo particular, no primeiro caso, uma conversão pode envolver uma mudança na representação. As conversões podem ser implícitas ou explícitas, e isso determina se um elenco explícito é necessário.

Exemplo: Por exemplo, a conversão de tipo int para tipo long é implícita, de modo que expressões de tipo int podem ser implicitamente tratadas como tipo long. A conversão oposta, de tipo long para tipo int, é explícita e, portanto, um elenco explícito é necessário.

int a = 123;
long b = a;      // implicit conversion from int to long
int c = (int) b; // explicit conversion from long to int

Exemplo final

Algumas conversões são definidas pelo idioma. Os programas também podem definir suas próprias conversões (§10.5).

Algumas conversões na linguagem são definidas de expressões para tipos, outras de tipos para tipos. Uma conversão de um tipo aplica-se a todas as expressões que têm esse tipo.

Exemplo:

enum Color { Red, Blue, Green }

// The expression 0 converts implicitly to enum types
Color c0 = 0;

// Other int expressions need explicit conversion
Color c1 = (Color)1;

// Conversion from null expression (no type) to string
string x = null;

// Conversion from lambda expression to delegate type
Func<int, int> square = x => x * x;

Exemplo final

10.2 Conversões implícitas

10.2.1 Generalidades

As seguintes conversões são classificadas como conversões implícitas:

  • Conversões de identidade (§10.2.2)
  • Conversões numéricas implícitas (§10.2.3)
  • Conversões de enumeração implícitas (§10.2.4)
  • Conversões de cadeia de caracteres interpoladas implícitas (§10.2.5)
  • Conversões de referência implícitas (§10.2.8)
  • Conversões de boxe (§10.2.9)
  • Conversões dinâmicas implícitas (§10.2.10)
  • Conversões implícitas de parâmetros de tipo (§10.2.12)
  • Conversões implícitas de expressões constantes (§10.2.11)
  • Conversões implícitas definidas pelo utilizador (incluindo levantadas) (§10.2.14)
  • Conversões de funções anónimas (§10.2.15)
  • Conversões de grupos de métodos (§10.2.15)
  • Conversões literais nulas (§10.2.7)
  • Conversões implícitas anuláveis (§10.2.6)
  • Conversões implícitas de tuplas (§10.2.13)
  • Conversões literais padrão (§10.2.16)
  • Conversões de lançamento implícitas (§10.2.17)

As conversões implícitas podem ocorrer em uma variedade de situações, incluindo invocações de membros de funções (§12.6.6), expressões de elenco (§12.9.7) e atribuições (§12.21).

As conversões implícitas pré-definidas sempre são bem-sucedidas e nunca fazem com que exceções sejam lançadas.

Nota: Conversões implícitas definidas pelo usuário adequadamente projetadas também devem exibir essas características. Nota final

Para efeitos de conversão, os tipos object e são convertíveis de identidade (dynamic).

No entanto, as conversões dinâmicas (§10.2.10) aplicam-se apenas a expressões de tipo dynamic (§8.2.4).

10.2.2 Conversão de identidade

Uma conversão de identidade converte de qualquer tipo para o mesmo tipo ou um tipo que é equivalente em tempo de execução. Uma razão pela qual esta conversão existe é para que um tipo T ou uma expressão de tipo T possa ser considerado convertível para T si mesmo. Existem as seguintes conversões de identidade:

  • Entre T e T, para qualquer tipo T.
  • Entre T e T? para qualquer tipo de referência T.
  • Entre object e dynamic.
  • Entre todos os tipos de tupla com a mesma aridade, e o tipo construído ValueTuple<...> correspondente, quando existe uma conversão de identidade entre cada par de tipos de elementos correspondentes.
  • Entre tipos construídos a partir do mesmo tipo genérico onde existe uma conversão de identidade entre cada argumento de tipo correspondente.

Exemplo: O seguinte ilustra a natureza recursiva da terceira regra:

(int a , string b) t1 = (1, "two");
(int c, string d) t2 = (3, "four");

// Identity conversions exist between
// the types of t1, t2, and t3.
var t3 = (5, "six");
t3 = t2;
t2 = t1;

var t4 = (t1, 7);
var t5 = (t2, 8);

// Identity conversions exist between
// the types of t4, t5, and t6.
var t6 =((8, "eight"), 9);
t6 = t5;
t5 = t4;

Os tipos de tuplas t1, t2 e t3 todos têm dois elementos: um int seguido por um string. Os tipos de elementos tuplas podem ser feitos por tuplas, como em t4, t5, e t6. Existe uma conversão de identidade entre cada par de tipos de elementos correspondentes, incluindo tuplas aninhadas, portanto, existe uma conversão de identidade entre os tipos de tuplas t4, t5e t6.

Exemplo final

Todas as conversões de identidade são simétricas. Se existir uma conversão de identidade de T₁ para T₂, então existe uma conversão de T₂ identidade de para T₁. Dois tipos são conversíveis de identidade quando existe uma conversão de identidade entre dois tipos.

Na maioria dos casos, uma conversão de identidade não tem efeito em tempo de execução. No entanto, uma vez que as operações de ponto flutuante podem ser realizadas com uma precisão superior à prescrita pelo seu tipo (§8.3.7), a atribuição dos seus resultados pode resultar numa perda de precisão, e é garantido que os moldes explícitos reduzam a precisão ao prescrito pelo tipo (§12.9.7).

10.2.3 Conversões numéricas implícitas

As conversões numéricas implícitas são:

  • De sbyte , shortint, long, float, double, ou decimal.
  • De byte , shortushort, , int, uint, long, ulongfloatdoubleou .decimal
  • De short , intlong, float, double, ou decimal.
  • De ushort , intuint, long, , ulongfloat, double, ou decimal.
  • De int , , longfloatdouble, ou .decimal
  • De uint , longulong, float, double, ou decimal.
  • De long , , floatdoubleou decimal.
  • De ulong , , floatdoubleou decimal.
  • De char , ushortint, , uint, long, ulongfloat, double, ou decimal.
  • De float a double.

Conversões de int, uintou longulong para float e de long ou para ulong podem double causar uma perda de precisão, mas nunca causarão uma perda de magnitude. As outras conversões numéricas implícitas nunca perdem nenhuma informação.

Não há conversões implícitas predefinidas para o char tipo, portanto, os valores dos outros tipos integrais não são convertidos automaticamente para o char tipo.

10.2.4 Conversões de enumeração implícitas

Uma conversão de enumeração implícita permite que um constant_expression (§12.23) com qualquer tipo inteiro e o valor zero seja convertido em qualquer enum_type e em qualquer nullable_value_type cujo tipo subjacente seja um enum_type. Neste último caso, a conversão é avaliada convertendo para o enum_type subjacente e envolvendo o resultado (§8.3.12).

10.2.5 Conversões implícitas de cadeias interpoladas

Uma conversão de cadeia de caracteres interpolada implícita permite que um interpolated_string_expression (§12.8.3) seja convertido em ou System.IFormattable (que implementa System.FormattableString).System.IFormattable Quando essa conversão é aplicada, um valor de cadeia de caracteres não é composto a partir da cadeia de caracteres interpolada. Em vez disso, é criada uma instância de System.FormattableString , conforme descrito mais detalhadamente no §12.8.3.

10.2.6 Conversões implícitas anuláveis

As conversões anuláveis implícitas são aquelas conversões anuláveis (§10.6.1) derivadas de conversões implícitas predefinidas.

10.2.7 Conversões literais nulas

Existe uma conversão implícita do null literal para qualquer tipo de referência ou tipo de valor anulável. Esta conversão produz uma referência nula se o tipo de destino for um tipo de referência, ou o valor nulo (§8.3.12) do tipo de valor nulo dado.

10.2.8 Conversões de referência implícitas

As conversões de referência implícitas são:

  • De qualquer reference_type para object e dynamic.
  • De qualquer class_typeS a qualquer class_typeT, desde que S derive de T.
  • De qualquer class_typeS a qualquer T, implementos fornecidos ST.
  • De qualquer interface_typeS a qualquer T , desde que seja derivado S de T.
  • De um S com um tipo Sᵢ de elemento para um array_typeT com um tipo Tᵢde elemento , desde que todos os itens a seguir sejam verdadeiros:
    • S e T diferem apenas no tipo de elemento. Por outras palavras, S e T têm o mesmo número de dimensões.
    • Existe uma conversão de referência implícita de Sᵢ para Tᵢ.
  • De um tipo S[] de matriz unidimensional para System.Collections.Generic.IList<T>, System.Collections.Generic.IReadOnlyList<T>e suas interfaces base, desde que haja uma identidade implícita ou conversão de referência de S para T.
  • De qualquer array_type para System.Array e as interfaces que implementa.
  • De qualquer delegate_type para System.Delegate e as interfaces que implementa.
  • Do literal nulo (§6.4.5.7) a qualquer tipo de referência.
  • De qualquer T
  • De qualquer reference_type para um tipo T de interface ou delegado, se tiver uma identidade implícita ou conversão de referência para um tipo de interface ou delegado T₀ e T₀ for conversível em variação (§18.2.3.3) para T.
  • Conversões implícitas envolvendo parâmetros de tipo que são conhecidos por serem tipos de referência. Ver §10.2.12 para obter mais detalhes sobre conversões implícitas envolvendo parâmetros de tipo.

As conversões de referência implícitas são aquelas conversões entre reference_types que podem ser comprovadamente sempre bem-sucedidas e, portanto, não exigem verificações em tempo de execução.

As conversões de referência, implícitas ou explícitas, nunca alteram a identidade referencial do objeto que está sendo convertido.

Nota: Em outras palavras, embora uma conversão de referência possa alterar o tipo da referência, ela nunca altera o tipo ou o valor do objeto que está sendo referido. Nota final

10.2.9 Conversões de boxe

Uma conversão de boxe permite que um value_type seja implicitamente convertido em reference_type. Existem as seguintes conversões de boxe:

  • De qualquer value_type para o tipo object.
  • De qualquer value_type para o tipo System.ValueType.
  • De qualquer enum_type para o tipo System.Enum.
  • De qualquer non_nullable_value_type a qualquer interface_type implementado pelo non_nullable_value_type.
  • De qualquer I
  • De qualquer non_nullable_value_type para qualquer I tal que haja uma conversão de boxe do non_nullable_value_type para outro interface_typeI₀e I₀ seja conversível em variação (§18.2.3.3) para I.
  • De qualquer nullable_value_type para qualquer reference_type onde haja uma conversão de boxe do tipo subjacente do nullable_value_type para o reference_type.
  • De um parâmetro de tipo que não se sabe ser um tipo de referência para qualquer tipo tal que a conversão é permitida pelo §10.2.12.

Boxar um valor de um tipo de valor não anulável consiste em alocar uma instância de objeto e copiar o valor para essa instância.

Boxar um valor de um nullable_value_type produz uma referência nula se for o valor nulo (HasValue is false) ou o resultado de desempacotar e encaixotar o valor subjacente de outra forma.

Nota: O processo de boxe pode ser imaginado em termos da existência de uma classe de boxe para cada tipo de valor. Por exemplo, considere implementar struct S uma interface I, com uma classe de boxe chamada S_Boxing.

interface I
{
    void M();
}

struct S : I
{
    public void M() { ... }
}

sealed class S_Boxing : I
{
    S value;

    public S_Boxing(S value)
    {
        this.value = value;
    }

    public void M()
    {
        value.M();
    }
}

Boxar um valor v do tipo S agora consiste em executar a expressão new S_Boxing(v) e retornar a instância resultante como um valor do tipo de destino da conversão. Assim, as declarações

S s = new S();
object box = s;

pode ser pensado como semelhante a:

S s = new S();
object box = new S_Boxing(s);

O tipo de boxe imaginado descrito acima não existe. Em vez disso, um valor in a box do tipo S tem o tipo Sde tempo de execução , e uma verificação de tipo de tempo de execução usando o is operador com um tipo de valor como o operando direito testa se o operando esquerdo é uma versão em caixa do operando direito. Por exemplo,

int i = 123;
object box = i;
if (box is int)
{
    Console.Write("Box contains an int");
}

produzirá o seguinte:

Box contains an int

Uma conversão de boxe implica fazer uma cópia do valor que está sendo encaixotado. Isso é diferente de uma conversão de um reference_type para tipo object, em que o valor continua a fazer referência à mesma instância e simplesmente é considerado como o tipo objectmenos derivado. Por exemplo, o seguinte

struct Point
{
    public int x, y;

    public Point(int x, int y)
    {
        this.x = x;
        this.y = y;
    }
}

class A
{
    void M() 
    {
        Point p = new Point(10, 10);
        object box = p;
        p.x = 20;
        Console.Write(((Point)box).x);
    }
}

produzirá o valor 10 no console porque a operação de boxe implícita que ocorre na atribuição de p para box faz com que o valor de p seja copiado. Se tivesse Point sido declarado um class em vez disso, o valor 20 seria saída porque p e box faria referência à mesma instância.

A analogia de uma aula de boxe não deve ser usada como mais do que uma ferramenta útil para imaginar como o boxe funciona conceitualmente. Existem inúmeras diferenças sutis entre o comportamento descrito por esta especificação e o comportamento que resultaria de o boxe ser implementado exatamente dessa maneira.

Nota final

10.2.10 Conversões dinâmicas implícitas

Existe uma conversão dinâmica implícita de uma expressão de tipo dinâmico para qualquer tipo T. A conversão é dinamicamente vinculada § 12.3.3, o que significa que uma conversão implícita será procurada em tempo de execução do tipo de tempo de execução da expressão para T. Se nenhuma conversão for encontrada, uma exceção em tempo de execução será lançada.

Esta conversão implícita aparentemente viola o conselho no início do §10.2 de que uma conversão implícita nunca deve causar uma exceção. No entanto, não é a conversão em si, mas a constatação da conversão que causa a exceção. O risco de exceções em tempo de execução é inerente ao uso da vinculação dinâmica. Se a ligação dinâmica da conversão não for desejada, a expressão pode ser primeiro convertida para object, e depois para o tipo desejado.

Exemplo: O seguinte ilustra conversões dinâmicas implícitas:

object o = "object";
dynamic d = "dynamic";
string s1 = o;         // Fails at compile-time – no conversion exists
string s2 = d;         // Compiles and succeeds at run-time
int i = d;             // Compiles but fails at run-time – no conversion exists

As atribuições para s2 e i ambas empregam conversões dinâmicas implícitas, onde a vinculação das operações é suspensa até o tempo de execução. Em tempo de execução, conversões implícitas são procuradas do tipo de tempo de execução de (d) para o tipo de stringdestino. Uma conversão é encontrada para string , mas não para int.

Exemplo final

10.2.11 Conversões implícitas de expressões constantes

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

  • Uma constant_expression (§12.23ulong
  • Uma constant_expression de tipo pode ser convertida em tipolong, desde que o ulong não seja negativo.

10.2.12 Conversões implícitas envolvendo parâmetros de tipo

Para um type_parameterT conhecido por ser um tipo de referência (§15.2.5), existem as seguintes conversões de referência implícitas (§10.2.8):

  • De T para sua classe Cbase efetiva, de T qualquer classe base de , e de C qualquer interface implementada Tpela C.
  • De T um interface_type I no Tconjunto de interfaces efetivo do e de T qualquer interface base do .I
  • De para um parâmetro de T tipo, desde que U dependa de T (U).

    Nota: Uma vez que T é conhecido por ser um tipo de referência, dentro do âmbito do T, o tipo de tempo de execução de será sempre um tipo de referência, mesmo que U não seja conhecido por ser um tipo de U referência em tempo de compilação. Nota final

  • Do literal nulo (§6.4.5.7) a T.

Para um T que não é conhecido por ser um tipo de referência §15.2.5, as seguintes conversões envolvendo T são consideradas conversões de boxe (§10.2.9) em tempo de compilação. Em tempo de execução, se T for um tipo de valor, a conversão é executada como uma conversão de boxe. Em tempo de execução, se T for um tipo de referência, a conversão é executada como uma conversão de referência implícita ou conversão de identidade.

  • De T para sua classe Cbase efetiva, de T qualquer classe base de , e de C qualquer interface implementada Tpela C.

    Nota: C será um dos tipos System.Object, System.ValueTypeou System.Enum (caso contrário T seria conhecido por ser um tipo de referência). Nota final

  • De T um interface_type I no Tconjunto de interfaces efetivo do e de T qualquer interface base do .I

Para um T que não é conhecido por ser um tipo de referência, há uma conversão implícita de para um parâmetro T de U tipo fornecido T depende de U. Em tempo de execução, se T for um tipo de valor e U for um tipo de referência, a conversão será executada como uma conversão de boxe. Em tempo de execução, se ambos T e U são tipos de valor, então T e U são necessariamente o mesmo tipo e nenhuma conversão é executada. Em tempo de execução, se T é um tipo de referência, então U é necessariamente também um tipo de referência e a conversão é executada como uma conversão de referência implícita ou conversão de identidade (§15.2.5).

Existem as seguintes conversões implícitas adicionais para um determinado parâmetro Tde tipo:

  • De para um tipo de T referência se tiver uma conversão implícita para um tipo S de referência e S₀ tiver uma conversão de identidade para S₀S . Em tempo de execução, a conversão é executada da mesma forma que a conversão para S₀.
  • De para um tipo de T interface, se tiver uma conversão implícita para um tipo Ide interface, e I₀ for convertível em variância (I₀I). Em tempo de execução, se T for um tipo de valor, a conversão é executada como uma conversão de boxe. Caso contrário, a conversão é executada como uma conversão de referência implícita ou conversão de identidade.

Em todos os casos, as regras garantem que uma conversão seja executada como uma conversão de boxe se e somente se, em tempo de execução, a conversão for de um tipo de valor para um tipo de referência.

10.2.13 Conversões implícitas de tuplas

Existe uma conversão implícita de uma expressão E de tupla para um tipo T de tupla se E tiver a mesma aridade T que e existe uma conversão implícita de cada elemento em E para o tipo de elemento correspondente em T. A conversão é realizada criando uma instância do tipo correspondente T de System.ValueTuple<...>', e inicializando cada um de seus campos em ordem da esquerda para a direita, avaliando a expressão correspondente do elemento de tupla de E, convertendo-o para o tipo de elemento correspondente usando T a conversão implícita encontrada, e inicializando o campo com o resultado.

Se o nome de um elemento na expressão da tupla não corresponder a um nome de elemento correspondente no tipo de tupla, deve ser emitido um aviso.

Exemplo:

(int, string) t1 = (1, "One");
(byte, string) t2 = (2, null);
(int, string) t3 = (null, null);        // Error: No conversion
(int i, string s) t4 = (i: 4, "Four");
(int i, string) t5 = (x: 5, s: "Five"); // Warning: Names are ignored

As declarações de , t1t2 e t4 são todas válidas, uma vez que existem conversões implícitas das expressões de elemento para os tipos de t5elementos correspondentes. A declaração de t3 é inválida, porque não há conversão de null para int. A declaração de causa um aviso porque os nomes dos elementos na expressão da tupla diferem daqueles no tipo de t5 tupla.

Exemplo final

10.2.14 Conversões implícitas definidas pelo usuário

Uma conversão implícita definida pelo usuário consiste em uma conversão implícita padrão opcional, seguida pela execução de um operador de conversão implícita definido pelo usuário, seguida por outra conversão implícita padrão opcional. As regras exatas para avaliar conversões implícitas definidas pelo usuário são descritas no §10.5.4.

10.2.15 Conversões de funções anónimas e conversões de grupos de métodos

Funções anônimas e grupos de métodos não têm tipos em si, mas podem ser implicitamente convertidos em tipos delegados. Além disso, algumas expressões lambda podem ser implicitamente convertidas em tipos de árvore de expressão. As conversões de funções anónimas são descritas mais pormenorizadamente no §10.7 e as conversões de grupo de métodos no §10.8.

10.2.16 Conversões literais padrão

Existe uma conversão implícita de um default_literal (§12.8.21) para qualquer tipo. Esta conversão produz o valor por defeito (§9.3) do tipo inferido.

10.2.17 Conversões de lançamento implícitas

Embora as expressões de lançamento não tenham um tipo, elas podem ser implicitamente convertidas em qualquer tipo.

10.3 Conversões explícitas

10.3.1 Generalidades

As seguintes conversões são classificadas como conversões explícitas:

  • Todas as conversões implícitas (§10.2)
  • Conversões numéricas explícitas (§10.3.2)
  • Conversões de enumeração explícitas (§10.3.3)
  • Conversões anuláveis explícitas (§10.3.4)
  • Conversões explícitas de tuplas (§10.3.6)
  • Conversões de referência explícitas (§10.3.5)
  • Conversões explícitas de interface
  • Conversões de unboxing (§10.3.7)
  • Conversões explícitas de parâmetros de tipo (§10.3.8)
  • Conversões explícitas definidas pelo utilizador (§10.3.9)

Conversões explícitas podem ocorrer em expressões de elenco (§12.9.7).

O conjunto de conversões explícitas inclui todas as conversões implícitas.

Nota: Isso, por exemplo, permite que um cast explícito seja usado quando existe uma conversão de identidade implícita, a fim de forçar a seleção de uma sobrecarga de método particular. Nota final

As conversões explícitas que não são conversões implícitas são conversões que nem sempre podem ser comprovadas como bem-sucedidas, conversões que são conhecidas por possivelmente perder informações e conversões entre domínios de tipos suficientemente diferentes para merecer notação explícita.

10.3.2 Conversões numéricas explícitas

As conversões numéricas explícitas são as conversões de um numeric_type para outro numeric_type para as quais ainda não existe uma conversão numérica implícita (§10.2.3):

  • De sbyte , byteushort, uint, ulong, ou char.
  • De byte ou sbytecharpara .
  • De short , sbytebyte, ushort, uint, ulong, ou char.
  • De ushort , , sbytebyteshort, ou .char
  • De int , sbytebyte, short, , ushortuint, ulong, ou char.
  • De uint , sbytebyte, short, ushort, int, ou char.
  • De long , sbytebyte, , short, ushort, intuint, ulong, ou char.
  • De ulong , sbytebyte, , short, ushort, intuint, long, ou char.
  • De char , , sbytebyteou short.
  • De float , sbytebyte, , short, ushort, intuint, long, ulongchar, , ou decimal.
  • De double , sbytebyte, short, , ushort, intuint, long, ulong, charfloat, , ou decimal.
  • De decimal , sbytebyte, short, , ushort, intuint, long, ulong, charfloat, , ou double.

Como as conversões explícitas incluem todas as conversões numéricas implícitas e explícitas, é sempre possível converter de qualquer numeric_type para qualquer outra numeric_type usando uma expressão de elenco (§12.9.7).

As conversões numéricas explícitas possivelmente perdem informações ou possivelmente fazem com que exceções sejam lançadas. Uma conversão numérica explícita é processada da seguinte forma:

  • Para uma conversão de um tipo integral para outro tipo integral, o processamento depende do contexto de verificação de estouro (§12.8.20) em que a conversão ocorre:
    • Em um checked contexto, a conversão será bem-sucedida se o valor do operando de origem estiver dentro do intervalo do tipo de destino, mas lançará um System.OverflowException se o valor do operando de origem estiver fora do intervalo do tipo de destino.
    • Em um unchecked contexto, a conversão sempre é bem-sucedida e prossegue da seguinte forma.
      • Se o tipo de origem for maior que o tipo de destino, o valor de origem será truncado descartando seus bits "extra" mais significativos. O resultado é então tratado como um valor do tipo de destino.
      • Se o tipo de origem tiver o mesmo tamanho que o tipo de destino, o valor de origem será tratado como um valor do tipo de destino
  • Para uma conversão de um tipo integral, o valor de decimal origem é arredondado para zero para o valor integral mais próximo, e esse valor integral torna-se o resultado da conversão. Se o valor integral resultante estiver fora do intervalo do tipo de destino, um System.OverflowException será lançado.
  • Para uma conversão de ou float para um tipo integral, o processamento depende do contexto de verificação de double estouro (§12.8.20) em que a conversão ocorre:
    • Num contexto verificado, a conversão procede da seguinte forma:
      • Se o valor do operando for NaN ou infinito, a System.OverflowException é lançado.
      • Caso contrário, o operando de origem é arredondado para zero para o valor integral mais próximo. Se esse valor integral estiver dentro do intervalo do tipo de destino, esse valor será o resultado da conversão.
      • Caso contrário, um System.OverflowException é jogado.
    • Em um contexto não verificado, a conversão sempre é bem-sucedida e prossegue da seguinte maneira.
      • Se o valor do operando for NaN ou infinito, o resultado da conversão será um valor não especificado do tipo de destino.
      • Caso contrário, o operando de origem é arredondado para zero para o valor integral mais próximo. Se esse valor integral estiver dentro do intervalo do tipo de destino, esse valor será o resultado da conversão.
      • Caso contrário, o resultado da conversão é um valor não especificado do tipo de destino.
  • Para uma conversão de double para float, o double valor é arredondado para o valor mais próximo float . Se o double valor for muito pequeno para ser representado como um float, o resultado se tornará zero com o mesmo sinal que o valor. Se a magnitude do double valor for muito grande para representar como um float, o resultado torna-se infinito com o mesmo sinal que o valor. Se o double valor for NaN, o resultado também será NaN.
  • Para uma conversão de ou float para double, o valor de decimal origem é convertido em decimal representação e arredondado para o número mais próximo, se necessário (§8.3.8).
    • Se o valor de origem for muito pequeno para ser representado como um decimal, o resultado se tornará zero, preservando o sinal do valor original se decimal oferecer suporte a valores zero assinados.
    • Se a magnitude do valor de origem for muito grande para representar como um decimal, ou esse valor for infinito, o resultado será infinito preservando o sinal do valor original, se a representação decimal suportar infinidades, caso contrário, um System.OverflowException será lançado.
    • Se o valor de origem for NaN, o resultado será NaN se a representação decimal suportar NaNs; caso contrário, um System.OverflowException será lançado.
  • Para uma conversão de decimal para float ou double, o decimal valor é arredondado para o valor ou mais próximo doublefloat . Se a magnitude do valor de origem for muito grande para representar no tipo de destino, ou se esse valor for infinito, o resultado será infinito preservando o sinal do valor original. Se o valor de origem for NaN, o resultado será NaN. Embora essa conversão possa perder a precisão, ela nunca faz com que uma exceção seja lançada.

Nota: O decimal tipo não é necessário para suportar infinidades ou valores de NaN, mas pode fazê-lo, o seu intervalo pode ser menor do que o intervalo de float e double, mas não é garantido que seja. Para decimal representações sem infinidades ou valores NaN, e com um intervalo menor que float, o resultado de uma conversão de decimal para um ou floatdouble nunca será infinito ou NaN. Nota final

10.3.3 Conversões de enumeração explícitas

As conversões de enumeração explícitas são:

  • De sbyte, byte, short, , ushortint, uintlongulongcharfloatdouble, ou decimal a qualquer enum_type.
  • De qualquer enum_type para sbyte, byte, , shortushort, int, uint, long, ulongcharfloatdoubleou .decimal
  • De qualquer enum_type para qualquer outro enum_type.

Uma conversão de enumeração explícita entre dois tipos é processada tratando qualquer enum_type participante como o tipo subjacente desse enum_type e, em seguida, executando uma conversão numérica implícita ou explícita entre os tipos resultantes.

Exemplo: Dado um E com e tipo subjacente de int, uma conversão de para E é processada byte como uma conversão numérica explícita (§10.3.2) de int para byte, e uma conversão de para byte é processada E como uma conversão numérica implícita (§10.2.3) de byte para int. Exemplo final

10.3.4 Conversões anuláveis explícitas

As conversões anuláveis explícitas são aquelas conversões anuláveis (§10.6.1) derivadas de conversões explícitas e implícitas predefinidas.

10.3.5 Conversões de referência explícitas

As conversões de referência explícitas são:

  • Do objeto a qualquer outro reference_type.
  • De qualquer class_typeS a qualquer class_typeT, desde S que seja uma classe base de T.
  • De qualquer class_typeS a qualquer interface_typeT, desde que S não seja selado e desde que S não implementeT.
  • De qualquer interface_typeS a qualquer T, desde que T não sejam selados ou fornecidos T implementosS.
  • De qualquer interface_typeS a qualquer interface_typeT, desde que S não derive de T.
  • De um S com um tipo Sᵢ de elemento para um array_typeT com um tipo Tᵢde elemento , desde que todos os itens a seguir sejam verdadeiros:
    • S e T diferem apenas no tipo de elemento. Por outras palavras, S e T têm o mesmo número de dimensões.
    • Existe uma conversão de referência explícita de Sᵢ para Tᵢ.
  • De System.Array e as interfaces que implementa, para qualquer array_type.
  • De um array_type S[]para System.Collections.Generic.IList<T>, System.Collections.Generic.IReadOnlyList<T>e suas interfaces de base, desde que haja uma conversão de identidade ou conversão de referência explícita de S para T.
  • De System.Collections.Generic.IList<S>, System.Collections.Generic.IReadOnlyList<S>, e suas interfaces de base para um tipo T[]de matriz unidimensional , desde que haja uma conversão de identidade ou conversão de referência explícita de S para T.
  • De System.Delegate e as interfaces que implementa para qualquer delegate_type.
  • De um tipo S de referência para um tipo T de referência se ele tiver uma conversão de referência explícita de para um tipo S de T₀ referência e T₀ houver uma conversão de identidade de T₀ para T.
  • De um tipo S de referência para um tipo de interface ou de delegadoT, se houver uma conversão de referência explícita de para uma interface ou tipo S de T₀ delegado e for T₀ conversível em T variância para ou T for conversível em variação para T₀§18.2.3.3.
  • De D<S₁...Sᵥ> onde D<T₁...Tᵥ>D<X₁...Xᵥ> é um tipo de delegado genérico, D<S₁...Sᵥ> não é compatível ou idêntico a D<T₁...Tᵥ>, e para cada parâmetro Xᵢ de tipo das D seguintes retenções:
    • Se Xᵢ é invariante, então Sᵢ é idêntico a Tᵢ.
    • Se Xᵢ for covariante, então há uma conversão de identidade, conversão de referência implícita ou conversão de referência explícita de Sᵢ para Tᵢ.
    • Se Xᵢ é contravariante, então Sᵢ e Tᵢ são idênticos ou ambos os tipos de referência.
  • Conversões explícitas envolvendo parâmetros de tipo que são conhecidos por serem tipos de referência. Para obter mais detalhes sobre conversões explícitas envolvendo parâmetros de tipo, consulte §10.3.8.

As conversões de referência explícitas são aquelas conversões entre reference_types que exigem verificações em tempo de execução para garantir que estejam corretas.

Para que uma conversão de referência explícita seja bem-sucedida em tempo de execução, o valor do operando de origem deve ser null, ou o tipo do objeto referenciado pelo operando de origem deve ser um tipo que possa ser convertido para o tipo de destino por uma conversão de referência implícita (§10.2.8). Se uma conversão de referência explícita falhar, um System.InvalidCastException é lançado.

Nota: As conversões de referência, implícitas ou explícitas, nunca alteram o valor da própria referência (§8.2.1), apenas o seu tipo, nem o tipo ou valor do objeto que está a ser referenciado. Nota final

10.3.6 Conversões explícitas de tuplas

Existe uma conversão explícita de uma expressão E de tupla para um tipo T de tupla se E tiver a mesma aridade que T e existe uma conversão implícita ou explícita de cada elemento para E o tipo de elemento correspondente em T. A conversão é realizada criando uma instância do tipo correspondente T de System.ValueTuple<...>, e inicializando cada um de seus campos em ordem da esquerda para a direita, avaliando a expressão correspondente do elemento de tupla de E, convertendo-o para o tipo de elemento correspondente usando T a conversão explícita encontrada e inicializando o campo com o resultado.

10.3.7 Conversões de unboxing

Uma conversão unboxing permite que um reference_type seja explicitamente convertido em value_type. Existem as seguintes conversões de unboxing:

  • Do tipo object a qualquer value_type.
  • Do tipo System.ValueType a qualquer value_type.
  • Do tipo System.Enum a qualquer enum_type.
  • De qualquer interface_type a qualquer non_nullable_value_type que implemente o interface_type.
  • De qualquer I para qualquer non_nullable_value_type onde há uma conversão de unboxing de um interface_typeI₀ para o tipo non_nullable_value e uma conversão de I identidade de para I₀.
  • De qualquer I para qualquer non_nullable_value_type em que haja uma conversão de unboxing de um interface_typeI₀ para o non_nullable_value_type e I₀ seja variance_convertible ou II seja conversível em I₀ variação (§18.2.3.3).
  • De qualquer reference_type para qualquer nullable_value_type onde haja uma conversão de unboxing de reference_type para o non_nullable_value_type subjacente do nullable_value_type.
  • De um parâmetro de tipo que não se sabe ser um tipo de valor para qualquer tipo tal que a conversão é permitida pelo §10.3.8.

Uma operação de unboxing para um non_nullable_value_type consiste em primeiro verificar se a ocorrência do objeto é um valor em caixa do non_nullable_value_type determinado e, em seguida, copiar o valor para fora da instância.

Unboxing para um nullable_value_type produz o valor nulo do nullable_value_type se o operando de origem for null, ou o resultado encapsulado do unboxing da instância de objeto para o tipo subjacente do nullable_value_type caso contrário.

Nota: Referindo-se à classe de boxe imaginária descrita no §10.2.9, uma conversão de unboxing de uma caixa de objeto para uma value_typeS consiste em executar a expressão ((S_Boxing)box).value. Assim, as declarações

object box = new S();
S s = (S)box;

correspondem conceptualmente a

object box = new S_Boxing(new S());
S s = ((S_Boxing)box).value;

Nota final

Para que uma conversão de unboxing para um determinado non_nullable_value_type seja bem-sucedida em tempo de execução, o valor do operando de origem deve ser uma referência a um valor in a box desse non_nullable_value_type. Se o operando de origem for null um System.NullReferenceException é lançado. Se o operando de origem for uma referência a um objeto incompatível, um System.InvalidCastException será lançado.

Para que uma conversão de unboxing para um determinado nullable_value_type seja bem-sucedida em tempo de execução, o valor do operando de origem deve ser nulo ou uma referência a um valor in a box do non_nullable_value_type subjacente do nullable_value_type. Se o operando de origem for uma referência a um objeto incompatível, um System.InvalidCastException será lançado.

10.3.8 Conversões explícitas envolvendo parâmetros de tipo

Para um type_parameterT conhecido por ser um tipo de referência (§15.2.5), existem as seguintes conversões de referência explícitas (§10.3.5):

  • Da classe C base efetiva de T para T e de qualquer classe base de C para T.
  • De qualquer interface_type a T.
  • De T para qualquer interface_typeI desde que ainda não haja uma conversão de referência implícita de T para I.
  • De um U para T desde que T dependa (U§15.2.5).

    Nota: Como T é conhecido por ser um tipo de referência, dentro do escopo do T, o tipo de tempo de execução de você sempre será um tipo de referência, mesmo que U não seja conhecido por ser um tipo de referência em tempo de compilação. Nota final

Para um type_parameterT que não é conhecido por ser um tipo de referência (§15.2.5), as seguintes conversões envolvendo T são consideradas conversões unboxing (§10.3.7) em tempo de compilação. Em tempo de execução, se T for um tipo de valor, a conversão é executada como uma conversão de unboxing. Em tempo de execução, se T for um tipo de referência, a conversão é executada como uma conversão de referência explícita ou conversão de identidade.

  • Da classe C base efetiva de T para T e de qualquer classe base de C para T.

    Nota: C será um dos tipos System.Object, System.ValueTypeou System.Enum (caso contrário T seria conhecido por ser um tipo de referência). Nota final

  • De qualquer interface_type a T.

Para um T que não é conhecido por ser um tipo de referência (§15.2.5), existem as seguintes conversões explícitas:

  • De T para qualquer interface_typeI desde que não haja já uma conversão implícita de T para I. Esta conversão consiste numa conversão de boxe implícita (§10.2.9) de T para seguida object de uma conversão de referência explícita de object para I. Em tempo de execução, se T for um tipo de valor, a conversão é executada como uma conversão de boxe seguida por uma conversão de referência explícita. Em tempo de execução, se T for um tipo de referência, a conversão é executada como uma conversão de referência explícita.
  • De um parâmetro U de tipo para T desde que T dependa de U (§15.2.5). Em tempo de execução, se T for um tipo de valor e U for um tipo de referência, a conversão será executada como uma conversão de unboxing. Em tempo de execução, se ambos T e U são tipos de valor, então T e U são necessariamente o mesmo tipo e nenhuma conversão é executada. Em tempo de execução, se T é um tipo de referência, então U é necessariamente também um tipo de referência e a conversão é executada como uma conversão de referência explícita ou conversão de identidade.

Em todos os casos, as regras garantem que uma conversão seja executada como uma conversão de unboxing se e somente se em tempo de execução a conversão for de um tipo de referência para um tipo de valor.

As regras acima não permitem uma conversão explícita direta de um parâmetro de tipo sem restrições para um tipo sem interface, o que pode ser surpreendente. A razão para esta regra é evitar confusões e tornar clara a semântica de tais conversões.

Exemplo: Considere a seguinte declaração:

class X<T>
{
    public static long F(T t)
    {
        return (long)t;         // Error
    }
}

Se a conversão explícita direta de t em long fosse permitida, seria de esperar que isso X<int>.F(7) voltasse 7L. No entanto, não o faria, porque as conversões numéricas padrão só são consideradas quando se sabe que os tipos são numéricos em tempo de vinculação. A fim de tornar a semântica clara, o exemplo acima deve ser escrito:

class X<T>
{
    public static long F(T t)
    {
        return (long)(object)t;         // Ok, but will only work when T is long
    }
}

Esse código agora será compilado, mas a execução X<int>.F(7) lançaria uma exceção em tempo de execução, já que um box não int pode ser convertido diretamente em um longarquivo .

Exemplo final

10.3.9 Conversões explícitas definidas pelo usuário

Uma conversão explícita definida pelo usuário consiste em uma conversão explícita padrão opcional, seguida pela execução de um operador de conversão implícita ou explícita definida pelo usuário, seguida por outra conversão explícita padrão opcional. As regras exatas para avaliar conversões explícitas definidas pelo usuário são descritas no §10.5.5.

10.4 Conversões padrão

10.4.1 Generalidades

As conversões padrão são aquelas conversões predefinidas que podem ocorrer como parte de uma conversão definida pelo usuário.

10.4.2 Conversões implícitas padrão

As seguintes conversões implícitas são classificadas como conversões implícitas padrão:

  • Conversões de identidade (§10.2.2)
  • Conversões numéricas implícitas (§10.2.3)
  • Conversões implícitas anuláveis (§10.2.6)
  • Conversões literais nulas (§10.2.7)
  • Conversões de referência implícitas (§10.2.8)
  • Conversões de boxe (§10.2.9)
  • Conversões implícitas de expressões constantes (§10.2.11)
  • Conversões implícitas envolvendo parâmetros de tipo (§10.2.12)

As conversões implícitas padrão excluem especificamente as conversões implícitas definidas pelo usuário.

10.4.3 Conversões explícitas padrão

As conversões explícitas padrão são todas as conversões implícitas padrão mais o subconjunto das conversões explícitas para as quais existe uma conversão implícita padrão oposta.

Nota: Em outras palavras, se existe uma conversão implícita padrão de um tipo A para um tipo B, então existe uma conversão explícita padrão de tipo A para tipo B e de tipo B para tipo A. Nota final

10.5 Conversões definidas pelo usuário

10.5.1 Generalidades

O C# permite que as conversões implícitas e explícitas predefinidas sejam aumentadas por conversões definidas pelo usuário. As conversões definidas pelo usuário são introduzidas declarando operadores de conversão (§15.10.4) em tipos de classe e struct.

10.5.2 Conversões permitidas definidas pelo usuário

O C# permite que apenas determinadas conversões definidas pelo usuário sejam declaradas. Em particular, não é possível redefinir uma conversão implícita ou explícita já existente.

Para um determinado tipo S de origem e tipo Tde destino , se S ou T são tipos de valor anuláveis, deixe S₀ e T₀ faça referência aos seus tipos subjacentes, caso contrário S₀ e T₀ são iguais a S e T respectivamente. Uma classe ou struct tem permissão para declarar uma conversão de um tipo S de origem para um tipo T de destino somente se todos os itens a seguir forem verdadeiros:

  • S₀ e T₀ são tipos diferentes.
  • Ou S₀T₀ é o tipo de classe ou estrutura em que a declaração do operador tem lugar.
  • Nem S₀T₀ é uma interface_type.
  • Excluindo conversões definidas pelo usuário, não existe uma conversão de S para T ou de T para S.

As restrições que se aplicam às conversões definidas pelo usuário são especificadas no §15.10.4.

10.5.3 Avaliação de conversões definidas pelo usuário

Uma conversão definida pelo usuário converte uma expressão de origem, que pode ter um tipo de origem, em outro tipo, chamado de tipo de destino. A avaliação de um centro de conversão definido pelo usuário para encontrar o operador de conversão mais específico definido pelo usuário para a expressão de origem e o tipo de destino. Esta determinação divide-se em várias etapas:

  • Encontrar o conjunto de classes e estruturas a partir das quais os operadores de conversão definidos pelo usuário serão considerados. Esse conjunto consiste no tipo de origem e suas classes base, se o tipo de origem existir, juntamente com o tipo de destino e suas classes base. Para este efeito, assume-se que apenas classes e structs podem declarar operadores definidos pelo usuário e que tipos não-classe não têm classes base. Além disso, se o tipo de origem ou destino for um tipo de valor anulável, seu tipo subjacente será usado.
  • A partir desse conjunto de tipos, determinar quais operadores de conversão definidos pelo usuário e levantados são aplicáveis. Para que um operador de conversão seja aplicável, deve ser possível efetuar uma conversão normalizada (ponto 10.4) da expressão de origem para o tipo de operando do operador, e deve ser possível efetuar uma conversão normalizada do tipo de resultado do operador para o tipo alvo.
  • A partir do conjunto de operadores aplicáveis definidos pelo usuário, determinar qual operador é inequivocamente o mais específico. Em termos gerais, o operador mais específico é o operador cujo tipo de operando é "mais próximo" da expressão de origem e cujo tipo de resultado é "mais próximo" do tipo de destino. Os operadores de conversão definidos pelo usuário são preferidos em relação aos operadores de conversão levantados. As regras exatas para estabelecer o operador de conversão mais específico definido pelo usuário são definidas nas subcláusulas a seguir.

Uma vez identificado um operador de conversão definido pelo usuário mais específico, a execução real da conversão definida pelo usuário envolve até três etapas:

  • Primeiro, se necessário, executar uma conversão padrão da expressão de origem para o tipo de operando do operador de conversão definido pelo usuário ou levantado.
  • Em seguida, chamando o operador de conversão definido pelo usuário ou levantado para executar a conversão.
  • Finalmente, se necessário, executar uma conversão padrão do tipo de resultado do operador de conversão definido pelo usuário para o tipo de destino.

A avaliação de uma conversão definida pelo usuário nunca envolve mais de um operador de conversão definido pelo usuário ou levantado. Em outras palavras, uma conversão de tipo S para tipo T nunca primeiro executará uma conversão definida pelo usuário de S para X e, em seguida, executará uma conversão definida pelo usuário de X para T.

  • As definições exatas de avaliação das conversões implícitas ou explícitas definidas pelo utilizador são dadas nas subcláusulas seguintes. As definições utilizam os seguintes termos:
  • Se uma conversão implícita padrão (§10.4.2) existe de um tipo para um tipo A, e se nem BA são interface_type B , então s diz-se que estáA , e B diz-se queBA
  • Se uma conversão implícita padrão (§10.4.2E
  • O tipo mais abrangente em um conjunto de tipos é o tipo que engloba todos os outros tipos no conjunto. Se nenhum tipo engloba todos os outros tipos, então o conjunto não tem o tipo mais abrangente. Em termos mais intuitivos, o tipo mais abrangente é o tipo "maior" do conjunto — aquele tipo para o qual cada um dos outros tipos pode ser implicitamente convertido.
  • O tipo mais englobado em um conjunto de tipos é o tipo que é englobado por todos os outros tipos no conjunto. Se nenhum tipo único é englobado por todos os outros tipos, então o conjunto não tem nenhum tipo mais englobado. Em termos mais intuitivos, o tipo mais englobado é o tipo "menor" do conjunto — aquele tipo que pode ser implicitamente convertido para cada um dos outros tipos.

10.5.4 Conversões implícitas definidas pelo usuário

Uma conversão implícita definida pelo usuário de uma expressão E para um tipo T é processada da seguinte maneira:

  • Determine os tipos Se S₀T₀.

    • Se E tem um tipo, que seja S esse tipo.
    • Se S ou T são tipos de valor anuláveis, deixe Sᵢ e Tᵢ sejam seus tipos subjacentes, caso contrário, let Sᵢ e Tᵢ be S e T, respectivamente.
    • Se Sᵢ ou Tᵢ são parâmetros de tipo, deixe S₀ e T₀ sejam suas classes base efetivas, caso contrário, deixe S₀ e T₀ seja Sₓ e Tᵢ, respectivamente.

  • Encontre o conjunto de tipos, D, a partir dos quais os operadores de conversão definidos pelo usuário serão considerados. Este conjunto consiste em S₀ (se S₀ existe e é uma classe ou struct), as classes base de S₀ (se S₀ existe e é uma classe) e T₀ (se T₀ é uma classe ou struct). Um tipo é adicionado ao conjunto D somente se uma conversão de identidade para outro tipo já incluído no conjunto não existir.

  • Encontre o conjunto de operadores de conversão definidos pelo usuário e levantados aplicáveis, U. Esse conjunto consiste nos operadores de conversão implícitos definidos pelo usuário e levantados declarados pelas classes ou structs em D que convertem de um tipo abrangente para um tipo englobado E por T. Se U estiver vazia, a conversão é indefinida e ocorre um erro em tempo de compilação.

    • Se S existe e qualquer um dos operadores em U converter de S, então Sₓ é S.
    • Caso contrário, Sₓ é o tipo mais englobado no conjunto combinado de tipos de origem dos operadores em U. Se exatamente um tipo mais abrangente não puder ser encontrado, então a conversão é ambígua e ocorre um erro em tempo de compilação.

  • Encontre o tipo de alvo mais específico, Tₓ, dos operadores em U:

    • Se qualquer um dos operadores em U converter para T, então Tₓ é T.
    • Caso contrário, Tₓ é o tipo mais abrangente no conjunto combinado de tipos de destino dos operadores em U. Se exatamente um tipo mais abrangente não puder ser encontrado, então a conversão é ambígua e ocorre um erro em tempo de compilação.

  • Encontre o operador de conversão mais específico:

    • Se U contiver exatamente um operador de conversão definido pelo usuário que converte de para Sₓ, então este é o operador de Tₓ conversão mais específico.
    • Caso contrário, se U contiver exatamente um operador de conversão levantado que converte de para Sₓ, então este é o operador de Tₓ conversão mais específico.
    • Caso contrário, a conversão é ambígua e ocorre um erro em tempo de compilação.

  • Por fim, aplique a conversão:

    • Se E ainda não tiver o tipo Sₓ, então uma conversão implícita padrão de E para Sₓ é executada.
    • O operador de conversão mais específico é invocado para converter de Sₓ para Tₓ.
    • Se Tₓ não Tfor , então uma conversão implícita padrão de Tₓ para T é realizada.

Existe uma conversão implícita definida pelo usuário de um tipo S para um tipo T se existir uma conversão implícita definida pelo usuário de uma variável de tipo S para T.

10.5.5 Conversões explícitas definidas pelo usuário

Uma conversão explícita definida pelo usuário de uma expressão E para um tipo T é processada da seguinte maneira:

  • Determine os tipos Se S₀T₀.
    • Se E tem um tipo, que seja S esse tipo.
    • Se S ou T são tipos de valor anuláveis, deixe Sᵢ e Tᵢ sejam seus tipos subjacentes, caso contrário, let Sᵢ e Tᵢ be S e T, respectivamente.
    • Se Sᵢ ou Tᵢ são parâmetros de tipo, deixe S₀ e T₀ sejam suas classes base efetivas, caso contrário, deixe S₀ e T₀ seja Sᵢ e Tᵢ, respectivamente.
  • Encontre o conjunto de tipos, D, a partir dos quais os operadores de conversão definidos pelo usuário serão considerados. Este conjunto consiste em S₀ (se S₀ existe e é uma classe ou struct), as classes base de S₀ (se S₀ existe e é uma classe), T₀ (se T₀ é uma classe ou struct) e as classes base de T₀ (se T₀ é uma classe). A type é adicionado ao conjunto D somente se uma conversão de identidade para outro tipo já incluído no conjunto não existir.
  • Encontre o conjunto de operadores de conversão definidos pelo usuário e levantados aplicáveis, U. Este conjunto consiste nos operadores de conversão implícitos ou explícitos definidos pelo utilizador e levantados declarados pelas classes ou estruturas em D que convertem de um tipo que engloba E ou engloba por S (se existir) para um tipo que engloba ou engloba por T. Se U estiver vazia, a conversão é indefinida e ocorre um erro em tempo de compilação.
  • Encontre o tipo de fonte mais específico, Sₓ, dos operadores em U:
    • Se S existe e qualquer um dos operadores em U converter de S, então Sₓ é S.
    • Caso contrário, se qualquer um dos operadores em U converter de tipos que englobam E, então Sₓ é o tipo mais englobado no conjunto combinado de tipos de origem desses operadores. Se nenhum tipo mais abrangente puder ser encontrado, a conversão será ambígua e ocorrerá um erro em tempo de compilação.
    • Caso contrário, Sₓ é o tipo mais abrangente no conjunto combinado de tipos de origem dos operadores em U. Se exatamente um tipo mais abrangente não puder ser encontrado, então a conversão é ambígua e ocorre um erro em tempo de compilação.
  • Encontre o tipo de alvo mais específico, Tₓ, dos operadores em U:
    • Se qualquer um dos operadores em U converter para T, então Tₓ é T.
    • Caso contrário, se qualquer um dos operadores em U converter para tipos que são englobados por T, então Tₓ é o tipo mais abrangente no conjunto combinado de tipos de destino desses operadores. Se exatamente um tipo mais abrangente não puder ser encontrado, então a conversão é ambígua e ocorre um erro em tempo de compilação.
    • Caso contrário, Tₓ é o tipo mais englobado no conjunto combinado de tipos de destino dos operadores em U. Se nenhum tipo mais abrangente puder ser encontrado, a conversão será ambígua e ocorrerá um erro em tempo de compilação.
  • Encontre o operador de conversão mais específico:
    • Se U contém exatamente um operador de conversão definido pelo usuário que converte de para Sₓ, então este é o operador de Tₓ conversão mais específico.
    • Caso contrário, se U contiver exatamente um operador de conversão levantado que converte de para Sₓ, então este é o operador de Tₓ conversão mais específico.
    • Caso contrário, a conversão é ambígua e ocorre um erro em tempo de compilação.
  • Por fim, aplique a conversão:
    • Se E ainda não tiver o tipo Sₓ, então uma conversão explícita padrão de E para Sₓ é executada.
    • O operador de conversão mais específico definido pelo usuário é invocado para converter de Sₓ para Tₓ.
    • Se Tₓ não Tfor , então uma conversão explícita padrão de Tₓ para T é executada.

Existe uma conversão explícita definida pelo usuário de um tipo S para um tipo T se existir uma conversão explícita definida pelo usuário de uma variável de tipo S para T.

10.6 Conversões envolvendo tipos anuláveis

10.6.1 Conversões anuláveis

As conversões anuláveis permitem que conversões predefinidas que operam em tipos de valor não anuláveis também sejam usadas com formas anuláveis desses tipos. Para cada uma das conversões implícitas ou explícitas predefinidas que convertem de um tipo S de valor não anulável para um tipo T de valor não anulável (§10.2.2, §10.2.3, §10.2.4, §10.2.11, §10.3.2 e §10.3.3), existem as seguintes conversões anuláveis:

  • Uma conversão implícita ou explícita de S? para T?
  • Uma conversão implícita ou explícita de S para T?
  • Uma conversão explícita de S? para T.

Uma conversão anulável é classificada como uma conversão implícita ou explícita.

Certas conversões anuláveis são classificadas como conversões padrão e podem ocorrer como parte de uma conversão definida pelo usuário. Especificamente, todas as conversões implícitas anuláveis são classificadas como conversões implícitas padrão (§10.4.2), e as conversões explícitas anuláveis que satisfazem os requisitos do §10.4.3 são classificadas como conversões explícitas padrão.

Avaliação de uma conversão anulável com base numa conversão subjacente do ST produto do seguinte modo:

  • Se a conversão anulável for de S? para T?:
    • Se o valor de origem for null (HasValue propriedade for false), o resultado será o valor nulo do tipo T?.
    • Caso contrário, a conversão é avaliada como um desempacotamento de S? para S, seguido pela conversão subjacente de S para T, seguido por um encapsulamento de T para T?.
  • Se a conversão anulável for de S para T?, a conversão é avaliada como a conversão subjacente de S para T seguida de um wrapping de T para T?.
  • Se a conversão anulável for de S? para T, a conversão é avaliada como um desempacotamento de S? para S seguido pela conversão subjacente de S para T.

10.6.2 Conversões suspensas

Dado um operador de conversão definido pelo usuário que converte de um tipo S de valor não anulável para um tipo Tde valor não anulável, existe um operador de conversão suspenso que converte de S? para T?. Esse operador de conversão levantado executa um desempacotamento de S? para seguido pela conversão definida pelo usuário de S para S seguido por um encapsulamento de T para T, exceto que um valor T? nulo converte diretamente em um valor S?nulo T? . Um operador de conversão levantado tem a mesma classificação implícita ou explícita que o seu operador de conversão subjacente definido pelo utilizador.

10.7 Conversões de funções anónimas

10.7.1 Generalidades

Um anonymous_method_expression ou lambda_expression é classificado como uma função anónima (§12.19). A expressão não tem um tipo, mas pode ser implicitamente convertida em um tipo de delegado compatível. Algumas expressões lambda também podem ser implicitamente convertidas em um tipo de árvore de expressão compatível.

Especificamente, uma função F anônima é compatível com um tipo D de delegado, desde que:

  • Se F contém um anonymous_function_signature, então D e F tem o mesmo número de parâmetros.
  • Se F não contém um anonymous_function_signature, então pode ter zero ou mais parâmetros de qualquer tipo, desde que D nenhum parâmetro de é um parâmetro de D saída.
  • Se F tiver uma lista de parâmetros explicitamente tipada, cada parâmetro em D terá os mesmos modificadores que o parâmetro correspondente em F e existe uma conversão de identidade entre o parâmetro correspondente em F.
  • Se F tem uma lista de parâmetros digitada implicitamente, D não tem parâmetros de referência ou saída.
  • Se o corpo de é uma expressão, e tem um tipo D é assíncrono e tem um F tipo de retorno (D), então quando cada parâmetro de «TaskType» é dado o tipo do parâmetro correspondente em , o corpo de F é uma expressão válida (w.r.t D) que seria permitida como um F (§13.7).
  • Se o corpo de é um bloco, e F um tipo de D retorno vazio ouF é assíncrono e D tem um «TaskType» tipo de retorno, então quando cada parâmetro de F é dado o tipo do parâmetro correspondente em D, o corpo de F é um bloco válido (w.r.t §13.3) no qual nenhuma return instrução especifica uma expressão.
  • Se o corpo de F é uma expressão, e ouF é não-assíncrono e D tem um tipo voidnão-retornoT , F é assíncrono e D tem um «TaskType»<T> tipo de retorno (§15.15.1), então quando cada parâmetro de F é dado o tipo do parâmetro correspondente em D, o corpo de F é uma expressão válida (w.r.t §12) que é implicitamente conversível em T.
  • Se o corpo de F é um bloco, e ouF é não-assíncrono e D tem um tipo Tde retorno não-void , ouF é assíncrono e D tem um «TaskType»<T> tipo de retorno, então quando cada parâmetro de F é dado o tipo do parâmetro correspondente em D, o corpo de é um bloco de F instrução válido (w.r.t §13.3) com um ponto final não alcançável no qual cada instrução de retorno especifica uma expressão que é implicitamente conversível em T.

Exemplo: Os exemplos a seguir ilustram essas regras:

delegate void D(int x);
D d1 = delegate { };                         // Ok
D d2 = delegate() { };                       // Error, signature mismatch
D d3 = delegate(long x) { };                 // Error, signature mismatch
D d4 = delegate(int x) { };                  // Ok
D d5 = delegate(int x) { return; };          // Ok
D d6 = delegate(int x) { return x; };        // Error, return type mismatch

delegate void E(out int x);
E e1 = delegate { };                         // Error, E has an output parameter
E e2 = delegate(out int x) { x = 1; };       // Ok
E e3 = delegate(ref int x) { x = 1; };       // Error, signature mismatch

delegate int P(params int[] a);
P p1 = delegate { };                         // Error, end of block reachable
P p2 = delegate { return; };                 // Error, return type mismatch
P p3 = delegate { return 1; };               // Ok
P p4 = delegate { return "Hello"; };         // Error, return type mismatch
P p5 = delegate(int[] a)                     // Ok
{
    return a[0];
};
P p6 = delegate(params int[] a)              // Error, params modifier
{
    return a[0];
};
P p7 = delegate(int[] a)                     // Error, return type mismatch
{
    if (a.Length > 0) return a[0];
    return "Hello";
};

delegate object Q(params int[] a);
Q q1 = delegate(int[] a)                    // Ok
{
    if (a.Length > 0) return a[0];
    return "Hello";
};

Exemplo final

Exemplo: Os exemplos a seguir usam um tipo Func<A,R> de delegado genérico que representa uma função que usa um argumento de tipo A e retorna um valor de tipo R:

delegate R Func<A,R>(A arg);

Nas atribuições

Func<int,int> f1 = x => x + 1; // Ok
Func<int,double> f2 = x => x + 1; // Ok
Func<double,int> f3 = x => x + 1; // Error
Func<int, Task<int>> f4 = async x => x + 1; // Ok

Os tipos de parâmetro e retorno de cada função anônima são determinados a partir do tipo da variável à qual a função anônima é atribuída.

A primeira atribuição converte com êxito a função anônima para o tipo Func<int,int> delegado porque, quando x é dado tipo int, x + 1 é uma expressão válida que é implicitamente conversível em tipo int.

Da mesma forma, a segunda atribuição converte com êxito a função anônima para o tipo delegado Func<int,double> porque o resultado de x + 1 (do tipo int) é implicitamente conversível em tipo double.

No entanto, a terceira atribuição é um erro em tempo de compilação porque, quando x é dado tipo double, o resultado de x + 1 (do tipo double) não é implicitamente convertível em tipo int.

A quarta atribuição converte com êxito a função assíncrona anônima para o tipo Func<int, Task<int>> delegado porque o resultado de (do tipox + 1) é implicitamente conversível para o tipo int de retorno efetivo do lambda assíncrono, que tem um tipo de int retornoTask<int>.

Exemplo final

Uma expressão F lambda é compatível com um tipo Expression<D> de árvore de expressão se F for compatível com o tipo Dde delegado. Isso não se aplica a métodos anônimos, apenas expressões lambda.

Funções anônimas podem influenciar a resolução de sobrecarga e participar da inferência de tipo. Ver §12.6 para mais pormenores.

10.7.2 Avaliação de conversões de funções anónimas para tipos delegados

A conversão de uma função anônima para um tipo de delegado produz uma instância delegada que faz referência à função anônima e ao conjunto (possivelmente vazio) de variáveis externas capturadas que estão ativas no momento da avaliação. Quando o delegado é invocado, o corpo da função anônima é executado. O código no corpo é executado usando o conjunto de variáveis externas capturadas referenciadas pelo delegado. Um delegate_creation_expression (§12.8.17.6) pode ser usado como uma sintaxe alternativa para converter um método anônimo em um tipo delegado.

A lista de invocação de um delegado produzida a partir de uma função anónima contém uma única entrada. O objeto de destino exato e o método de destino do delegado não são especificados. Em particular, não é especificado se o objeto de destino do delegado é null, o this valor do membro da função de inclusão ou algum outro objeto.

Conversões de funções anônimas semanticamente idênticas com o mesmo conjunto (possivelmente vazio) de instâncias de variáveis externas capturadas para os mesmos tipos de delegados são permitidas (mas não obrigatórias) para retornar a mesma instância delegada. O termo semanticamente idêntico é usado aqui para significar que a execução das funções anônimas produzirá, em todos os casos, os mesmos efeitos dados os mesmos argumentos. Esta regra permite que códigos como os seguintes sejam otimizados.

delegate double Function(double x);

class Test
{
    static double[] Apply(double[] a, Function f)
    {
        double[] result = new double[a.Length];
        for (int i = 0; i < a.Length; i++)
        {
            result[i] = f(a[i]);
        }
        return result;
    }

    static void F(double[] a, double[] b)
    {
        a = Apply(a, (double x) => Math.Sin(x));
        b = Apply(b, (double y) => Math.Sin(y));
        ...
    }
}

Como os dois delegados de função anônimos têm o mesmo conjunto (vazio) de variáveis externas capturadas, e como as funções anônimas são semanticamente idênticas, um compilador pode fazer com que os delegados se refiram ao mesmo método de destino. Na verdade, um compilador tem permissão para retornar a mesma instância delegada de ambas as expressões de função anônimas.

10.7.3 Avaliação de conversões de expressões lambda para tipos de árvore de expressão

A conversão de uma expressão lambda em um tipo de árvore de expressão produz uma árvore de expressão (§8.6). Mais precisamente, a avaliação da conversão da expressão lambda produz uma estrutura de objeto que representa a estrutura da própria expressão lambda.

Nem todas as expressões lambda podem ser convertidas em tipos de árvore de expressão. A conversão para um tipo de delegado compatível sempre existe, mas pode falhar em tempo de compilação por motivos definidos pela implementação.

Nota: Os motivos comuns para uma expressão lambda não ser convertida em um tipo de árvore de expressão incluem:

  • Tem um corpo de bloco
  • Tem o async modificador
  • Ele contém um operador de atribuição
  • Ele contém um parâmetro de saída ou referência
  • Ele contém uma expressão dinamicamente ligada

Nota final

10.8 Conversões de grupo de métodos

Existe uma conversão implícita de um grupo de métodos (§12.2) para um tipo de delegado compatível (§20.4). Se D é um tipo delegado, e E é uma expressão que é classificada como um grupo de métodos, então D é compatível com E se e somente se E contém pelo menos um método que é aplicável em sua forma normal (§12.6.4.2) a qualquer lista de argumentos (§12.6.2) com tipos e modificadores correspondentes aos tipos de parâmetros e modificadores de D, conforme descrito a seguir.

A aplicação em tempo de compilação da conversão de um grupo E de métodos para um tipo de delegado D é descrita a seguir.

  • É selecionado um único método M correspondente a uma invocação de método (§12.8.10.2) do formulário E(A), com as seguintes modificações:
    • A lista A de argumentos é uma lista de expressões, cada uma classificada como uma variável e com o tipo e modificador (in, out, ou ref) do parâmetro correspondente na parameter_list de D — exceto parâmetros do tipo dynamic, onde a expressão correspondente tem o tipo object em vez de dynamic.
    • Os métodos candidatos considerados são apenas os que são aplicáveis na sua forma normal e não omitem quaisquer parâmetros opcionais (§12.6.4.2). Assim, os métodos candidatos são ignorados se forem aplicáveis apenas na sua forma expandida ou se um ou mais dos seus parâmetros opcionais não tiverem um parâmetro correspondente no D.
  • Considera-se que existe uma conversão se o algoritmo do §12.8.10.2 produzir um único melhor método M que seja compatível (§20.4) com D.
  • Se o método M selecionado for um método de instância, a expressão de instância associada a E determinará o objeto de destino do delegado.
  • Se o método M selecionado for um método de extensão que é indicado por meio de um acesso de membro em uma expressão de instância, essa expressão de instância determinará o objeto de destino do delegado.
  • O resultado da conversão é um valor do tipo D, ou seja, um delegado que se refere ao método selecionado e ao objeto de destino.

Exemplo: O seguinte demonstra conversões de grupo de método:

delegate string D1(object o);
delegate object D2(string s);
delegate object D3();
delegate string D4(object o, params object[] a);
delegate string D5(int i);
class Test
{
    static string F(object o) {...}

    static void G()
    {
        D1 d1 = F;         // Ok
        D2 d2 = F;         // Ok
        D3 d3 = F;         // Error – not applicable
        D4 d4 = F;         // Error – not applicable in normal form
        D5 d5 = F;         // Error – applicable but not compatible
    }
}

A atribuição a d1 converte implicitamente o grupo F de métodos em um valor do tipo D1.

A atribuição para d2 mostra como é possível criar um delegado para um método que tem menos tipos de parâmetros derivados (contravariantes) e um tipo de retorno mais derivado (covariante).

A atribuição para d3 mostra como nenhuma conversão existe se o método não for aplicável.

A atribuição para d4 mostra como o método deve ser aplicável em sua forma normal.

A atribuição para d5 mostra como os tipos de parâmetro e retorno do delegado e do método podem diferir apenas para tipos de referência.

Exemplo final

Como acontece com todas as outras conversões implícitas e explícitas, o operador cast pode ser usado para executar explicitamente uma conversão específica.

Exemplo: Assim, o exemplo

object obj = new EventHandler(myDialog.OkClick);

poderia, em vez disso, ser escrito

object obj = (EventHandler)myDialog.OkClick;

Exemplo final

Uma conversão de grupo de métodos pode referir-se a um método genérico, especificando explicitamente argumentos de tipo dentro Ede , ou através de inferência de tipo (§12.6.3). Se a inferência de tipo for usada, os tipos de parâmetros do delegado serão usados como tipos de argumento no processo de inferência. O tipo de retorno do delegado não é usado para inferência. Se os argumentos de tipo são especificados ou inferidos, eles fazem parte do processo de conversão do grupo de métodos; Estes são os argumentos de tipo usados para invocar o método de destino quando o delegado resultante é invocado.

Exemplo:

delegate int D(string s, int i);
delegate int E();

class X
{
    public static T F<T>(string s, T t) {...}
    public static T G<T>() {...}

    static void Main()
    {
        D d1 = F<int>;        // Ok, type argument given explicitly
        D d2 = F;             // Ok, int inferred as type argument
        E e1 = G<int>;        // Ok, type argument given explicitly
        E e2 = G;             // Error, cannot infer from return type
    }
}

Exemplo final

Os grupos de métodos podem influenciar a resolução da sobrecarga e participar na inferência de tipos. Ver §12.6 para mais pormenores.

A avaliação em tempo de execução de uma conversão de grupo de métodos prossegue da seguinte forma:

  • Se o método selecionado em tempo de compilação for um método de instância ou for um método de extensão que é acessado como um método de instância, o objeto de destino do delegado será determinado a partir da expressão de instância associada a E:
    • A expressão da instância é avaliada. Se essa avaliação causar uma exceção, nenhuma etapa adicional será executada.
    • Se a expressão de instância for de um reference_type, o valor calculado pela expressão de instância se tornará o objeto de destino. Se o método selecionado for um método de instância e o objeto de destino for null, a System.NullReferenceException será lançado e nenhuma outra etapa será executada.
    • Se a expressão da instância for de um value_type, uma operação de boxe (§10.2.9) será executada para converter o valor em um objeto, e esse objeto se tornará o objeto de destino.
  • Caso contrário, o método selecionado faz parte de uma chamada de método estático e o objeto de destino do delegado é null.
  • Uma instância delegada do tipo D delegado é obtida com uma referência ao método que foi determinado em tempo de compilação e uma referência ao objeto de destino calculado acima, da seguinte forma:
    • A conversão é permitida (mas não necessária) para usar uma instância delegada existente que já contenha essas referências.
    • Se uma instância existente não tiver sido reutilizada, é criada uma nova instância (§20.5). Se não houver memória suficiente disponível para alocar a nova instância, um System.OutOfMemoryException será lançado. Caso contrário, a instância é inicializada com as referências fornecidas.