Operadores as e is no C#

O que são os operadores is e as no C#

Os operadores is e as pertencem à família dos operadores de teste de tipo e conversão da linguagem. Além deles, essa família inclui o typeof e as expressões de cast, como (T)valor.

Em resumo, o is responde a uma pergunta simples: o valor em tempo de execução é compatível com determinado tipo? Por outro lado, o as tenta converter o valor para um tipo de referência e devolve null quando a conversão não é possível.

Na prática, os dois substituem trechos verbosos que usam GetType, typeof e casts com parênteses. Por isso, eles aparecem com frequência em código de domínio, em validações e em tratamentos de nulos.

Operadores is e as: um pouco de história

Muita gente associa os operadores is e as às versões recentes do C#, mas eles existem desde a primeira versão da linguagem. De fato, o que mudou ao longo do tempo foi o poder do is, que ganhou pattern matching.

No C# 7, o is passou a aceitar padrões, como a declaração de variável (obj is Passport passport) e o padrão constante is null. Em seguida, o C# 9 trouxe os padrões lógicos and, or e not, o que permitiu escrever is not null.

Já o C# 10 ampliou os padrões de propriedade, permitindo acessar propriedades aninhadas dentro do próprio padrão. Ou seja, cada versão tornou os operadores is e as mais expressivos, sem quebrar o código antigo.

Você pode conferir essa evolução no histórico de versões do C# no Microsoft Learn. Além disso, a documentação oficial detalha cada padrão suportado pela linguagem.

Como funciona o operador is

O is é um operador de comparação que verifica se o tipo de um valor em tempo de execução é compatível com outro tipo. Ele funciona tanto com tipos primitivos quanto com tipos complexos, como classes e records.

O resultado é sempre um bool, e essa é a primeira diferença entre os operadores is e as. Assim, você pode usar a expressão diretamente em um if, em um return ou em qualquer lugar que espere um valor lógico.

var someText = "This is a string";

// Retorna um bool
var result = someText.GetType() == typeof(string);

var result = someText is string;

object animal = new Giraffe();

Console.WriteLine(animal is Animal);                  // True
Console.WriteLine(animal.GetType() == typeof(Animal)); // False

public class Animal { }
public class Giraffe : Animal { }

// Documento base e seus tipos derivados
public record Document;
public record Cpf : Document;
public record Cnpj : Document;
public record Passport : Document;

var passport = new Passport();

if (passport is Document)
    Console.WriteLine("Passport is a document");

if (student == null)
    Console.WriteLine("Null");

if (student != null)
    Console.WriteLine("Not null");

if (student is null)
    Console.WriteLine("Null");

if (student is not null)
    Console.WriteLine("Not null");

object document = new Cpf();

if (document is Cpf cpf)
{
    // cpf já está tipado como Cpf aqui dentro
    Console.WriteLine($"Valid document: {cpf}");
}

static bool IsBusinessHour(int hour) => hour is >= 8 and < 18;

static bool IsFirstFridayOfOctober(DateTime date) =>
    date is { Month: 10, Day: <= 7, DayOfWeek: DayOfWeek.Friday };

public record Point(int X, int Y);
public record Segment(Point Start, Point End);

// Verifica se alguma ponta do segmento está no eixo X
static bool IsAnyEndOnXAxis(Segment segment) =>
    segment is { Start.Y: 0 } or { End.Y: 0 };

IEnumerable<int> numbers = new List<int> { 10, 20, 30 };

// Tenta usar o acesso por índice quando disponível
if (numbers is IList<int> list)
    Console.WriteLine(list[0] + list[list.Count - 1]); // 40

int quantity = 27;
Console.WriteLine(quantity is IFormattable); // True

object boxed = quantity;
Console.WriteLine(boxed is int);  // True
Console.WriteLine(boxed is long); // False

Como funciona o operador as

O as é outro operador útil, porque faz conversões explícitas de objetos de forma segura. É comum ver o tipo entre parênteses na frente da variável para fazer a conversão.

Document document = new Cpf();
var cpf = (Cpf)document;

Por outro lado, você pode escrever a mesma conversão de forma mais elegante usando as no lugar de (Cpf).

Document document = new Cpf();
var cpf = document as Cpf;

Document document = new Passport();

var cpf = document as Cpf; // cpf recebe null

var other = (Cpf)document; // lança InvalidCastException

var cpf = document as Cpf;

if (cpf is not null)
    Console.WriteLine("Conversion succeeded");

object boxed = 42;

var number = boxed as int?; // funciona, número anulável
// var invalid = boxed as int; // erro de compilação

// Sem a restrição class, o compilador rejeita o uso do as
public static T? TryConvert<T>(object value) where T : class
    => value as T;

Operadores is e as juntos: quando usar cada um

Os operadores is e as resolvem problemas parecidos, mas cada um brilha em uma situação. Primeiro, use o is simples quando você só precisa de um bool para decidir um fluxo.

Em seguida, prefira o is com declaração de variável quando você precisa testar e usar o objeto convertido. Esse padrão substitui a dupla as mais checagem de nulo em grande parte dos casos.

// Antes: as seguido de checagem de nulo
var cpf = document as Cpf;
if (cpf != null)
    Validate(cpf);

// Depois: is com declaração de variável
if (document is Cpf validCpf)
    Validate(validCpf);

Por fim, entre os operadores is e as, use o as quando o valor convertido pode legitimamente ser null e o restante do código já trata esse caso. Um exemplo típico é o encadeamento com o operador ?. ou com o ??.

var number = (document as Cpf)?.Number ?? "unknown";

Já o cast tradicional continua útil quando a conversão precisa funcionar e os operadores is e as não fazem sentido. Nesse cenário, uma exceção imediata indica um bug real e ajuda a encontrar o problema mais cedo.

Exemplo completo com documentos

Para fechar a parte prática, vamos juntar os conceitos em um pequeno serviço de validação. O método recebe um Document genérico e decide o que fazer conforme o tipo real.

public record Document;
public record Cpf(string Number) : Document;
public record Cnpj(string Number) : Document;
public record Passport(string Number, string Country) : Document;

public static class DocumentValidator
{
    public static string Describe(Document? document)
    {
        // Checagem de nulo sem depender do operador ==
        if (document is null)
            return "No document provided";

        // Teste de tipo com declaração de variável
        if (document is Cpf cpf)
            return $"CPF {cpf.Number}";

        // Padrão de propriedade combinado com tipo
        if (document is Passport { Country: "BR" } passport)
            return $"Brazilian passport {passport.Number}";

        // Conversão segura que pode resultar em null
        var cnpj = document as Cnpj;
        return cnpj?.Number ?? "Unknown document";
    }
}

Nesse exemplo, cada técnica aparece no lugar em que faz mais sentido. Primeiro, o is null protege a entrada; em seguida, o padrão de declaração trata o CPF sem cast extra.

Depois, o padrão de propriedade filtra apenas passaportes brasileiros. Por fim, o as com ?. e ?? mostra um caso em que o null faz parte do fluxo esperado.

Com isso, você vê os operadores is e as trabalhando juntos em um código curto, legível e sem exceções inesperadas.

Erros comuns com os operadores is e as

Um erro frequente com os operadores is e as é testar o tipo com is e, logo depois, fazer um cast manual. Assim, o runtime verifica o tipo duas vezes sem necessidade.

// Evite: dois testes de tipo
if (document is Cpf)
{
    var cpf = (Cpf)document;
}

// Prefira: um único teste
if (document is Cpf cpf)
{
    // use cpf
}

Outro erro comum é usar o as e esquecer a checagem de nulo. Nesse caso, a falha aparece longe da origem, o que dificulta o diagnóstico.

Também vale lembrar que o is retorna false para valores nulos. Então, null is Document nunca resulta em true, mesmo que a variável tenha sido declarada como Document.

Por último, cuidado com a herança ao trocar typeof por is. Se a regra de negócio exige o tipo exato, o is pode aceitar classes filhas que você não esperava.

Boas práticas com os operadores is e as

Para tirar proveito dos operadores is e as, adote algumas práticas simples no seu time. Em primeiro lugar, padronize is null e is not null para checagens de nulo.

Em segundo lugar, prefira pattern matching ao par as mais if, porque o código fica mais curto e o escopo da variável fica mais claro. Além disso, analisadores do Visual Studio e do Roslyn costumam sugerir essa troca automaticamente.

Também é importante reservar o as para cenários em que o null faz parte do fluxo esperado. Dessa forma, quem lê o código entende que a conversão pode falhar sem que isso seja um erro.

Por fim, combine os operadores is e as com o recurso de nullable reference types. Com isso, o compilador ajuda a identificar pontos em que um resultado do as pode ser nulo e ainda não foi tratado.

Se você quiser se aprofundar nas mudanças recentes sobre nulos na linguagem, veja o artigo sobre as mudanças no null do .NET 10 e C# 14. Para conversões de texto em números, o artigo sobre Parse e TryParse no C# complementa bem este conteúdo.

Conclusão

Os operadores is e as são simples, mas melhoram muito o código, porque entregam mais legibilidade e facilitam o entendimento. O is testa tipos, checa nulos e ainda declara variáveis com pattern matching.

Enquanto isso, o as converte objetos sem lançar exceções e devolve null quando a conversão falha. Portanto, entender a diferença entre os operadores is e as e o cast tradicional evita bugs silenciosos e torna suas intenções claras para o time.

Agora, revise um trecho do seu projeto que ainda usa typeof ou casts encadeados. Em seguida, aplique os padrões deste guia e compare a legibilidade antes e depois da mudança.

FAQ

Os operadores is e as surgiram no C# 10?

Não, os dois existem desde a primeira versão do C#. As versões 7, 9 e 10 apenas ampliaram o pattern matching do operador is.

Qual a diferença entre as e cast no C#?

O cast lança InvalidCastException quando a conversão falha. Já o as retorna null e nunca lança exceção.

Posso usar as com int ou outros tipos de valor?

Somente com tipos anuláveis, como int?. Com um int puro, o compilador gera um erro.

Por que preferir is null em vez de == null?

O is null sempre testa a referência real. Por outro lado, o == pode ter uma sobrecarga que altera o resultado.

O is considera herança?

Sim, o is retorna true para tipos derivados e interfaces implementadas. Para checar o tipo exato, use GetType() == typeof(T).