0Pricing
C# Academy · Leçon

Schémas de type et de propriété

Faites correspondre la forme et les membres.

Schémas de type et de propriété est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 2 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.

Le patron de type

Un patron de type correspond lorsque l’entrée est une instance d’un type donné. Écrit simplement avec le nom du type dans une branche de sélection, il vérifie le type d’exécution de la valeur.

Cela remplace les chaînes maladroites de vérifications is suivies de conversions par une vérification claire en une seule expression, qui affine également le type pour vous.

object o = "hello";
string kind = o switch
{
    int    => "number",
    string => "text",
    _      => "unknown"
};
System.Console.WriteLine(kind);

Patrons de déclaration

Un patron de déclaration ajoute un nom de variable après le type : string s. Lorsqu’il correspond, l’entrée est convertie et associée à cette variable.

Vous pouvez ensuite utiliser la variable typée à droite de la branche et accéder aux membres propres à ce type, sans conversion supplémentaire.

object o = "coddy";
string result = o switch
{
    string s => $"len {s.Length}",
    int n    => $"value {n}",
    _        => "other"
};
System.Console.WriteLine(result);

Une sélection par type exécutable

Les patrons de type sont parfaits pour traiter des données hétérogènes, comme lors de l’analyse des valeurs d’un tableau object.

Ici, chaque élément est comparé à son type d’exécution puis formaté en conséquence. La variable associée conserve le type affiné dans l’expression de résultat.

using System;

class Program {
    static string Describe(object o) => o switch {
        int i    => $"int {i}",
        double d => $"double {d}",
        string s => $"string '{s}'",
        _        => "?"
    };
    static void Main() {
        foreach (var x in new object[]{ 1, 2.5, "hi" })
            Console.WriteLine(Describe(x));
    }
}

Le patron de propriété

Un patron de propriété inspecte les membres d’un objet à l’aide d’accolades : { Property: value }. Il correspond lorsque chaque propriété indiquée satisfait son patron imbriqué.

Cela vous permet d’effectuer une sélection directement selon la structure et le contenu d’un objet, sans écrire de comparaisons manuelles de membres.

record Person(string Name, int Age);

var p = new Person("Ada", 30);
string stage = p switch
{
    { Age: < 18 } => "minor",
    { Age: >= 65 } => "senior",
    _ => "adult"
};
System.Console.WriteLine(stage);

Plusieurs propriétés

Vous pouvez vérifier plusieurs propriétés à la fois en les séparant par des virgules entre les accolades. Elles doivent toutes correspondre pour que la branche soit choisie.

Cela exprime clairement des conditions composées, comme la correspondance avec un objet qui possède à la fois un état et un nombre précis.

record Order(string Status, int Items);

var order = new Order("Open", 0);
string msg = order switch
{
    { Status: "Open", Items: 0 } => "empty cart",
    { Status: "Open" } => "shopping",
    _ => "closed"
};
System.Console.WriteLine(msg);

Combiner type et propriété

Les patrons de type et de propriété se combinent : écrivez le type, puis un bloc d’accolades contenant les propriétés. La branche ne correspond que si l’entrée est de ce type et que ses propriétés correspondent.

C’est particulièrement utile avec des références vers une classe de base ou des interfaces, lorsque vous souhaitez effectuer une sélection à la fois sur les sous-types concrets et sur leur état.

using System;

abstract record Shape;
record Circle(double R) : Shape;
record Square(double Side) : Shape;

class Program {
    static string Big(Shape s) => s switch {
        Circle { R: > 10 } => "big circle",
        Square { Side: > 10 } => "big square",
        _ => "small"
    };
    static void Main() => Console.WriteLine(Big(new Circle(12)));
}

Patrons de propriété imbriqués

Les patrons de propriété peuvent être imbriqués. Si une propriété est elle-même un objet, vous pouvez faire correspondre ses membres avec un autre bloc d’accolades.

Par exemple, { Address: { City: "Paris" } } examine deux niveaux en profondeur dans une seule expression. Cela évite les chaînes d’accès par points susceptibles de rencontrer des valeurs nulles.

record Address(string City);
record User(string Name, Address Address);

var u = new User("Lin", new Address("Paris"));
bool inParis = u is { Address: { City: "Paris" } };
System.Console.WriteLine(inParis);

Accès étendu aux propriétés

Depuis C# 10, vous pouvez utiliser un chemin séparé par des points dans un patron de propriété : { Address.City: "Paris" }. C’est une forme abrégée des accolades imbriquées.

Cela aplatit les vérifications profondes en une seule ligne lisible, tout en gérant correctement les valeurs intermédiaires pendant la correspondance.

record Address(string City);
record User(string Name, Address Address);

var u = new User("Lin", new Address("Rome"));
string where = u switch
{
    { Address.City: "Paris" } => "FR",
    { Address.City: "Rome" }  => "IT",
    _ => "??"
};
System.Console.WriteLine(where);

Capturer toute la correspondance

Vous pouvez associer une variable à toute la valeur correspondante en ajoutant un nom après le patron de propriété : { Age: > 18 } adult.

La variable adult désigne alors l’objet complet dans la branche, ce qui vous permet de l’utiliser après avoir vérifié que ses propriétés satisfont la vérification.

using System;

record Person(string Name, int Age);

class Program {
    static void Main() {
        Person p = new("Sam", 40);
        string r = p switch {
            { Age: >= 18 } adult => $"{adult.Name} can vote",
            _ => "too young"
        };
        Console.WriteLine(r);
    }
}

Gestion des valeurs nulles

Un patron de propriété ne correspond jamais à null, car il n’y a aucun objet à inspecter. Ainsi, { } (des accolades vides) correspond à toute valeur non nulle.

Cela fait de not null et de { } des idiomes utiles pour vérifier la nullité, et garantit que les branches fondées sur des propriétés ignorent correctement les entrées nulles.

string? maybe = null;
string state = maybe switch
{
    null => "missing",
    { Length: 0 } => "empty",
    _ => "has text"
};
System.Console.WriteLine(state);

Pourquoi les patrons sont préférables aux conversions

Avant les patrons, effectuer une sélection selon le type signifiait écrire des vérifications is suivies de conversions et de vérifications de nullité. Les patrons de type et de propriété regroupent tout cela dans une seule expression.

Le compilateur suit également l’exhaustivité et l’accessibilité, ce qui lui permet de détecter les branches inatteignables et les cas manquants que des chaînes de conditions écrites manuellement ignoreraient silencieusement.

object o = 42;
// Old: if (o is int) { int n = (int)o; ... }
// New:
if (o is int n) System.Console.WriteLine(n + 1);

Vérification rapide

Vérifiez votre compréhension des patrons de type et de propriété.

Récapitulatif

Les patrons de type correspondent selon le type d’exécution et peuvent associer une variable typée. Les patrons de propriété inspectent les membres avec { Prop: pattern }, prennent en charge l’imbrication et les chemins séparés par des points, et ne correspondent jamais à une valeur nulle.

Combinez-les pour effectuer une sélection selon la structure et l’état. Nous allons maintenant étudier les patrons relationnels et logiques.

Questions Fréquemment Posées

La leçon « Schémas de type et de propriété » est-elle gratuite ?

Oui — le texte complet de « Schémas de type et de propriété » 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 type et de propriété » ?

Faites correspondre la forme et les membres. 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 2 sur 4.

Combien de temps prend la leçon « Schémas de type et de propriété » ?

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

  1. Expressions switch
  2. Schémas de type et de propriété
  3. Schémas relationnels et logiques
  4. Schémas de listes et de tuples
← Retour à C# Academy