Operadores de teste de tipo e expressão de conversão (referência C#)Type-testing operators and cast expression (C# reference)

Você pode usar os seguintes operadores e expressões para executar verificação de tipo ou conversão de tipo:You can use the following operators and expressions to perform type checking or type conversion:

  • operador is: para verificar se o tipo de runtime de uma expressão é compatível com um determinado tipois operator: to check if the runtime type of an expression is compatible with a given type
  • operador as: para converter explicitamente uma expressão em um determinado tipo, se o tipo de runtime for compatível com esse tipoas operator: to explicitly convert an expression to a given type if its runtime type is compatible with that type
  • expressão de conversão: para executar uma conversão explícitacast expression: to perform an explicit conversion
  • operador typeof: para obter a instância System.Type para um tipotypeof operator: to obtain the System.Type instance for a type

Operador isis operator

O operador is verifica se o tipo de runtime de um resultado de expressão é compatível com um determinado tipo.The is operator checks if the runtime type of an expression result is compatible with a given type. A partir do C# 7,0, o is operador também testa um resultado de expressão em relação a um padrão.Beginning with C# 7.0, the is operator also tests an expression result against a pattern.

A expressão com o operador is de teste de tipo tem o seguinte formatoThe expression with the type-testing is operator has the following form

E is T

em que E é uma expressão que retorna um valor e T é o nome de um tipo ou um parâmetro de tipo.where E is an expression that returns a value and T is the name of a type or a type parameter. E não pode ser um método anônimo ou uma expressão lambda.E cannot be an anonymous method or a lambda expression.

A expressão E is T retorna true se o resultado de E não for nulo e puder ser convertido para o tipo T por uma conversão de referência, uma conversão boxing ou uma conversão unboxing; caso contrário, retorna false.The E is T expression returns true if the result of E is non-null and can be converted to type T by a reference conversion, a boxing conversion, or an unboxing conversion; otherwise, it returns false. O operador is não considera conversões definidas pelo usuário.The is operator doesn't consider user-defined conversions.

O exemplo a seguir demonstra que o operador is retorna true se o tipo de runtime de um resultado da expressão é derivado de um determinado tipo, ou seja, existe uma conversão de referência entre tipos:The following example demonstrates that the is operator returns true if the runtime type of an expression result derives from a given type, that is, there exists a reference conversion between types:

public class Base { }

public class Derived : Base { }

public static class IsOperatorExample
{
    public static void Main()
    {
        object b = new Base();
        Console.WriteLine(b is Base);  // output: True
        Console.WriteLine(b is Derived);  // output: False

        object d = new Derived();
        Console.WriteLine(d is Base);  // output: True
        Console.WriteLine(d is Derived); // output: True
    }
}

O exemplo a seguir mostra que o is operador leva em consideração as conversões boxing e unboxing, mas não considera as conversões numéricas:The next example shows that the is operator takes into account boxing and unboxing conversions but doesn't consider numeric conversions:

int i = 27;
Console.WriteLine(i is System.IFormattable);  // output: True

object iBoxed = i;
Console.WriteLine(iBoxed is int);  // output: True
Console.WriteLine(iBoxed is long);  // output: False

Para saber mais sobre conversões em C#, confira o capítulo Conversões da Especificação da linguagem C#.For information about C# conversions, see the Conversions chapter of the C# language specification.

Teste de tipo com correspondência de padrõesType testing with pattern matching

A partir do C# 7,0, o is operador também testa um resultado de expressão em relação a um padrão.Beginning with C# 7.0, the is operator also tests an expression result against a pattern. Em particular, ele dá suporte ao padrão de tipo da seguinte forma:In particular, it supports the type pattern in the following form:

E is T v

em que E é uma expressão que retorna um valor, T é o nome de um tipo ou um parâmetro de tipo, e v é uma nova variável local do tipo T.where E is an expression that returns a value, T is the name of a type or a type parameter, and v is a new local variable of type T. Se o resultado de E não for nulo e puder ser convertido para T por uma conversão de referência, boxing ou unboxing, a expressão E is T v retornará true e o valor convertido do resultado de Eserá atribuído à variável v.If the result of E is non-null and can be converted to T by a reference, boxing, or unboxing conversion, the E is T v expression returns true and the converted value of the result of E is assigned to variable v.

O exemplo a seguir demonstra o uso do operador is com um padrão de tipo:The following example demonstrates the usage of the is operator with the type pattern:

int i = 23;
object iBoxed = i;
int? jNullable = 7;
if (iBoxed is int a && jNullable is int b)
{
    Console.WriteLine(a + b);  // output 30
}

Para saber mais sobre o padrão de tipos e outros padrões com suporte, confira Correspondência de padrões com is.For more information about the type pattern and other supported patterns, see Pattern matching with is.

Operador asas operator

O operador as converte explicitamente o resultado de uma expressão para uma determinada referência ou tipo de valor anulável.The as operator explicitly converts the result of an expression to a given reference or nullable value type. Se a conversão não for possível, o operador as retorna null.If the conversion is not possible, the as operator returns null. Ao contrário de uma expressão de conversão, o as operador nunca gera uma exceção.Unlike a cast expression, the as operator never throws an exception.

A expressão da formaThe expression of the form

E as T

em que E é uma expressão que retorna um valor e T é o nome de um tipo ou um parâmetro de tipo, produz o mesmo resultado quewhere E is an expression that returns a value and T is the name of a type or a type parameter, produces the same result as

E is T ? (T)(E) : (T)null

exceto que E é avaliado apenas uma vez.except that E is only evaluated once.

O operador as considera apenas as conversões de referência, anulável, boxing e unboxing.The as operator considers only reference, nullable, boxing, and unboxing conversions. Não é possível usar o operador as para executar uma conversão definida pelo usuário.You cannot use the as operator to perform a user-defined conversion. Para fazer isso, use uma expressão de conversão.To do that, use a cast expression.

O exemplo a seguir demonstra o uso do operador as:The following example demonstrates the usage of the as operator:

IEnumerable<int> numbers = new[] { 10, 20, 30 };
IList<int> indexable = numbers as IList<int>;
if (indexable != null)
{
    Console.WriteLine(indexable[0] + indexable[indexable.Count - 1]);  // output: 40
}

Observação

Como mostrado no exemplo anterior, você precisa comparar o resultado da expressão as com null para verificar se uma conversão foi bem-sucedida.As the preceding example shows, you need to compare the result of the as expression with null to check if the conversion is successful. A partir do C# 7,0, você pode usar o operador is para testar se a conversão é bem sucedido e, se tiver sucesso, atribuir seu resultado a uma nova variável.Beginning with C# 7.0, you can use the is operator both to test if the conversion succeeds and, if it succeeds, assign its result to a new variable.

Expressão de conversãoCast expression

Uma expressão de conversão do formulário (T)E realiza uma conversão explícita do resultado da expressão E para o tipo T.A cast expression of the form (T)E performs an explicit conversion of the result of expression E to type T. Se não existir nenhuma conversão explícita do tipo E para o tipo T, ocorrerá um erro em tempo de compilação.If no explicit conversion exists from the type of E to type T, a compile-time error occurs. No tempo de execução, uma conversão explícita pode não ter êxito e uma expressão de conversão pode lançar uma exceção.At run time, an explicit conversion might not succeed and a cast expression might throw an exception.

O exemplo a seguir demonstra conversões numéricas e de referência explícitas:The following example demonstrates explicit numeric and reference conversions:

double x = 1234.7;
int a = (int)x;
Console.WriteLine(a);   // output: 1234

IEnumerable<int> numbers = new int[] { 10, 20, 30 };
IList<int> list = (IList<int>)numbers;
Console.WriteLine(list.Count);  // output: 3
Console.WriteLine(list[1]);  // output: 20

Para saber mais sobre conversões explícitas sem suporte, confira a seção Conversões explícitas da Especificação da linguagem C#.For information about supported explicit conversions, see the Explicit conversions section of the C# language specification. Para saber mais sobre como definir uma conversão de tipo explícito ou implícito personalizado, confira Operadores de conversão definidos pelo usuário.For information about how to define a custom explicit or implicit type conversion, see User-defined conversion operators.

Outros usos de ()Other usages of ()

Você também usa parênteses para chamar um método ou chamar um delegado .You also use parentheses to call a method or invoke a delegate.

Outro uso dos parênteses é ajustar a ordem na qual as operações em uma expressão são avaliadas.Other use of parentheses is to adjust the order in which to evaluate operations in an expression. Para saber mais, confira Operadores C#.For more information, see C# operators.

Operador typeoftypeof operator

O operador typeof obtém a instância System.Type para um tipo.The typeof operator obtains the System.Type instance for a type. O argumento do operador typeof deve ser o nome de um tipo ou um parâmetro de tipo, como mostra o exemplo a seguir:The argument to the typeof operator must be the name of a type or a type parameter, as the following example shows:

void PrintType<T>() => Console.WriteLine(typeof(T));

Console.WriteLine(typeof(List<string>));
PrintType<int>();
PrintType<System.Int32>();
PrintType<Dictionary<int, char>>();
// Output:
// System.Collections.Generic.List`1[System.String]
// System.Int32
// System.Int32
// System.Collections.Generic.Dictionary`2[System.Int32,System.Char]

Você também pode usar o typeof operador com tipos genéricos não associados.You can also use the typeof operator with unbound generic types. O nome de um tipo genérico não associado deve conter o número apropriado de vírgulas, que é um a menos que o número de parâmetros de tipo.The name of an unbound generic type must contain the appropriate number of commas, which is one less than the number of type parameters. O exemplo a seguir mostra o uso do operador typeof com um tipo genérico não associado:The following example shows the usage of the typeof operator with an unbound generic type:

Console.WriteLine(typeof(Dictionary<,>));
// Output:
// System.Collections.Generic.Dictionary`2[TKey,TValue]

Uma expressão não pode ser um argumento do operador typeof.An expression cannot be an argument of the typeof operator. Para obter a System.Type instância para o tipo de tempo de execução de um resultado de expressão, use o Object.GetType método.To get the System.Type instance for the runtime type of an expression result, use the Object.GetType method.

Teste de tipo com o operador typeofType testing with the typeof operator

Use o operador typeof para verificar se o tipo de runtime do resultado da expressão corresponde exatamente a um determinado tipo.Use the typeof operator to check if the runtime type of the expression result exactly matches a given type. O exemplo a seguir demonstra a diferença entre a verificação de tipo executada com o operador typeof e o operador is:The following example demonstrates the difference between type checking performed with the typeof operator and the is operator:

public class Animal { }

public class Giraffe : Animal { }

public static class TypeOfExample
{
    public static void Main()
    {
        object b = new Giraffe();
        Console.WriteLine(b is Animal);  // output: True
        Console.WriteLine(b.GetType() == typeof(Animal));  // output: False

        Console.WriteLine(b is Giraffe);  // output: True
        Console.WriteLine(b.GetType() == typeof(Giraffe));  // output: True
    }
}

Capacidade de sobrecarga do operadorOperator overloadability

Os is as operadores, e typeof não podem ser sobrecarregados.The is, as, and typeof operators cannot be overloaded.

Um tipo definido pelo usuário não pode sobrecarregar o operador (), mas pode definir conversões de tipo customizado que podem ser executadas por uma expressão de conversão.A user-defined type cannot overload the () operator, but can define custom type conversions that can be performed by a cast expression. Para saber mais, confira Operadores de conversão definidos pelo usuário.For more information, see User-defined conversion operators.

especificação da linguagem C#C# language specification

Para obter mais informações, confira as seguintes seções da especificação da linguagem C#:For more information, see the following sections of the C# language specification:

Consulte tambémSee also