C# - Apresentando expressões switch

Hoje vou apresentar as expressões switch um recurso incluído na versão 8.0 da linguagem C#.

As expressões de switch são um novo recurso do compilador disponível a partir do C# 8 e são uma evolução das instruções switch padrões..

Uma expressão switch fornece semântica semelhante a switch em um contexto de expressão.

Este recurso fornece uma sintaxe concisa quando os braços do switch produzem um valor.

Para ilustrar o conceito vamos supor que desejamos obter o valor do frete em um hipotético sistema de pedidos.

Para vamos definir o método GetPrecoFrete fornecendo uma instância da enumeração TipoFrete:

using System;

namespace CShp_Switch1
{
    class Program
    {
        public enum TipoFrete
        {
           Padrao,
            BaixoCusto,
            Expresso
        }

        static void Main(string[] args)
        {
            var precoFrete = GetPrecoFrete(TipoFrete.Padrao);
            Console.WriteLine($"Valor do frete {precoFrete}");

            Console.ReadLine();
        }

        static decimal GetPrecoFrete(TipoFrete frete)
        {
            switch (frete)
            {
                case TipoFrete.Padrao:
                    return 8.50m;
                case TipoFrete.BaixoCusto:
                    return 5.20m;
                case TipoFrete.Expresso:
                    return 19.80m;
                default:
                    return 8.50m;
            }
        }
    }
}

No método GetPrecoFrete, temos uma instrução switch padrão que trata de todos os três tipos de envio. Ele também lida com o caso padrão, que retorna o mesmo valor do frete padrão.

Assim executando o código iremos obter o resultado a seguir:

Usando uma expressão switch

Vamos agora ver como usar as expressões switch pode nos ajudar neste cenário.

A primeira coisa a fazer é reescrever a instrução switch usada em uma expressão switch.

Vamos então alterar o código do método GetPrecoFrete() conforme abaixo:

        static decimal GetPrecoFrete(TipoFrete frete)
        {
            var precoFrete = frete switch
            {
                TipoFrete.Padrao => 8.50m,
                TipoFrete.BaixoCusto => 5.20m,
                TipoFrete.Expresso => 19.80m,
                _ => 8.50m
            };

            return precoFrete;
        }

Uma expressão de switch sempre retorna um valor. Criamos uma variável precoFrete para armazenar o resultado.

Em seguida, precisamos trocar a palavra-chave switch e seu argumento e a última etapa é reescrever nossos casos como expressões.

Fazemos isso removendo a palavra-chave case e usando a sintaxe de seta em vez de dois pontos para definir uma expressão. No final de cada caso, usamos uma vírgula em vez de um ponto e vírgula. Podemos remover a palavra-chave return porque uma expressão sempre é avaliada como um resultado.

As expressões de switch usam o operador de descarte em vez da palavra-chave padrão. Vamos reescrever o caso padrão em uma expressão também.

Por último, vamos remover o uso da precoFrete e retornar o resultado diretamente da expressão switch.

O método GetPrecoFrete() agora ficou definido da seguinte forma usando uma expressão switch:

       static decimal GetPrecoFrete(TipoFrete frete)
        {
            return frete switch
            {
                TipoFrete.Padrao => 8.50m,
                TipoFrete.BaixoCusto => 5.20m,
                TipoFrete.Expresso => 19.80m,
                _ => 8.50m
            };
        }

Concluindo temos que :

Em primeiro lugar, a ordem é importante pois o runtime avalia cada expressão de cima para baixo.

Funciona da mesma forma que uma instrução switch tradicional. A diferença é que cada expressão precisa retornar um valor.

Uma expressão switch deve ser uma única declaração e não podemos usar métodos anônimos ou outras definições de delegate.

E estamos conversados...

"Quanto lhe for possível, não deixe de fazer o bem a quem dele precisa"
Provérbios 3:27

Referências:

José Carlos Macoratti