La correspondance des modèles est-elle meilleure que la commutation traditionnelle basée sur les types?

Dans des langages tels que C # qui ne prennent pas en charge "Switch by Type" direct, les programmeurs utilisent généralement la structure classique "si ... else if ... else" pour simuler la commutation basée sur le type. Cependant, à mesure que le nombre de types impliqués augmente, cette approche devient longue et fragile.

correspondant de modèle en C # 7 et plus tard

En commençant par C # 7, la correspondance du modèle offre un moyen plus élégant et concis de basculer par type. La syntaxe "Type de cas" permet de faire correspondre les types de variables, en remplacement efficace de l'instruction "IF" par un cas de motif spécifique.

Par exemple:

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 Utilisation de nameof ()

Dans C # 6, vous pouvez utiliser l'opérateur NameOf () pour obtenir le nom de type dynamiquement pour les instructions de commutation. Bien qu'il ne soit pas aussi concis que la correspondance de motifs, il fournit une alternative plus facile pour éviter les noms de type codés durs.

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

commutateur basé sur des types en C # 5 et plus tôt

Pour C # 5 et plus tôt, vous n'avez pas d'autre choix que d'utiliser la structure de base "if ... else if ... else" avec des noms de type codés dur. Cette approche peut devenir maladroite et sujet aux erreurs.

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

en conclusion

La correspondance du modèle en C # 7 et fournit plus tard un moyen puissant et concis de simuler la commutation basée sur le type. Il élimine le besoin de chaînes conditionnelles, améliore la lisibilité du code et réduit la possibilité d'erreurs. Pour les versions antérieures de C #, l'utilisation des instructions NameOf () et Switch a fourni une alternative plus flexible que les noms de type codé dur, tandis que la structure classique "si ... sinon si ... else" est toujours une option moins idéale mais toujours viable.