Pattern matching no C# 8.0

A partir do C# 7.0 a linguagem começou a receber funcionalidades que fazem uso de um recurso de programação funcional chamado pattern matching. A maioria desses recursos é derivada do F# e a introdução deles no C# visa facilitar a vida do desenvolvedor e solução de certos tipos de problemas.

São recursos muito poderosos e que simplificam em muito alguns tipos de construções.

Como os recursos de pattern matching do C# 8.0 são extensões daqueles instroduzidos no C# 7.0, vou apresentá-los na mesma ordem para simplificar o entendimento.

#Patterns introduzidos no C# 7.0

No C# 7.0 o operador is e a declaração switch foram melhoradas com a adição de alguns novos padrões: const pattern, type pattern e var pattern.

#Const pattern

Vejamos a seguinte função, que recebe um objeto o como argumento:

public void Is(object o) { if (o is null) Console.WriteLine("o é null!"); // ... }

Antes do C# 7.0, teríamos que escrever essa verificação usando o operador ==, mas agora podemos fazer a mesma validação com o operador is.

Este padrão também vale para inteiros ou outros valores constantes:

if (o is 42) Console.WriteLine("A resposta é 42!");

#Type pattern

O type pattern pode ser um pouco mais útil. Com ele podemos extrair uma variável ao verificar o tipo, tanto com o operador is quanto com o switch.

Este padrão sempre tem sucesso quando o tipo aferido é o mesmo da variável.

public void Is(object o) { if (o is Pessoa pessoa) Console.WriteLine($"O nome é {pessoa.Nome}"); // ... }

Com o tipo identificado, também é possível usá-lo na mesma expressão para filtrar ainda mais o objeto:

if (o is Pessoa p && p.Idade < 18) Console.WriteLine($"{p.Nome} é menor de idade.");

#Var pattern

O var pattern sempre é avaliado com sucesso, pois toda variável tem um tipo.

Ele é bastante útil para obter uma variável já convertida para o seu tipo verdadeiro.

public void Is(object o) { if (o is var x) { var nomeTipo = x?.GetType()?.Name; Console.WriteLine($"O tipo de 'x' é {nomeTipo}"); } // ... }

Então, se passarmos uma variável do tipo Pessoa para a variável x no exemplo acima, a saída será O tipo de 'x' é Pessoa.

#Usando a declaração switch com Pattern Matching

Todos os três padrões acima são utilizáveis numa declaração do tipo switch:

switch(o) { case Humano humano: Console.WriteLine($"Nome do humano: {humano.Nome}"); break; case AnimalSelvagem animal: Console.WriteLine($"Nome do animal: {animal.Nome}"); break; case int resposta: Console.WriteLine($"A resposta é {resposta}"); break; case var x: Console.WriteLine($"x não é incógnita! É do tipo {x.GetType().Name}!"); break; }

Como o var pattern sempre dá match, pode até ser usado como default.

#Recursos introduzidos no C# 8.0

Já no C# 8.0, foi introduzido um pattern matching bem mais poderoso, mais parecido com o encontrado em linguagens como F# e Scala.

Antes de ver um exemplo completo, é interessante fazermos uma rápida revisão de tuplas tal como são usadas a partir do C# 7.0.

Uma tupla pode ser declarada assim:

var tupla = (1, true); // tupla do tipo (int, bool)

E uma tupla pode ser facilmente decomposta desta forma:

(var entrada, var saida) = (1, true); // ou (int entrada, bool saida) = (1, true);

O primeiro valor da tupla é atribuído à primeira variável, e o segundo valor é atribuído à segunda variável.

Outro aspecto importante, é a possibilidade de utilizar o operador de descarte _.

(var a, _) = (x, y);

Neste caso, comunicamos ao compilador que não estamos interessados no segundo valor da tupla, e que ele pode ser descartado.

#Full pattern matching!

No C# 8.0, é possível escrever uma declaração switch em que cada caso é uma expressão que será avaliada em tempo de execução.

Vejamos um exemplo para selecionar uma classe CSS com base no valor de uma variável do tipo bool?:

bool? visivel = false; var classeCss = visivel switch { true => "Visible", false => "Hidden", null => "Blink" };

Neste exemplo, ao rodar este código, cada uma das expressões será avaliada, na ordem em que foram declaradas. A primeira que for verdadeira (der match) será executada.

Há dois pontos interessantes para notar: o primeiro é que neste caso a expressão switch possui um retorno que pode ser atribuído a uma variável ou retornado. O segundo ponto é que ela está usando o const pattern que vimos mais acima.

A entrada de uma expressão swtich com pattern matching pode ser uma tupla, e cada caso pode ser decomposto. Este padrão é chamado de tuple pattern. Vamos a um exemplo mais complexo:

int a = A(); // valor entre 1 e 3 int b = B(); // valor entre 1 e 3 bool c = HabilitarAvaliacao(); bool resultado = (a, b, c) switch { (1, 1, false) => Ok(), (1, 2, false) => Ok(), (1, 3, false) => Ok(), (2, 1, false) => Ok(), (2, 2, false) => Ok(), (2, 3, false) => Ok(), (3, 1, false) => Ok(), (3, 2, false) => Ok(), (3, 3, false) => Ok(), (1, 3, true) => Ok(), (2, 3, true) => Ok(), (3, 3, true) => Ok(), (_, _, _) => Nok() };

Neste exemplo, estamos tratando várias combinações de variáveis que resultam numa avaliação Ok(), e em outros casos resultam num Nok();

Este código pode ser fácil de ler e entender, mas pode ser simplificado com a introdução de outro recurso, as guardas. Vejamos um exemplo:

var resultado = (1, 2) switch { (var a, var b) when a > 10 => a * b, (var a, var b) when b < 1 => a + b, (_, _) => a - b };

Neste caso, apesar de termos dois casos aparentemente idênticos (var a, var b), o primeiro só será executado quando a for maior que 10. Caso não for, o segundo poderá ser executado quando b for menor que 1.

Assim, o exemplo anterior poderia ser reescrito, tomando vantagem das guardas:

int a = A(); // valor entre 1 e 3 int b = B(); // valor entre 1 e 3 bool c = HabilitarAvaliacao(); bool resultado = (a, b, c) switch { (_, _, false) => Ok(), (_, 3, true) => Ok(), (_, _, _) => Nok() };

Vamos a um exemplo mais prático, em que fazemos um tratamento para checar a saúde de um serviço, e avaliação toma dois argumentos: 1) o sucesso na checagem e 2) o tempo de resposta do serviço:

var healthCheckResult = (sucesso, tempoRespostaMilissegundos) switch { (true, var ms) when ms <= 5000 => HealthCheckResult.Healthy(), (true, _) => HealthCheckResult.Degraded(), (false, _) => HealthCheckResult.Unhealthy(), };

No cenário acima, temos um uso interessante da guarda: o serviço só será considerado saudável quando o tempo de resposta for de até 5 segundos.

Esta é uma forma bastante compacta e concisa de representar vários cenários num código expressivo e fácil de ler, e é particularmente útil para reescrever cadeias complexas ou confusas de ifs.

#Implementando máquinas de estado

Esta abordagem também é bastante útil para descrever máquinas de estado.

Por exemplo, uma máquina de estado para um portão eletrônico poderia ser algo mais ou menos assim:

var newState = (currentState, action, key.IsValid) switch { (GateState.Locked, GateAction.Open, true) => GateState.Opened, (GateState.Opened, GateAction.Open, _) => throw new InvalidOperationException("Não se pode abrir um portão aberto"), (GateState.Opened, GateAction.Lock, true) => GateState.Locked, (GateState.Locked, GateAction.Open, false) => GateState.Locked, (GateState.Closed, GateAction.Lock, true) => GateState.Locked, (GateState.Closed, GateAction.Close, _) => throw new InvalidOperationException("Não se pode fechar um portão fechado"), _ => currentState };

#Desconstrução de tipos

Um último recurso que eu gostaria de mostrar aqui é a desconstrução de tipos, ou seja, é um structure pattern.

Para exemplificar, veja esses dois structs que representam respectivamente pontos em sistemas de coordenadas 2D e 3D:

public struct Point2D { public int X { get; } public int Y { get; } public Point2D(int x, int y) => (X, Y) = (x, y); public void Deconstruct(out int x, out int y) => (x, y) = (X, Y); } public struct Point3D { public int X { get; } public int Y { get; } public int Z { get; } public Point3D(int x, int y, int z) => (X, Y, Z) = (x, y, z); public void Deconstruct(out int x, out int y, out int z) => (x, y, z) = (X, Y, Z); }

Com o método Deconstruct implementado, podemos usar pattern matching para determinar qual quadrante um ponto 2D se encontra:

public static string ComputeQuadrant(Point2D point) => point switch { (0, 0) => "Origin", var (x, y) when x > 0 && y > 0 => "One", var (x, y) when x < 0 && y > 0 => "Two", var (x, y) when x < 0 && y < 0 => "Three", var (x, y) when x > 0 && y < 0 => "Four", var (x, _) when x > 0 => "Positive X axis", var (x, _) when x < 0 => "Negative X axis", var (_, y) when y > 0 => "Positive Y axis", var (_, y) when y < 0 => "Negative Y axis" };

Esse é um exemplo bem interessante porque demonstra como podemos usar pattern matching para desconstruir um tipo customizado e aplicar várias guardas para chegar numa decisão.

#Conclusão

O pattern matching é um recurso extremamente poderoso e expressivo. Ele pode ajudar a simplificar muitos códigos complexos e difíceis de ler, especialmente aqueles que envolvem muitas condições e validações.

Espero que este artigo tenha demonstrado algumas das possibilidades que o pattern matching oferece, e que você possa aplicar esses conceitos nos seus próprios projetos.

Dyego Maas - Blog