C# - Comparando os operadores is e as

Hoje vamos comparar os operadores is e as usados na linguagem C#.

Hoje veremos um conceito básico da linguagem C# que você tem a obrigação de conhecer.

Segundo a Microsoft :

O operador is verifica se o resultado de uma expressão é compatível com um tipo fornecido ou (a partir do C# 7.0) testa uma expressão em relação a um padrão.

O operador as converte explicitamente o resultado de uma expressão para uma determinada referência ou tipo de valor anulável. Se a conversão não for possível, o operador as retorna null e não lança uma exceção.

Vejamos a seguir algumas das principais diferenças entre esses operadores:

Operador is	Operador as
È usado para verificar se o tipo de tempo de execução de um objeto é compatível com o tipo especificado ou não	È usado para executar a conversão entre tipos de referência compatíveis ou tipos anuláveis.
É do tipo booleano	Não é do tipo booleano
Retorna true se o objeto especificado é do mesmo tipo	Retorna o objeto quando eles são compatíveis com o tipo especificado.
Retorna false se o objeto especificado não for do mesmo tipo	Retorna null se a conversão não for possível.
É usado apenas para conversões de referência, boxe e unboxing	É usado apenas para conversões anuláveis, de referência e boxing
Uso: bool isobject = (Object is Type);	Uso: Type obj = Object as Type;

A seguir vejamos um exemplo prático de uso de cada um destes operadores.

recursos usados:

Visual Studio 2019 Community Edition

Criando o projeto C# no VS 2019

Crie um projeto Console do tipo .NET Core chamado CShp_IsAs;

Inclua o código a seguir no arquivo Programcs a definição das classes Aluno e Funcionario:

Obs: Usamos o namespace: using static System.Console;

   class Aluno
    {
        public string Nome { get; set; }
        public int Idade { get; set; }
    }


    class Funcionario
    {
        public string Nome { get; set; }
        public int Idade { get; set; }
        public double Salario { get; set; }

A seguir na classe Program vamos incluir o código abaixo no método Main():

 static void Main(string[] args)
 {
      UsandoOperadorIs();
      UsandoOperadorAs();
      ReadLine();
 }

A seguir temos o código que mostra o uso do operador is no método UsandoOperadorIs():

      private static void UsandoOperadorIs()
        {
            Aluno aluno1 = new Aluno();
            aluno1.Nome = "Amanda";
            aluno1.Idade = 15;

            Funcionario funcionario1 = new Funcionario();
            funcionario1.Nome = "Macoratti";
            funcionario1.Salario = 5000;
            funcionario1.Idade = 25;

            // Verifica se funcionario é do tipo Aluno
            bool isAluno = funcionario1 is Aluno;
            WriteLine($"funcionario1 é um Aluno ?: {isAluno.ToString()}");

            // Verifica se aluno é do tipo Aluno
            isAluno = (aluno1 is Aluno);
            WriteLine($"aluno1 é um Aluno ?: {isAluno.ToString()}");

            aluno1 = null;
            // Verifica o objeto tipo Null
            isAluno = (aluno1 is Aluno);
            WriteLine($"aluno1(null) é um Aluno ?: {isAluno.ToString()}");
        }

O resultado obtido é visto abaixo:

A seguir temos o código que mostra o uso do operador as no método UsandoOperadorAs():

      private static void UsandoOperadorAs()
       {
            Aluno aluno1 = new Aluno();
            aluno1.Nome = "Amanda";
            aluno1.Idade = 15;

            Funcionario funcionario1 = new Funcionario();
            funcionario1.Nome = "Macoratti";
            funcionario1.Salario = 5000;
            funcionario1.Idade = 25;

            WriteLine($"funcionario1 é um Aluno ?: {VerificaEConverte(funcionario1)}");

            WriteLine($"aluno1 é um Aluno ?: {VerificaEConverte(aluno1)}");
     }

Aqui precisamos criar o método VerificaEConverte() para usar o operador as:

        public static string VerificaEConverte(dynamic obj)
        {
            // Se obj é do tipo Aluno ele atribui um valor para alunobj
            // caso contrário atribui null
            Aluno alunobj = obj as Aluno;
            if (alunobj != null)
                return "O objeto é um Aluno e seu nome é " + alunobj.Nome;

            return "Não é um Aluno";
        }

O resultado obtido é visto abaixo:

As vantagens em usar as ao invés de is

No caso d operador is, para realizar um cast para Tipo, precisamos executar duas etapas:

Verificar o Tipo usando is;
Se for true então fazemos o cast para o Tipo;

Isso afeta o desempenho, pois cada vez que a CLR passa pela hierarquia de herança, verificando cada tipo base com o tipo especificado.

Usando o operador as isso será feito em uma única etapa.

Assim usamos o operador is somente para verificar o tipo.

Pegue o código do projeto aqui: CShp_IsAs.zip

"Se o mundo vos odeia, sabei que, primeiro do que a vós, me odiou a mim.
Se vós fôsseis do mundo, o mundo amaria o que era seu, mas porque não sois do mundo, antes eu vos escolhi do mundo, por isso é que o mundo vos odeia."
João 15:18,19

Referências:

José Carlos Macoratti