¿La coincidencia de patrones es mejor que la conmutación tradicional basada en tipo?

En idiomas como C# que no admiten "conmutador por tipo" directo, los programadores generalmente usan la estructura clásica "si ... si ... else" para simular la conmutación basada en el tipo. Sin embargo, a medida que aumenta el número de tipos involucrados, este enfoque se vuelve largo y frágil.

Patrón de coincidencia en C# 7 y más tarde

Comenzando con C# 7, la coincidencia de patrones proporciona una forma más elegante y concisa de cambiar por tipo. La sintaxis del "tipo de caso" permite que coincidan con los tipos de variables, reemplazando efectivamente la declaración "si" con un caso de un patrón específico.

Por ejemplo:

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 nameOf ()

En C# 6, puede usar el operador NameOf () para obtener el nombre de tipo dinámico para las declaraciones de conmutador. Si bien no es tan conciso como la coincidencia de patrones, proporciona una alternativa más fácil para evitar nombres de tipo codificado.

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

Switch basado en tipo en C# 5 y anterior

Para C# 5 y antes, no tiene más remedio que usar la estructura básica "si ... si ... si ... de lo contrario" con nombres de tipos codificados. Este enfoque puede volverse torpe y propenso a errores.

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

en conclusión

La coincidencia de patrones en C# 7 y luego proporciona una forma poderosa y concisa de simular la conmutación basada en el tipo. Elimina la necesidad de cadenas condicionales, mejora la legibilidad del código y reduce la posibilidad de errores. Para versiones anteriores de C#, el uso de las declaraciones NameOf () y Switch proporcionó una alternativa más flexible que los nombres de tipo codificado, mientras que la estructura clásica "si ... si ... de lo contrario" sigue siendo una opción menos ideal pero aún viable.