A correspondência de padrões é melhor do que a comutação tradicional baseada em tipo?

Em idiomas como C# que não suportam a estrutura "Switch by Type" direta, os programadores geralmente usam o clássico "se ... else ... else" estrutura para simular a comutação baseada em tipo. No entanto, à medida que o número de tipos envolvidos aumenta, essa abordagem se torna longa e frágil.

padrão correspondente em c# 7 e mais tarde

Começando com C# 7, a correspondência de padrões fornece uma maneira mais elegante e concisa de alternar por tipo. A sintaxe "tipo de caso" permite corresponder os tipos de variáveis, substituindo efetivamente a instrução "se" por um caso de um padrão específico.

Por exemplo:

void Foo(object o)
{
    switch (o)
    {
        case A a:    // 匹配A类型
            a.Hop();
            break;
        case B b:    // 匹配B类型
            b.Skip();
            break;
        default:
            throw new ArgumentException("意外类型: "   o.GetType());
    }
}

C# 6 Usando o nome de ()

Em C# 6, você pode usar o operador nameof () para obter o nome de tipo dinamicamente para instruções de switch. Embora não seja tão conciso quanto a correspondência de padrões, ele fornece uma alternativa mais fácil para evitar nomes de tipos codificados.

void Foo(object o)
{
    switch (o.GetType().Name)
    {
        case nameof(A):
            // 处理A类型
            break;
        case nameof(B):
            // 处理B类型
            break;
        default:
            // 处理其他类型
            break;
    }
}

Switch baseado em tipo em C# 5 e anterior

Para C# 5 e anterior, você não tem escolha a não ser usar o básico "se ... else se ... else" estrutura com nomes de tipo codificado. Essa abordagem pode se tornar desajeitada e propensa a erros.

void Foo(object o)
{
    if (o is A)
    {
        // 处理A类型
    }
    else if (o is B)
    {
        // 处理B类型
    }
    else
    {
        // 处理其他类型
    }
}

para concluir

correspondência de padrões em C# 7 e posterior fornece uma maneira poderosa e concisa de simular a comutação baseada em tipo. Ele elimina a necessidade de cadeias condicionais, melhora a legibilidade do código e reduz a possibilidade de erros. Para versões anteriores de C#, usando as instruções Nameof () e Switch forneceu uma alternativa mais flexível do que os nomes de tipo codificados, enquanto a estrutura clássica "se ... else ... se ... else" ainda é uma opção menos ideal, mas ainda viável.