C# Academy · Leçon

Schémas de listes et de tuples

Décomposez des collections.

Schémas de listes et de tuples est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 4 leçons au total.

Motifs de tuple

Un motif de tuple met en correspondance plusieurs valeurs à la fois en les plaçant entre parenthèses. Chaque position est mise en correspondance avec son propre sous-motif.

C’est idéal pour les décisions qui dépendent de plusieurs entrées, comme une petite machine à états ou un arbitre de pierre-papier-ciseaux, le tout dans un même switch.

int x = 0, y = 5;
string quadrant = (x, y) switch
{
    (0, 0) => "origin",
    (0, _) => "y-axis",
    (_, 0) => "x-axis",
    _ => "plane"
};
System.Console.WriteLine(quadrant);

Un switch de tuple exécutable

Les motifs de tuple rendent les tables de décision lisibles. Ici, deux valeurs booléennes choisissent une action.

Chaque branche énumère un motif de tuple, et le motif de rejet _ à une position signifie que celle-ci peut contenir n’importe quelle valeur. La dernière branche _ couvre tous les cas restants.

using System;

class Program {
    static string Move(bool fwd, bool turn) => (fwd, turn) switch {
        (true, false) => "straight",
        (true, true) => "curve",
        (false, true) => "spin",
        _ => "stop"
    };
    static void Main() => Console.WriteLine(Move(true, true));
}

Liaison dans les tuples

Les positions d’un motif de tuple peuvent capturer des valeurs. (0, var y) correspond lorsque le premier élément vaut 0 et lie le second à y.

Vous pouvez ensuite utiliser la variable liée dans le résultat de la branche ou dans une garde when, en combinant mise en correspondance et extraction en une seule étape.

var point = (0, 7);
string r = point switch
{
    (0, var y) => $"on y-axis at {y}",
    (var x, 0) => $"on x-axis at {x}",
    _ => "elsewhere"
};
System.Console.WriteLine(r);

Motifs de liste

Un motif de liste met en correspondance les tableaux et les listes selon leurs éléments, avec une notation entre crochets : [1, 2, 3]. Il correspond lorsque la longueur et chaque motif d’élément concordent.

Introduits avec C# 11, les motifs de liste vous permettent de choisir une branche directement selon la forme d’une séquence, sans vérifications manuelles de la longueur et des indices.

int[] data = { 1, 2, 3 };
string shape = data switch
{
    [] => "empty",
    [_] => "one",
    [_, _] => "two",
    _ => "many"
};
System.Console.WriteLine(shape);

Mise en correspondance d’éléments exacts

Les motifs de liste peuvent mettre en correspondance des valeurs précises à chaque position. [1, 2, 3] correspond uniquement à cette séquence exacte de trois éléments.

Mélangez librement constantes et motifs de rejet : [1, _, 3] correspond à une liste de longueur trois qui commence par 1 et se termine par 3, en ignorant l’élément central.

using System;

class Program {
    static void Main() {
        int[] a = { 1, 9, 3 };
        bool ok = a is [1, _, 3];
        Console.WriteLine(ok);
    }
}

Le motif de tranche

Le motif de tranche .. correspond à un nombre quelconque d’éléments, y compris zéro, à une position. Un motif de liste peut contenir au plus une tranche.

[1, .., 9] correspond à toute liste qui commence par 1 et se termine par 9, quels que soient les éléments intermédiaires. C’est idéal pour vérifier head et tail.

int[] nums = { 1, 4, 5, 9 };
string r = nums switch
{
    [1, .., 9] => "1..9 bookends",
    _ => "other"
};
System.Console.WriteLine(r);

Capturer une tranche

La tranche peut capturer les éléments ignorés dans une variable à l’aide de var : [first, .. var rest].

La partie capturée est elle-même un tableau ou une liste du type mis en correspondance, ce qui vous permet de déstructurer un élément head et de conserver le tail pour un traitement ultérieur.

using System;

class Program {
    static void Main() {
        int[] xs = { 10, 20, 30, 40 };
        if (xs is [var head, .. var tail])
            Console.WriteLine($"{head} then {tail.Length} more");
    }
}

Lier les éléments aux extrémités

Vous pouvez lier les deux extrémités autour d’une tranche : [var first, .., var last] capture le premier et le dernier élément tout en ignorant ceux du milieu.

C’est une notation concise pour les séquences dont seules les limites comptent, par exemple pour vérifier qu’un itinéraire commence et se termine à des points connus.

using System;

class Program {
    static void Main() {
        string[] route = { "A", "B", "C", "D" };
        if (route is [var start, .., var end])
            Console.WriteLine($"{start} -> {end}");
    }
}

Motifs de liste avec des sous-motifs

Chaque position d’une liste peut utiliser n’importe quel motif, y compris des motifs relationnels et logiques. [> 0, > 0] correspond à une liste de deux éléments positifs.

Cela réunit tous les outils de motifs pour la mise en correspondance de séquences, afin de vérifier à la fois la forme et le contenu dans une seule expression.

int[] pair = { 3, 8 };
string r = pair switch
{
    [> 0, > 0] => "both positive",
    [_, _] => "mixed",
    _ => "wrong size"
};
System.Console.WriteLine(r);

Imbrication de tuples et de listes

Les motifs de tuple et de liste peuvent s’imbriquer les uns dans les autres ainsi que dans des motifs de propriété. Une position de tuple peut contenir un motif de liste, et inversement.

Vous pouvez ainsi mettre en correspondance des données structurées complexes, comme une séquence étiquetée, dans une seule expression plutôt qu’au moyen de plusieurs vérifications imbriquées.

using System;

class Program {
    static void Main() {
        (string, int[]) record = ("primes", new[]{ 2, 3 });
        string r = record switch {
            ("primes", [2, ..]) => "starts with 2",
            _ => "other"
        };
        Console.WriteLine(r);
    }
}

Conditions requises pour les motifs de liste

Les motifs de liste fonctionnent avec tout type dénombrable et indexable : il doit disposer d’une propriété Length ou Count ainsi que d’un indexeur. Les tableaux, List<T> et les chaînes de caractères conviennent.

La capture d’une tranche nécessite également une méthode de tranche ou un indexeur de plage. La plupart des collections intégrées prennent en charge ces deux éléments directement.

string s = "cat";
bool isCat = s is ['c', 'a', 't'];
System.Console.WriteLine(isCat);

Vérification rapide

Vérifiez votre compréhension des motifs de liste et de tuple.

Récapitulatif

Les motifs de tuple mettent en correspondance plusieurs valeurs entre parenthèses ; les motifs de liste mettent en correspondance la forme d’une séquence entre crochets, avec .. comme tranche pouvant capturer la partie centrale au moyen de var.

Les positions acceptent n’importe quel sous-motif et s’imbriquent librement. Les motifs de liste nécessitent un type dénombrable et indexable. Vous maîtrisez désormais toute la boîte à outils des motifs C#.

Questions Fréquemment Posées

La leçon « Schémas de listes et de tuples » est-elle gratuite ?

Oui — le texte complet de « Schémas de listes et de tuples » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Schémas de listes et de tuples » ?

Décomposez des collections. Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C# Academy ?

Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Schémas de listes et de tuples » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?

Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à C# Academy