Tutoriel : Instructions et boucles C# `if` - Logique conditionnelle

Ce tutoriel vous explique comment écrire du code C# qui examine les variables et modifie le chemin d’exécution en fonction de ces variables. Vous écrivez du code C# et voyez les résultats de la compilation et de l’exécution. Le tutoriel contient une série de leçons qui explorent les constructions de branchement et de bouclage en C#. Ces leçons vous enseignent les principes fondamentaux de la langue C#.

Dans ce tutoriel, vous allez :

Lancez un espace de code GitHub avec un environnement de développement C#.
Explorez les instructions if et else.
Utilisez des boucles pour répéter les opérations.
Utiliser des boucles imbriquées.
Combinez des branches et des boucles.

Prerequisites

Vous devez disposer de l’une des options suivantes :

Un compte GitHub pour utiliser GitHub Codespaces. Si vous n’en avez pas encore, vous pouvez créer un compte gratuit à GitHub.com.
Un ordinateur avec les outils suivants installés :

Utilisez l'instruction if

Pour démarrer un Espace de code GitHub avec l’environnement du didacticiel, ouvrez une fenêtre de navigateur dans le référentiel codespace du didacticiel . Sélectionnez le bouton Code vert et l’onglet Espaces de code . Sélectionnez ensuite le + signe pour créer un espace de code à l’aide de cet environnement. Si vous avez terminé d’autres didacticiels de cette série, vous pouvez ouvrir cet espace de code au lieu de en créer un nouveau.

Lorsque votre espace de code se charge, créez un fichier dans le dossier didacticiels nommé branches-loops.cs.
Ouvrez votre nouveau fichier.

Tapez ou copiez le code suivant dans branches-loops.cs :

int a = 5;
int b = 6;
if (a + b > 10)
    Console.WriteLine("The answer is greater than 10.");

Essayez ce code en tapant la commande suivante dans le terminal intégré :
```
cd tutorials
dotnet branches-loops.cs
```
Le message « La réponse est supérieure à 10 » doit s’afficher dans votre console.
Modifiez la déclaration de b sorte que la somme soit inférieure à 10 :
```
int b = 3;
```
Tapez dotnet branches-loops.cs à nouveau dans la fenêtre de terminal.

Étant donné que la réponse est inférieure à 10, rien n’est imprimé. La condition que vous testez est false. Vous n’avez pas de code à exécuter, car vous n’avez écrit qu’une des branches possibles pour une if instruction : la véritable branche.

Conseil / Astuce

Lorsque vous explorez C# (ou n’importe quel langage de programmation), vous pouvez faire des erreurs lorsque vous écrivez du code. Le compilateur recherche et signale les erreurs. Examinez attentivement la sortie d’erreur et le code qui a généré l’erreur. Vous pouvez également demander à Copilot de trouver des différences ou de repérer les erreurs. L’erreur du compilateur peut généralement vous aider à trouver le problème.

Cet exemple montre la puissance des types Boolean et de if. Une valeur booléenne est une variable qui peut avoir l’une des deux valeurs suivantes : true ou false. C# définit un type spécial pour bool les variables booléennes. L’instruction if vérifie la valeur d’un bool. Quand la valeur est true, l’instruction qui suit if s’exécute. Dans le cas contraire, il est ignoré. Ce processus de vérification des conditions et d’exécution d’instructions basées sur ces conditions est puissant. Examinons-en davantage.

Utiliser if et else ensemble

Pour exécuter un code différent dans les branches true et false, vous créez une else branche qui s’exécute lorsque la condition est false. Essayer une branche else.

Ajoutez les deux dernières lignes dans l’extrait de code suivant (vous devez déjà avoir les quatre premières) :
```
int a = 5;
int b = 3;
if (a + b > 10)
    Console.WriteLine("The answer is greater than 10");
else
    Console.WriteLine("The answer is not greater than 10");
```
L’instruction qui suit le else mot clé s’exécute uniquement lorsque la condition testée est false. La combinaison de if et de else avec des conditions booléennes fournit tout ce dont vous avez besoin pour gérer à la fois une condition true et une condition false.

Importante

La mise en retrait sous les déclarations if et else est destinée aux lecteurs humains. Le langage C# ne traite pas la mise en retrait ou l’espace blanc comme significatif. L'instruction qui suit le mot-clé if ou else s'exécute en fonction de la condition. Tous les exemples de ce didacticiel suivent une pratique courante pour mettre en retrait les lignes en fonction du flux de contrôle des instructions.

Étant donné que la mise en retrait n’est pas significative, vous devez utiliser { et } indiquer quand vous souhaitez que plusieurs instructions font partie du bloc qui s’exécute de manière conditionnelle. Les programmeurs C# utilisent généralement les accolades pour toutes les clauses if et else.
L’exemple suivant est le même que celui que vous avez créé dans l’exemple précédent, avec l’ajout de { et }. Modifiez votre code pour qu’il corresponde au code suivant :
```
int a = 5;
int b = 3;
if (a + b > 10)
{
    Console.WriteLine("The answer is greater than 10");
}
else
{
    Console.WriteLine("The answer is not greater than 10");
}
```
Conseil / Astuce

Dans le reste de ce didacticiel, tous les exemples de code incluent les accolades, conformément aux pratiques acceptées.
Vous pouvez tester des conditions plus complexes. Ajoutez le code suivant après le code que vous avez écrit jusqu’à présent :
```
int a = 5;
int b = 3;
int c = 4;
if ((a + b + c > 10) && (a == b))
{
    Console.WriteLine("The answer is greater than 10");
    Console.WriteLine("And the first number is equal to the second");
}
else
{
    Console.WriteLine("The answer is not greater than 10");
    Console.WriteLine("Or the first number is not equal to the second");
}
```
Le symbole == teste l’égalité. == se distingue du test d’égalité d’attribution, que nous avons vu avec a = 5.

Le && représente « et ». Cela signifie que les deux conditions doivent être true pour que l’instruction s’exécute dans la branche true. Ces exemples montrent également que vous pouvez avoir plusieurs instructions dans chaque branche conditionnelle, à condition de les placer dans { et }.
Vous pouvez également utiliser || pour représenter « ou ». Ajoutez le code suivant après ce que vous avez écrit jusqu’à présent :
```
if ((a + b + c > 10) || (a == b))
```
Modifiez les valeurs de a, bet c basculez entre && et || pour explorer. Vous comprendrez mieux comment fonctionnent les opérateurs && et ||.

Vous avez terminé la première étape. Avant de commencer la section suivante, nous allons déplacer le code actuel dans une méthode distincte. Cela rend plus facile de commencer à travailler avec un nouvel exemple. Placez le code existant dans une méthode appelée ExploreIf(). Appelez-le au début de votre programme. Une fois ces modifications terminées, votre code doit ressembler au code suivant :

ExploreIf();

void ExploreIf()
{
    int a = 5;
    int b = 3;
    if (a + b > 10)
    {
        Console.WriteLine("The answer is greater than 10");
    }
    else
    {
        Console.WriteLine("The answer is not greater than 10");
    }

    int c = 4;
    if ((a + b + c > 10) && (a > b))
    {
        Console.WriteLine("The answer is greater than 10");
        Console.WriteLine("And the first number is greater than the second");
    }
    else
    {
        Console.WriteLine("The answer is not greater than 10");
        Console.WriteLine("Or the first number is not greater than the second");
    }

    if ((a + b + c > 10) || (a > b))
    {
        Console.WriteLine("The answer is greater than 10");
        Console.WriteLine("Or the first number is greater than the second");
    }
    else
    {
        Console.WriteLine("The answer is not greater than 10");
        Console.WriteLine("And the first number is not greater than the second");
    }
}

Commentez l’appel à ExploreIf(). La sortie est moins encombrée lorsque vous travaillez dans cette section :
```
//ExploreIf();
```

Le // commence un commentaire en C#. Les commentaires sont n’importe quel texte que vous souhaitez conserver dans votre code source, mais pas en tant que code. Le compilateur ne génère aucun code exécutable à partir de commentaires.

Utiliser des boucles pour répéter des opérations

Un autre concept important pour la création de programmes plus volumineux est des boucles. Utilisez des boucles pour répéter des instructions que vous souhaitez exécuter plusieurs fois.

Ajoutez ce code après l’appel à ExploreIf:
```
int counter = 0;
while (counter < 10)
{
    Console.WriteLine($"Hello World! The counter is {counter}");
    counter++;
}
```
L’instruction while vérifie une condition et exécute l’instruction suivant .while Elle répète la vérification de la condition et l’exécution de ces instructions jusqu’à ce que la condition soit false.

Il existe un autre nouvel opérateur dans cet exemple. ++ après la variable counter est l’opérateur d’incrémentation. Il ajoute 1 à la valeur de counter la variable et stocke cette valeur dans la counter variable.

Importante

Assurez-vous que la condition de while boucle passe à false lorsque vous exécutez le code. Sinon, vous créez une boucle infinie où votre programme ne se termine jamais. Ce comportement n’est pas démontré dans cet exemple, car vous devez forcer votre programme à quitter à l’aide de Ctrl-C ou d’autres moyens.

La while boucle teste la condition avant d’exécuter le code suivant le while.
La do boucle ... while exécute d’abord le code, puis vérifie la condition. La boucle do while s’affiche dans le code suivant :
```
int counter = 0;
do
{
    Console.WriteLine($"Hello World! The counter is {counter}");
    counter++;
} while (counter < 10);
```
Cette do boucle et la boucle précédente while produisent la même sortie.

Passons maintenant à une dernière instruction de boucle.

Utiliser la boucle for

Une autre instruction de boucle courante que vous voyez dans le code C# est la for boucle.

Essayez ce code :
```
for (int counter = 0; counter < 10; counter++)
{
    Console.WriteLine($"Hello World! The counter is {counter}");
}
```
La boucle précédente for effectue le même travail que la while boucle et la do boucle que vous avez déjà utilisée. L’instruction for comporte trois parties qui contrôlent son fonctionnement :
- La première partie est l’initialiseur for : int counter = 0; déclare counter comme la variable de boucle et définit sa valeur initiale à 0.
- La partie centrale est la condition for : counter < 10 déclare que cette for boucle continue à s’exécuter tant que la valeur est counter inférieure à 10.
- La dernière partie est l’itérateur pour : counter++ spécifie comment modifier la variable de boucle après l’exécution du bloc suivant l’instruction for . Ici, il spécifie que counter est incrémenté de 1 chaque fois que le bloc s’exécute.
Expérimentez ces conditions vous-même. Essayez chacune des modifications suivantes :
- Modifiez l’initialiseur pour commencer à une autre valeur.
- Modifiez la condition pour qu’elle s’arrête à une autre valeur.

Lorsque vous avez terminé, passez à la section suivante pour écrire du code vous-même et utiliser ce que vous avez appris.

Il existe une autre instruction de bouclage qui n’est pas abordée dans ce tutoriel : l’instruction foreach . L’instruction foreach répète son instruction pour chaque élément dans une séquence d’éléments. Vous l’utilisez le plus souvent avec des collections. Il est abordé dans le tutoriel suivant.

Création de boucles imbriquées

Vous pouvez imbriquer une boucle while, do ou for à l’intérieur d’une autre boucle pour créer une matrice en combinant chaque élément de la boucle externe avec chaque élément de la boucle interne. Créons un ensemble de paires alphanumériques pour représenter des lignes et des colonnes.

Ajoutez la boucle suivante for qui génère les lignes :

for (int row = 1; row < 11; row++)
{
    Console.WriteLine($"The row is {row}");
}

Ajoutez une autre boucle pour générer les colonnes :

for (char column = 'a'; column < 'k'; column++)
{
    Console.WriteLine($"The column is {column}");
}

Enfin, imbriquez la boucle des colonnes dans celle des lignes pour former des paires :
```
for (int row = 1; row < 11; row++)
{
    for (char column = 'a'; column < 'k'; column++)
    {
        Console.WriteLine($"The cell is ({row}, {column})");
    }
}
```
La boucle externe incrémente une fois pour chaque exécution complète de la boucle interne. Inversez l’imbrication des lignes et des colonnes et observez les modifications. Lorsque vous avez terminé, placez le code de cette section dans une méthode appelée ExploreLoops().

Combiner des branches et des boucles

Maintenant que vous avez utilisé l’instruction if et les constructions de bouclage dans le langage C#, vérifiez si vous pouvez écrire du code C# pour trouver la somme de tous les entiers 1 à 20 qui sont divisibles par 3. Voici quelques conseils :

L’opérateur % vous donne le reste d’une opération de division.
L’instruction if vous donne la condition pour voir si un nombre doit faire partie de la somme.
La for boucle peut vous aider à répéter une série d’étapes pour tous les nombres 1 à 20.

Essayez-le vous-même. Vérifiez ensuite comment vous l’avez fait. En guise d’indicateur, vous devriez obtenir 63 comme réponse.

Tu as trouvé quelque chose comme ça ?

int sum = 0;
for (int number = 1; number < 21; number++)
{
    if (number % 3 == 0)
    {
        sum = sum + number;
    }
}
Console.WriteLine($"The sum is {sum}");

Vous avez terminé le didacticiel « branches et boucles ». Pour en savoir plus sur ces concepts, consultez les articles suivants :

Nettoyer les ressources

GitHub supprime automatiquement votre Espace de code après 30 jours d’inactivité. Si vous envisagez d’explorer d’autres tutoriels de cette série, vous pouvez laisser votre espace de code provisionné. Si vous êtes prêt à visiter le site .NET pour télécharger le Kit de développement logiciel (SDK) .NET, vous pouvez supprimer votre espace de code. Pour supprimer votre espace de code, ouvrez une fenêtre de navigateur et accédez à vos espaces de code. Vous devez voir une liste de vos espaces de code dans la fenêtre. Sélectionnez les trois points (...) dans l’entrée de l’espace de code du didacticiel Learn, puis sélectionnez Supprimer.

Étape suivante

En savoir plus sur les collections

Rétroaction

Cette page vous a-t-elle été utile ?

Last updated on 2025-12-11