Compartilhar via

Elenco e conversões de Tipo (guia de programação de C#)

  • Artigo

Como o C# é estaticamente tipado no momento de compilar, após uma variável ser declarada, ela não pode ser declarada novamente ou usada para armazenar valores de outro tipo a menos que esse tipo seja conversível para o tipo da variável. Por exemplo, não há nenhuma conversão de inteiro para qualquer seqüência de caracteres arbitrária. Portanto, após você declarar i como um inteiro, você não pode atribuir a seqüência de caracteres "Hello" a ele, como é mostrado no código a seguir.

int i;
i = "Hello"; // Error: "Cannot implicitly convert type 'string' to 'int'"

No entanto, às vezes, talvez seja necessário copiar um valor para um parâmetro de método ou variável de outro tipo. Por exemplo, você pode ter uma variável de inteiro que você precisa passar para um método cujo parâmetro é digitado como double. Ou talvez você precise 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. C#, você pode executar os seguintes tipos de conversões:

Conversões implícitas

Para tipos numéricos internos (ou primitivos), uma conversão implícita pode ser feita quando o valor a ser armazenado puder caber na varíavel, sem ser truncado ou arredondado. Por exemplo, uma variável do tipo longo (inteiro de 8 bytes) que pode armazenar qualquer valor que uma int (4 bytes em um computador de 32 bits) pode armazenar. No exemplo a seguir, o compilador converte implicitamente o valor à direita para um tipo de long antes de atribuí-lo para bigNum.

// Implicit conversion. num 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 implícitas de numéricas, consulte Implicit Numeric Conversions Table (C# Reference).

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

Derived d = new Derived();
Base b = d; // Always OK.

Conversões explícitas

No entanto, se uma conversão não pode ser feita sem risco de perda de informações, o compilador requer que você executar uma conversão explícita, o que é chamada de um cast. A projeção é uma maneira de informar explicitamente o compilador, que você pretende fazer a conversão e que você está ciente de que pode ocorrer perda de dados. Para executar uma conversão, especifique o tipo que são a projeção para entre parênteses na frente do valor ou variável a ser convertido. O seguinte programa projeções de um double para um int. O programa não será compilado sem a projeção.

class Test
{
    static void Main()
    {
        double x = 1234.7;
        int a;
        // Cast double to int.
        a = (int)x;
        System.Console.WriteLine(a);
    }
}
// Output: 1234

Para obter uma lista as conversões explícitas numéricas permitidos, consulte Explicit Numeric Conversions Table (C# Reference).

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

// Create a new derived type.
Giraffe g = new Giraffe();

// Implicit conversion to base type is safe.
Animal a = g;

// Explicit conversion is required to cast back
// to derived type. Note: This will compile but will
// throw an exception at run time if the right-side
// object is not in fact a Giraffe.
Giraffe g2 = (Giraffe) a;

Uma operação de conversão entre tipos de referência não altera o tipo de tempo de execução do objeto subjacente; Ele apenas altera o tipo do valor que está sendo usado como uma referência a esse objeto. Para obter mais informações, consulte Polymorphism (C# Programming Guide).

Exceções de conversão de tipo em tempo de execução

Em algumas conversões de tipo de referência, o compilador não pode determinar se uma conversão será válida. É possível que uma operação de conversão compila corretamente falhar em tempo de execução. Conforme mostrado no exemplo a seguir, um tipo de projeção de falhar em tempo de execução causará um InvalidCastException ser acionada.


class Animal
{
    public void Eat() { Console.WriteLine("Eating."); }
    public override string ToString()
    {
        return "I am an animal.";
    }
}
class Reptile : Animal { }
class Mammal : Animal { }

class UnSafeCast
{
    static void Main()
    {            
        Test(new Mammal());

        // Keep the console window open in debug mode.
        System.Console.WriteLine("Press any key to exit.");
        System.Console.ReadKey();
    }

    static void Test(Animal a)
    {
        // Cause InvalidCastException at run time 
        // because Mammal is not convertible to Reptile.
        Reptile r = (Reptile)a;
    }

}

C# fornece a é e como operadores para que você possa testar a compatibilidade antes de realmente executar uma conversão. Para obter mais informações, consulte How to: Convertida com segurança usando como e for operadores (guia de programação C#).

Especificação da linguagem C#

Para obter mais informações, consulte C# Language Specification A especificação de linguagem é a fonte definitiva para a sintaxe e o uso de C#.

Consulte também

Tarefas

How to: Converter uma seqüência em um int (guia de programação C#)

Referência

Tipos (guia de programação de C#)

Operador de () (C# referência)

(C# referência explícita)

(C# referência implícita)

Operadores de conversão (guia de programação de C#)

Conceitos

C# Programming Guide

Conversão de tipo generalizada

Conversão de tipo exportado

Histórico de alterações

Date

History

Motivo

Junho de 2010

Revisado a definição de conversões explícitas na introdução.

Comentários do cliente.