C# 7.0 - Entendendo Pattern Matching  - I

 Hoje vou abordar o novo recurso Pattern  Matching introduzido na versão 7.0 da linguagem C#.

O recurso Pattern Matching ou Correspondência de padrões é um novo recurso que foi introduzido com o C# 7.0, que nos permite escrever código mais limpo e conciso em muitos cenários diferentes.

Esse recurso pode ser visto como uma extensão do operador is que já existe desde a primeira versão do C# e que é usado para verificar um tipo de um objeto em tempo de execução.

O recurso Pattern Matching adiciona mais poder ao operador is e a cláusula switch permitindo atribuir o resultado a uma variável após realizar a verificação de tipo. (Antes era comum ter que usar um 'cast' para fazer a atribuição)

Vamos ver como isso funciona usando a expressão Is.

Antes do C# 7.0, o operador Is era usado para verificar o tipo de uma variável e, com base no tipo, retornar true ou false, mas com o C# 7.0, a expressão Is fornece 3 tipos de correspondência de padrões :

  1. Padrão Const
  2. Padrão Type
  3. Padrão Var

1 - Padrão Const

        static void ExpressaoIs_Const()
        {
            object objNull = null;
            object objNumero = 99;
            string objNome = "Macoratti";
            // verifica null
            if (objNull is null)
                Console.WriteLine("ObjNull é null");
            // Verifica valor constante
            if (objNumero is 99)
                Console.WriteLine("ObjNumero tem o valor igual a 99");
            // verifica valor string
            if (objNome is "Macoratti")
                Console.WriteLine("O ObjNome é igual a : \"Macoratti\"");
            Console.ReadLine();
        }

Note que podemos verificar qualquer valor incluindo o null.

2 - Padrão Type

Agora podemos confirmar o tipo do objeto e também atribuir o valor a uma nova variável do tipo dado.

Antes do C# 7.0, também tínhamos o recurso semelhante, mas era precisa dar um cast.

No código abaixo temos duas classes Pessoa e Funcionario onde Funcionario herda de Pessoa:

        internal class Pessoa
        {
            public Pessoa() {}
            public string Nome { get; set; }
            public string Email { get; set; }
        }
        internal class Funcionario : Pessoa
        {
            public Funcionario(){}
            public string Setor { get; set; }
        }
        static void EspressaoIs_Type()
        {
            Object obj = 2;
            var objPessoa = new Pessoa() { Nome = "Macoratti", Email = "mac@yahoo.com" };
            var objNewPessoa = new Funcionario() { Nome = "Jefferson", Setor = "Engenharia" };
            if (obj is int i)
                Console.WriteLine($" Variavel i possui o valor de {i}");
            if (objPessoa is Pessoa pessoa)
                Console.WriteLine($" p é do tipo {pessoa.GetType().Name} e o nome é {pessoa.Nome}");
            if (objNewPessoa is Funcionario newPessoa)
                Console.WriteLine($" p é do tipo {newPessoa.GetType().Name} e o setor é  {newPessoa.Setor}");
            if (objNewPessoa is Pessoa objPess)
                Console.WriteLine($" p é do tipo {objPess.GetType().Name} e o nome é {objPess.Nome}");
            Console.ReadLine();
        }

Abaixo temos o resultado da execução deste código:

Como Funcionario herda de Pessoa , na última instrução temos um objeto real de Funcionario mas ele é atribuído a uma variável do tipo base. (Pessoa)

3 - Padrão Var

Este é um padrão de caso especial onde verificamos o tipo como var. Isso possui uma diferença com o padrão de tipo, uma vez que retorna true mesmo que seja nulo. 

       internal class Pessoa
        {
            public Pessoa(){ }
            public string Nome { get; set; }
            public string Email { get; set; }
        }
        static void ExpressaoIs_Var()
        {
            object obj = new Pessoa() { Nome = "Macoratti", Email = "mac@yahoo.com" };
            if (obj is var p)
            {
                Console.WriteLine($"Padrão Var : P é do tipo {p?.GetType().Name}.");
            }
            obj = null;
            if (obj is var pess)
            {
                Console.WriteLine($"Padrão Var : P é do tipo {pess?.GetType().Name}.");
            }
            Console.ReadLine();
        }

Abaixo vemos o resultado da execução do código acima:

Note que agora podemos ver que a segunda verificação também é verdadeira, mas como ela é nula, nada é exibido onde escrevemos o nome do tipo.

Na próxima parte do artigo veremos o funcionamento do Pattern Matching com a instrução switch.

Pegue o projeto completo aqui :  C7_PatternMatching.zip

"Meus filhinhos, estas coisas vos escrevo, para que não pequeis; e, se alguém pecar, temos um Advogado para com o Pai, Jesus Cristo, o justo."
1 João 2:1

Veja os Destaques e novidades do SUPER DVD Visual Basic (sempre atualizado) : clique e confira !

Quer migrar para o VB .NET ?

Quer aprender C# ??

Quer aprender os conceitos da Programação Orientada a objetos ?

Quer aprender o gerar relatórios com o ReportViewer no VS 2013 ?

Quer aprender a criar aplicações Web Dinâmicas usando a ASP .NET MVC 5 ?

 

  Gostou ?   Compartilhe no Facebook   Compartilhe no Twitter

 

Referências:

José Carlos Macoratti