Modèles de liste et de tranche

Tip

Cet article fait partie de la section Notions de base pour les développeurs qui connaissent déjà au moins un langage de programmation et apprennent C#. Commencez par la vue d’ensemble des critères correspondants si les modèles sont nouveaux pour vous. Pour obtenir des règles de langage et de type pris en charge complètes, consultez les modèles de liste dans la référence de langue.

La forme d’une séquence est l’ensemble de propriétés observables dont un modèle a besoin. Ces propriétés peuvent inclure le nombre d’éléments, les exigences écrites pour chaque élément ou pour une séquence d’éléments dans son ensemble et les valeurs de marqueur à des index spécifiques. Par exemple, une structure peut nécessiter exactement deux éléments avec "Name" à l’indice 0, ou un premier marqueur, un dernier marqueur et une séquence non vide entre les deux.

Un modèle de liste décrit une forme en combinant une exigence de nombre d’éléments avec des modèles imbriqués aux positions ordonnées. Il teste uniquement les exigences écrites dans le modèle : un sous-modèle d’élément teste son élément correspondant, tandis qu’un modèle de tranche peut autoriser ou tester une séquence d’éléments sans correspondance. Vous pouvez utiliser ces parties pour faire correspondre un nombre exact et des valeurs de marqueur, capturer des valeurs à des positions fixes, autoriser un milieu sans correspondance ou appliquer un modèle imbriqué à ce milieu.

Choisissez un motif de liste lorsque le type à la compilation de l’entrée fournit une propriété Count ou Length, ainsi qu’un accès indexé aux éléments, qui permet de récupérer un élément par sa position, comme dans input[index]. Les tableaux, List<T>les chaînes et les étendues sont des exemples courants. Le compilateur détermine l’éligibilité du type déclaré et au moment de la compilation de la variable, car il doit résoudre ces membres requis avant l’exécution du programme. L’interface IEnumerable<T> elle-même fournit une énumération au lieu de ces membres, même lorsque l’objet runtime est une collection indexable.

Les motifs de liste utilisent une longueur ou un décompte ainsi qu’un accès aux éléments indexés, au lieu d’une énumération. Pour les types intégrés courants, la mise en correspondance peut vérifier uniquement les positions indiquées par le motif au lieu de parcourir tous les éléments. Le coût de ces opérations dépend du type d’entrée. L’itération d’une collection longue peut prendre du temps. Utilisez donc une boucle ou LINQ lorsque la décision nécessite l’examen d’un nombre arbitraire d’éléments plutôt que de positions spécifiques.

Mettre en correspondance une forme exacte

La méthode suivante reconnaît un en-tête à deux colonnes :

static bool IsHeader(string[] columns) =>
    columns is ["Name", "Score"];

L’expression columns constitue l’entrée du modèle d’expression. ["Name", "Score"] contient deux modèles constants. Un modèle de liste exact omet un modèle de tranche, nécessite exactement deux éléments et applique chaque modèle imbriqué à l’élément au même index. Ce modèle décrit une forme avec un nombre exact et deux valeurs de marqueur : "Name" à l’index 0 et "Score" à l’index 1. Les modèles d’éléments imbriqués sont facultatifs : le modèle [] de liste vide décrit et correspond à une séquence sans élément.

Choisissez un modèle de liste lorsque la forme combine un nombre d’éléments avec des exigences aux positions ordonnées. Si seul le nombre d’éléments importe, un modèle de propriété Count ou Length, comme items is { Count: 0 }, exprime cette intention plus directement.

Utiliser un abandon pour faire correspondre n’importe quelle valeur d’élément

La méthode suivante extrait le gagnant et le troisième d’un ordre d’arrivée composé de trois noms :

static string GetAnnouncements(List<string> finishingOrder) =>
    finishingOrder switch
    {
        [var winner, _, var thirdPlace] =>
            $"Winner: {winner}; third place: {thirdPlace}",
        _ => "A complete three-runner result isn't available"
    };

Les motifs var winner et var thirdPlace déclarent chacun une variable. Lorsque le modèle de liste correspond, C# affecte la valeur d’élément correspondante à cette position à la variable correspondante, afin que le résultat puisse utiliser winner et thirdPlace. Le modèle _ d’abandon accepte le deuxième élément et ignore sa valeur. Cette forme nécessite exactement trois éléments et donne la signification spécifique aux premières et troisième positions, mais elle ne nécessite pas de valeurs particulières à une position quelconque.

Choisissez ce formulaire lorsque les positions fixes ont une signification stable. Utilisez une boucle ou LINQ lorsque vous devez inspecter un nombre arbitraire d’éléments, transformer une séquence, effectuer une recherche dans l’ensemble ou effectuer une agrégation.

Autoriser les éléments restants avec un motif de tranche

Dans cet exemple simplifié, une ligne de commande peut commencer par --verbose et contenir d’autres arguments et est supposée se terminer par le nom du fichier d’entrée. La méthode suivante reconnaît les formes avec un nom de fichier à la dernière position et capture cette valeur :

static string GetInputFile(string[] arguments) =>
    arguments switch
    {
        ["--verbose", .., var fileName] => $"Verbose processing: {fileName}",
        [.., var fileName] => $"Processing: {fileName}",
        [] => "No input file was provided"
    };

Le modèle.. de tranche autorise zéro ou plusieurs éléments restants entre les modèles de premier et dernier élément. Un modèle de liste peut contenir au plus un modèle de tranche. Le premier bras de commutateur décrit une forme avec au moins deux éléments : le marqueur "--verbose" à l’index 0, un nom de fichier à la dernière position et un nombre quelconque d’arguments sans correspondance entre eux. La tranche autonome ne teste pas ces arguments intermédiaires. Le deuxième bras accepte n’importe quelle forme non vide et capture son dernier élément, tandis que le motif vide gère une séquence ne contenant aucun élément.

Une tranche peut apparaître au début, au milieu ou à la fin d’un modèle de liste. Utilisez-la lorsqu’une séquence de longueur variable fait partie de la forme, mais seules les positions environnantes nécessitent des tests d’élément. Utilisez une itération ordinaire lorsque chaque élément a besoin de traitement.

Appliquer un modèle à une tranche

Vous pouvez appliquer un autre motif à la partie correspondant à ... La méthode suivante teste si un tableau commence par "BEGIN", se termine par "END", et a au moins un élément entre eux :

static bool HasContent(string[] entries) =>
    entries is ["BEGIN", .. { Length: > 0 }, "END"];

Le modèle externe nécessite d’abord le marqueur "BEGIN" à l’index 0 et "END" au dernier index. Le modèle { Length: > 0 } de propriété ajoute ensuite une exigence pour la séquence mise en correspondance par la tranche : il doit contenir au moins un élément. Ensemble, ces exigences décrivent la forme complète. Le modèle ne teste pas les valeurs des éléments à l’intérieur de la tranche.

Utilisez un sous-modèle de tranche uniquement lorsque la partie centrale elle-même a besoin d’un test ou d’une capture. Si seuls les éléments de limite sont importants, la simple .. est plus simple.

Voir aussi

  • Dernière mise à jour :