Partilhar via

Operadores de teste de tipo e expressões de molde - is, as, typeofe moldes

Esses operadores e expressões executam verificação de tipo ou conversão de tipo. O isoperador verifica se o tipo de tempo de execução de uma expressão é compatível com um determinado tipo. O asoperador converte explicitamente uma expressão em um determinado tipo se seu tipo de tempo de execução for compatível com esse tipo. As expressões de transmissão executam uma conversão explícita para um tipo de destino. O typeofoperador obtém a System.Type instância para um tipo.

A referência da linguagem C# documenta a versão mais recentemente lançada da linguagem C#. Contém também documentação inicial para funcionalidades em versões preliminares públicas para a próxima versão da linguagem.

A documentação identifica qualquer funcionalidade introduzida pela primeira vez nas últimas três versões da língua ou em pré-visualizações públicas atuais.

Sugestão

Para saber quando uma funcionalidade foi introduzida pela primeira vez em C#, consulte o artigo sobre o histórico de versões da linguagem C#.

O operador is

O is operador verifica se o tipo de tempo de execução de um resultado de expressão é compatível com um determinado tipo. O is operador também testa um resultado de expressão em relação a um padrão.

A expressão com o operador de teste is de tipo tem a seguinte forma

E is T

Onde E é uma expressão que retorna um valor e T é o nome de um tipo ou um parâmetro de tipo. E não pode ser um método anônimo ou uma expressão lambda.

O is operador retorna true quando um resultado de expressão é não-nulo e qualquer uma das seguintes condições são verdadeiras:

  • O tipo de tempo de execução de um resultado de expressão tem uma conversão de identidade para T.

  • O tipo de tempo de execução de um resultado de expressão deriva do tipo T, implementa a interface Tou outra conversão de referência implícita existe dele para T. Esta condição abrange relações de herança e implementações de interfaces.

  • O tipo de tempo de execução de um resultado de expressão é um tipo de valor anulável com o tipo T subjacente e o Nullable<T>.HasValue is true.

  • Existe uma conversão de boxing ou unboxing do tipo de tempo de execução de um resultado de expressão para tipo T quando a expressão não é uma instância de um ref struct.

O is operador não considera conversões definidas pelo usuário ou conversões de extensão implícitas.

O exemplo a seguir demonstra que o is operador retorna true se o tipo de tempo de execução de um resultado de expressão deriva de um determinado tipo, ou seja, existe uma conversão de referência entre tipos:

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 próximo exemplo mostra que o operador leva em conta as is conversões de boxe e unboxing, mas não considera as conversões numéricas:

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 obter informações sobre conversões em C#, consulte o capítulo Conversões da especificação da linguagem C#.

Teste de tipo com correspondência de padrões

O is operador também testa um resultado de expressão em relação a um padrão. O exemplo a seguir mostra como usar um padrão de declaração para verificar o tipo de tempo de execução de uma expressão:

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 obter informações sobre os padrões suportados, consulte Padrões.

O operador as

Use o as operador para converter explicitamente o resultado de uma expressão num dado tipo de referência ou valor nulo. Se a conversão não for possível, o as operador retornará null. Ao contrário de uma expressão de elenco, o as operador nunca lança uma exceção.

A expressão da forma

E as T

Onde 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 que

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

Só que E só é avaliada uma vez.

O as operador considera apenas conversões de referência, anuláveis, boxe e unboxing. Não é possível usar o as operador para executar uma conversão definida pelo usuário. Para realizar uma conversão definida pelo utilizador, use uma expressão cast.

O exemplo a seguir demonstra o uso do as operador:

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

Nota

Como mostra o exemplo anterior, você precisa comparar o as resultado da expressão com null para verificar se a conversão foi bem-sucedida. Você pode usar o is operador para testar se a conversão é bem-sucedida e, se for bem-sucedida, atribuir seu resultado a uma nova variável.

Expressão de elenco

Uma expressão cast da forma (T)E converte explicitamente o resultado da expressão E para o tipo T. Se não existir conversão explícita do tipo de E para o tipo T, o compilador emite um erro. Em tempo de execução, uma conversão explícita pode não ter êxito e uma expressão de elenco pode lançar uma exceção.

O exemplo a seguir demonstra conversões numéricas e de referência explícitas:

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

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

Para obter informações sobre conversões explícitas suportadas, consulte a seção Conversões explícitas da especificação da linguagem C#. Para obter informações sobre como definir uma conversão de tipo explícita ou implícita personalizada, consulte Operadores de conversão definidos pelo usuário.

Outros usos de ()

Você também usa parênteses para chamar um método ou invocar um delegado.

Outro uso dos parênteses é ajustar a ordem em que C# avalia as operações numa expressão. Para obter mais informações, consulte Operadores C#.

O operador typeof

O typeof operador obtém a System.Type instância para um tipo. O argumento para o typeof operador deve ser o nome de um tipo ou um parâmetro type, como mostra o exemplo a seguir:

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]

O argumento não pode ser um tipo que exija anotações de metadados. Exemplos destes tipos incluem os seguintes tipos:

  • dynamic
  • string? (ou qualquer tipo de referência anulável)

Esses tipos não são representados diretamente nos metadados. Os tipos incluem atributos que descrevem o tipo subjacente. Em ambos os casos, você pode usar o tipo subjacente. Em vez de dynamic, utilize object. Em vez de string?, utilize string.

Você também pode usar o typeof operador com tipos genéricos não acoplados. O nome de um tipo genérico não acoplado deve conter o número apropriado de vírgulas, que é um a menos do que o número de parâmetros de tipo. O exemplo a seguir mostra o typeof uso do operador com um tipo genérico não acoplado:

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

Uma expressão não pode ser um argumento do typeof operador. 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.

Ensaio de tipo com o typeof operador

Use o typeof operador para verificar se o tipo de tempo de execução do resultado da expressão corresponde exatamente a um determinado tipo. O exemplo seguinte demonstra a diferença entre a verificação de tipos feita usando o typeof operador e o is operador:

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 operador

Não pode sobrecarregar os isoperadores , as, e typeof .

Um tipo definido pelo utilizador não pode sobrecarregar o () operador, mas pode definir conversões de tipo personalizadas que uma expressão cast realiza. Para obter mais informações, consulte Operadores de conversão definidos pelo usuário.

Especificação da linguagem C#

Para obter mais informações, consulte as seguintes seções da especificação da linguagem C#:

Consulte também

  • Last updated on