C# Academy · Leçon

Schémas relationnels et logiques

Combinez des conditions dans les schémas.

Schémas relationnels et logiques est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.

Patrons relationnels

Un patron relationnel compare l’entrée à une constante à l’aide de <, >, <= ou >=. Il correspond lorsque la comparaison est vraie.

Introduits dans C# 9, les patrons relationnels rendent les vérifications d’intervalles concises dans les branches de sélection et les expressions is, sans écrire de comparaisons explicites.

int temp = 18;
string level = temp switch
{
    < 0  => "freezing",
    < 15 => "cold",
    < 25 => "mild",
    _    => "hot"
};
System.Console.WriteLine(level);

Patrons relationnels avec l’opérateur de test de type

Les patrons relationnels fonctionnent également dans les expressions is, ce qui permet d’écrire des vérifications booléennes lisibles.

n is > 0 se lit presque comme une phrase et renvoie une valeur booléenne que vous pouvez utiliser dans des conditions, des affectations ou des prédicats LINQ.

using System;

class Program {
    static void Main() {
        int score = 82;
        bool passed = score is >= 60;
        Console.WriteLine(passed);
    }
}

Le patron logique de conjonction

Le patron logique and exige que les deux sous-patrons correspondent. Il est idéal pour les intervalles bornés.

>= 1 and <= 12 correspond aux valeurs comprises dans un intervalle inclusif. Sans and, il serait impossible d’exprimer des bornes inférieure et supérieure dans un seul patron.

int month = 6;
bool valid = month is >= 1 and <= 12;
System.Console.WriteLine(valid);

Le patron logique de disjonction

Le patron logique or correspond lorsque l’un ou l’autre des sous-patrons correspond. Il regroupe des valeurs alternatives dans une seule branche.

Au lieu de répéter des branches pour des cas associés, 'a' or 'e' or 'i' les regroupe. Cela conserve des expressions de sélection concises et explicites.

char c = 'e';
string kind = c switch
{
    'a' or 'e' or 'i' or 'o' or 'u' => "vowel",
    _ => "consonant"
};
System.Console.WriteLine(kind);

Le patron logique de négation

Le patron logique not correspond lorsque son sous-patron ne correspond pas. Son utilisation la plus courante est not null.

Il peut aussi nier d’autres patrons, comme not 0 ou not (> 100), ce qui permet d’exprimer clairement des exclusions dans une seule branche.

object? value = "hi";
if (value is not null)
    System.Console.WriteLine("present");

Combiner des patrons logiques

Les patrons logiques peuvent être combinés. Vous pouvez enchaîner and, or et not pour construire des conditions complexes, en utilisant des parenthèses pour contrôler la priorité.

La priorité est la suivante : not s’applique le plus fortement, puis and, puis or. Ajoutez des parenthèses dès que l’intention risque d’être ambiguë.

using System;

class Program {
    static string Classify(int n) => n switch {
        < 0 or > 100 => "out of range",
        >= 0 and <= 50 => "low half",
        _ => "high half"
    };
    static void Main() => Console.WriteLine(Classify(75));
}

Intervalles pour la notation

Les patrons relationnels et logiques permettent de représenter clairement les barèmes de notation classiques.

Comme les branches sont vérifiées de haut en bas, vous pouvez utiliser de simples bornes supérieures ou combiner des bornes avec and pour exprimer explicitement les intervalles. Les deux styles sont valides ; choisissez le plus clair.

using System;

class Program {
    static char Grade(int s) => s switch {
        >= 90 => 'A',
        >= 80 and < 90 => 'B',
        >= 70 and < 80 => 'C',
        _ => 'F'
    };
    static void Main() => Console.WriteLine(Grade(85));
}

La non-nullité avec les patrons de propriété

Combiner not null avec des patrons de type et de propriété produit des gardes sûres et explicites.

obj is Person { Name: not null } p correspond à une instance de Person non nulle dont Name est également non nul, puis l’associe à une variable. Cela évite les vérifications de nullité en cascade.

record Person(string? Name);

object obj = new Person("Kai");
if (obj is Person { Name: not null } p)
    System.Console.WriteLine(p.Name);

Nier des intervalles

Vous pouvez nier un groupe relationnel avec not et des parenthèses pour exprimer des exclusions.

not (>= 1 and <= 5) correspond à toute valeur située en dehors de l’intervalle de 1 à 5. Pour certains lecteurs, cette écriture est plus directe que l’équivalent < 1 or > 5.

using System;

class Program {
    static void Main() {
        int n = 9;
        bool outside = n is not (>= 1 and <= 5);
        Console.WriteLine(outside);
    }
}

Combiner avec des patrons de type

Les patrons logiques peuvent également être associés à des patrons de type. o is int or long correspond aux types numériques entiers dans une seule vérification.

C’est pratique pour traiter uniformément plusieurs types associés. Notez que les deux côtés de or doivent être compatibles avec l’utilisation qui sera faite du résultat.

object o = 5L;
string kind = o switch
{
    int or long => "integral",
    float or double => "floating",
    _ => "other"
};
System.Console.WriteLine(kind);

Recommandations de lisibilité

Les motifs logiques sont expressifs, mais peuvent devenir denses. Gardez les branches courtes, préférez les plages avec and et mettez entre parenthèses les combinaisons de and/or pour plus de clarté.

Lorsqu’une condition nécessite de nombreuses clauses ou des variables externes, une garde when peut être plus lisible qu’un long motif logique. Choisissez la forme qui communique le mieux l’intention.

int n = 42;
string r = n switch
{
    > 0 and < 10 when n % 2 == 0 => "small even",
    _ => "other"
};
System.Console.WriteLine(r);

Vérification rapide

Vérifiez votre compréhension des motifs relationnels et logiques.

Récapitulatif

Les motifs relationnels (< > <= >=) comparent des valeurs à des constantes. Les motifs logiques combinent des sous-motifs avec and, or et not.

La priorité est not, puis and, puis or ; mettez entre parenthèses les combinaisons. Nous abordons ensuite les motifs de liste et de tuple.

Questions Fréquemment Posées

La leçon « Schémas relationnels et logiques » est-elle gratuite ?

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

Combinez des conditions dans les schémas. 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 3 sur 4.

Combien de temps prend la leçon « Schémas relationnels et logiques » ?

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