Compartilhar via

Coerções e conversões de tipo (Guia de Programação em C#)

Como o C# é tipado estaticamente no momento da compilação, depois que uma variável é declarada, ela não pode ser declarada novamente ou atribuída a um valor de outro tipo, a menos que esse tipo seja implicitamente conversível para o tipo da variável. Por exemplo, string não pode ser convertido implicitamente para int. Portanto, depois de declarar i como um int, não é possível atribuir a cadeia de caracteres "Olá" a ela, como mostra o código a seguir:

int i;

// error CS0029: can't implicitly convert type 'string' to 'int'
i = "Hello";

No entanto, às vezes, talvez seja necessário copiar um valor para um parâmetro de variável ou método de outro tipo. Por exemplo, você pode ter uma variável de inteiro que precisa passar para um método cujo parâmetro é digitado como double. Ou talvez seja necessário atribuir uma variável de classe a uma variável de um tipo de interface. Esses tipos de operações são chamados de conversões de tipo. No C#, você pode executar os seguintes tipos de conversões:

  • Conversões implícitas: nenhuma sintaxe especial é necessária porque a conversão sempre é bem-sucedida e nenhum dado é perdido. Os exemplos incluem conversões de tipos integrais menores para maiores, conversões de classes derivadas para classes base e conversões de intervalo.

  • Conversões explícitas (casts): as conversões explícitas exigem uma expressão cast. O casting é necessário quando as informações podem ser perdidas no processo de conversão ou quando a conversão pode não ter êxito por outros motivos. Exemplos típicos incluem conversão numérica em um tipo que tem menos precisão ou um intervalo menor e conversão de uma instância de classe base em uma classe derivada.

  • Conversões definidas pelo usuário: as conversões definidas pelo usuário usam métodos especiais que você pode definir para habilitar conversões explícitas e implícitas entre tipos personalizados que não têm uma relação de classe base derivada de classe. Para saber mais, confira Operadores de conversão definidos pelo usuário.

  • Conversões com classes auxiliares: para converter entre tipos não compatíveis, como inteiros e System.DateTime objetos, ou cadeias de caracteres hexadecimal e matrizes de bytes, você pode usar a System.BitConverter classe, a System.Convert classe e os Parse métodos dos tipos numéricos internos, como Int32.Parse. Para obter mais informações, consulte os seguintes artigos:

  • Como converter uma matriz de bytes em um int

  • Como converter uma cadeia de caracteres em um número

  • Como converter entre cadeias de caracteres hexadecimal e tipos numéricos

Conversões implícitas

Para tipos numéricos internos, uma conversão implícita pode ser feita quando o valor a ser armazenado pode caber na variável sem ser truncado ou arredondado. Para tipos integrais, essa restrição significa que o intervalo do tipo de origem é um subconjunto adequado do intervalo para o tipo de destino. Por exemplo, uma variável do tipo long (inteiro de 64 bits) pode armazenar qualquer valor que um int (inteiro de 32 bits) possa armazenar. No exemplo a seguir, o compilador converte implicitamente o valor da num direita em um tipo long antes de atribuí-lo a bigNum.

// Implicit conversion. A long can
// hold any value an int can hold, and more!
int num = 2147483647;
long bigNum = num;

Para obter uma lista completa de todas as conversões numéricas implícitas, consulte a seção conversões numéricas implícitas do artigo conversões numéricas internas .

Para tipos de referência, sempre existe uma conversão implícita de uma classe para qualquer uma de suas classes ou interfaces base diretas ou indiretas. Nenhuma sintaxe especial é necessária porque uma classe derivada sempre contém todos os membros de uma classe base.

Derived d = new Derived();

// Always OK.
Base b = d;

Conversões explícitas

No entanto, se uma conversão não puder ser realizada sem o risco de perda de informações, o compilador exigirá que você execute uma conversão explícita, que é chamada de cast. Um cast é uma forma de fazer a conversão explicitamente. Isso indica que você está ciente de que a perda de dados pode ocorrer ou a conversão pode falhar em tempo de execução. Para executar uma conversão, especifique o tipo de destino entre parênteses antes da expressão que você deseja converter. O programa a seguir converte um double em um int. O programa não compila sem a conversão.

double x = 1234.7;
int a;
// Cast double to int.
a = (int)x;
Console.WriteLine(a);
// Output: 1234

Para uma lista completa de conversões numéricas explícitas com suporte, consulte a seção Conversões numéricas explícitas do artigo Conversões numéricas nativas.

Para tipos de referência, uma conversão explícita será necessária se você precisar converter de um tipo base para um tipo derivado:

Uma operação de conversão entre tipos de referência não altera o tipo de execução em tempo real do objeto subjacente; ela apenas altera o tipo do valor que está sendo usado como referência para esse objeto. Para obter mais informações, consulte Polymorphism.

Exceções de conversão de tipo durante a execução

Em algumas conversões de tipo de referência, o compilador não pode determinar se uma conversão é válida. É possível que uma operação de conversão que é compilada corretamente falhe em tempo de execução. Conforme mostrado no exemplo a seguir, um tipo de conversão que falha em tempo de execução faz com que uma InvalidCastException seja lançada.

Animal a = new Mammal();
Reptile r = (Reptile)a; // InvalidCastException at run time

Converter explicitamente o argumento a em um Reptile faz uma suposição perigosa. É mais seguro não fazer suposições, mas sim verificar o tipo. O C# fornece o is operador para permitir que você teste a compatibilidade antes de realmente executar uma conversão. Para saber mais, confira Como converter com segurança usando a correspondência de padrões e os operadores “is” e “as”.

Especificação da linguagem C#

Para obter mais informações, consulte a seção Conversões da especificação da linguagem C#.

Consulte também