Exercice - Blocs de code et étendue des variables
- 11 minutes
Un bloc de code est constitué d’une ou plusieurs instructions C# qui définissent un chemin d’exécution. Les instructions en dehors d’un bloc de code affectent quand, si et à quelle fréquence ce bloc de code est exécuté au moment de l’exécution. Les limites d’un bloc de code sont généralement définies par des accolades, {}.
Outre leur effet sur le chemin d’exécution, les blocs de code peuvent également affecter l’étendue de vos variables. Les exemples de code que vous examinez au cours de cet exercice vous aideront à comprendre la relation entre les blocs de code et l’étendue des variables.
Les blocs de code ont un impact sur l’étendue d’une déclaration de variable
L’étendue d’une variable fait référence à la visibilité de la variable pour le reste du code de votre application. Une variable dont l’étendue est locale n’est accessible qu’à l’intérieur du bloc de code où elle est définie. Si vous tentez d’accéder à la variable en dehors du bloc de code, vous recevez une erreur du compilateur.
Le reste de cette unité explore la relation entre les blocs de code et l’étendue des variables.
Préparer votre environnement de programmation
Ce module comprend des activités pratiques qui vous guident tout au long du processus de création et d’exécution du code de démonstration. Si possible, effectuez ces activités en utilisant Visual Studio Code comme environnement de développement. L’utilisation de Visual Studio Code pour ces activités vous permet d’être plus à l’aise dans l’écriture et l’exécution de code dans un environnement de développement qui est utilisé par les professionnels du monde entier.
Ouvrez Visual Studio Code.
Vous pouvez utiliser le menu Démarrer de Windows (ou une ressource équivalente pour un autre système d’exploitation) pour ouvrir Visual Studio Code.
Dans Visual Studio Code, dans le menu Fichier, sélectionnez Ouvrir un dossier.
Dans la boîte de dialogue Ouvrir un dossier, accédez au dossier Bureau Windows.
Si vous conservez vos projets de code dans un autre dossier, vous pouvez utiliser cet emplacement à la place. Pour cette formation, l’important est d’avoir un emplacement facile à localiser et à mémoriser.
Dans la boîte de dialogue Ouvrir un dossier, sélectionnez Sélectionner un dossier.
Si une boîte de dialogue de sécurité vous demande si vous faites confiance aux auteurs, sélectionnez Oui.
Dans le menu Terminal de Visual Studio Code, sélectionnez Nouveau Terminal.
Notez qu’une invite de commandes dans le panneau Terminal affiche le chemin du dossier actif. Par exemple :
C:\Users\someuser\Desktop>Notes
Si vous travaillez sur votre propre PC plutôt que dans un bac à sable ou un environnement hébergé et que vous avez terminé d’autres modules Microsoft Learn de cette série sur C#, vous avez peut-être déjà créé un dossier de projet pour les exemples de code. Si c’est le cas, vous pouvez passer à l’étape suivante, qui est utilisée pour créer une application console dans le dossier TestProject.
À l’invite de commandes terminal, pour créer une application console dans un dossier spécifié, entrez l’invite suivante :
dotnet new console -o ./CsharpProjects/TestProjectCette commande CLI .NET utilise un modèle de programme .NET pour créer un projet d’application console C# à l’emplacement du dossier spécifié. La commande crée les dossiers CsharpProjects et TestProject automatiquement, et utilise TestProject comme nom pour votre fichier
.csproj.Si un message s’affiche pour vous indiquer que les fichiers existent déjà, passez aux étapes suivantes. Vous allez réutiliser les fichiers projet existants.
Dans l’affichage EXPLORATEUR, développez le dossier CsharpProjects .
Vous devez voir le dossier TestProject et deux fichiers, un fichier de programme C# nommé Program.cs et un fichier projet C# nommé TestProject.csproj.
Dans Visual Studio Code, dans le menu Fichier, sélectionnez Ouvrir un dossier.
Dans la boîte de dialogue Ouvrir un dossier , sélectionnez le dossier CsharpProjects , puis sélectionnez Sélectionner un dossier.
Dans l’affichage EXPLORATEUR, développez le dossier TestProject, puis sélectionnez Program.cs.
Supprimez les lignes de code existantes.
Vous allez utiliser ce projet de console C# pour créer, générer et exécuter des exemples de code au cours de ce module.
Fermez le panneau du Terminal.
Créer une variable à l’intérieur d’un bloc de code
Vous allez commencer en examinant le cas où une variable est initialisée à l’intérieur d’un bloc de code.
Vérifiez que Visual Studio Code est ouvert et que Program.cs est affiché dans le panneau Éditeur.
Notes
Program.cs doit être vide. Si ce n’est pas le cas, sélectionnez toutes les lignes de code et supprimez-les.
Tapez le code suivant dans l’Éditeur Visual Studio Code :
bool flag = true; if (flag) { int value = 10; Console.WriteLine($"Inside the code block: {value}"); }Dans le menu Fichier de Visual Studio Code, sélectionnez Enregistrer.
Vous devez enregistrer le fichier Program.cs avant de générer ou d’exécuter le code.
Dans le panneau EXPLORATEUR, pour ouvrir un Terminal à l’emplacement de votre dossier TestProject, cliquez avec le bouton droit sur TestProject, puis sélectionnez Ouvrir dans le Terminal intégré.
Un panneau Terminal s’ouvre. Le Terminal doit inclure une invite de commandes indiquant qu’il est ouvert à l’emplacement de votre dossier TestProject.
À l’invite de commandes du Terminal, pour exécuter votre code, tapez dotnet run, puis appuyez sur Entrée.
Notes
Si vous voyez un message indiquant « Impossible de trouver un projet à exécuter », vérifiez que l’invite de commandes Terminal affiche l’emplacement attendu du dossier TestProject. Par exemple :
C:\Users\someuser\Desktop\csharpprojects\TestProject>Vous devez normalement voir la sortie suivante.
Inside the code block: 10
Il s’agit du résultat attendu. Mais que se passe-t-il si vous voulez accéder à la variable value en dehors du bloc de code d’instruction if ?
Essayer d’accéder à une variable en dehors du bloc de code où elle est déclarée
Dans l’éditeur Visual Studio Code, créez une nouvelle ligne de code sous le bloc de code d’instruction
if.Sur la ligne de code vide que vous avez créée, ajoutez la ligne de code suivante :
Console.WriteLine($"Outside the code block: {value}");Vérifiez que votre code mis à jour se présente comme ceci :
bool flag = true; if (flag) { int value = 10; Console.WriteLine($"Inside the code block: {value}"); } Console.WriteLine($"Outside the code block: {value}");Enregistrez votre fichier de code, puis utilisez Visual Studio Code pour exécuter votre code.
Entrez
dotnet runà partir de l’invite de commandes du Terminal pour exécuter votre code.Notez que lorsque vous tentez d’exécuter l’application, vous obtenez une erreur de compilation :
Program.cs(7,46): error CS0103: The name 'value' does not exist in the current context
La partie Program.cs(7,46) du message vous indique que l’erreur est associée à la ligne 7 du fichier Program.cs, colonne 46.
Cette erreur est générée car une variable déclarée à l’intérieur d’un bloc de code est accessible uniquement (peut seulement être visible) au sein de ce bloc de code. Étant donné qu’une variable n’est pas accessible en dehors du bloc de code dans lequel elle est déclarée, value n’est pas accessible à partir de la ligne 7 de votre code.
Une variable qui est déclarée dans un bloc de code de méthode est appelée variable locale. Vous pouvez voir le terme variable locale utilisée lors de l’examen d’articles qui traitent de l’étendue des variables.
Déplacer la déclaration de la variable au-dessus du bloc de code
Pour accéder à une variable à la fois à l’intérieur et à l’extérieur d’un bloc de code, vous devez déclarer la variable avant (ci-dessus) le bloc de code afin que le code en dehors du bloc de code puisse « voir » la variable.
Mettez à jour votre code dans l’Éditeur Visual Studio Code comme suit :
bool flag = true; int value; if (flag) { Console.WriteLine($"Inside the code block: {value}"); } value = 10; Console.WriteLine($"Outside the code block: {value}");Prenez le temps de passer en revue les mises à jour.
Notez que
valueest maintenant déclaré (mais pas initialisé) en dehors du bloc de codeif.Utiliser Visual Studio Code pour enregistrez vos mises à jour, puis pour exécuter votre code.
Notez que vous obtenez toujours une erreur de compilation.
Cette fois, quand vous essayez d’exécuter l’application, vous obtenez l’erreur de compilation suivante :
Program.cs(6,49): error CS0165: Use of unassigned local variable 'value'L’erreur est associée à la ligne 6 à l’intérieur du bloc de code car
valuen’est pas initialisée (n’a pas été affectée à une valeur). Si la ligne de codevalue = 10;était située au-dessus du bloc de code d’instructionif, l’application compilerait correctement et tout fonctionnerai. Toutefois, étant donné quevaluen’a pas été initialisé, il n’est pas accessible à l’intérieur du bloc de code.Assurez-vous que vos variables sont initialisées avant de tenter d’y accéder pour résoudre ce problème.
Initialiser une variable dans le cadre de la déclaration de variable
Pour initialiser
valuedans le cadre de la déclaration de variable, mettez à jour votre code comme suit :bool flag = true; int value = 0; if (flag) { Console.WriteLine($"Inside the code block: {value}"); } value = 10; Console.WriteLine($"Outside the code block: {value}");Ce code traite l’erreur de compilation « variable locale non attribuée » en initialisant
valuedans le cadre de votre déclaration de variable.Utilisez Visual Studio Code pour enregistrer et exécuter votre code.
Notez que maintenant, quand vous exécutez l’application, vous voyez la sortie suivante :
Inside the code block: 0 Outside the code block: 10
Examiner l’interprétation du compilateur de votre code
Pour éviter les erreurs de runtime, le compilateur C# analyse votre code dans Visual Studio Code Editor et pendant le processus de génération. Toutefois, le compilateur peut ne pas toujours interpréter votre code de la même manière que vous.
Examinez les deux exemples de code suivants qui semblent avoir le même objectif :
// Code sample 1
bool flag = true;
int value;
if (flag)
{
value = 10;
Console.WriteLine($"Inside the code block: {value}");
}
Console.WriteLine($"Outside the code block: {value}");
// Code sample 2
int value;
if (true)
{
value = 10;
Console.WriteLine($"Inside the code block: {value}");
}
Console.WriteLine($"Outside the code block: {value}");
Vous pouvez constater que ces deux exemples doivent toujours produire le même résultat, mais le compilateur C# interprète ces deux exemples de code différemment.
Pour le premier exemple de code, le compilateur interprète flag comme une variable booléenne qui peut être affectée à une valeur soit true, soit false. Le compilateur conclut que si flag est false, value ne sera pas initialisé lorsque la seconde Console.WriteLine() est exécutée. Essentiellement, le compilateur considère que les deux chemins d’exécution de code suivants sont possibles :
// path when flag = true
int value;
value = 10;
Console.WriteLine($"Inside the code block: {value}");
Console.WriteLine($"Outside the code block: {value}");
ET
// path when flag = false
int value;
Console.WriteLine($"Outside the code block: {value}");
Étant donné que le compilateur considère le deuxième chemin d’accès une possibilité (pour l’exemple de code 1), il génère un message d’erreur pendant le processus de génération. En outre, l’éditeur de code dans Visual Studio Code vous avertit de ce problème en affichant une ligne rouge ondulée sous value (sous le bloc de code).
Pour le deuxième exemple de code, le compilateur conclut que le contenu du bloc de code d’instruction if sera toujours exécuté (true est toujours true). Le compilateur ne génère pas d’erreur de génération, car il interprète que le deuxième exemple de code possède un chemin d’exécution unique comme suit :
int value;
value = 10;
Console.WriteLine($"Inside the code block: {value}");
Console.WriteLine($"Outside the code block: {value}");
Récapitulatif
Voici quelques points importants à retenir à propos des blocs de code :
- Quand vous déclarez une variable à l’intérieur d’un bloc de code, sa visibilité est locale à ce bloc de code et cette variable est inaccessible en dehors de ce bloc de code.
- Pour vous assurer qu’une variable est visible à la fois à l’intérieur et à l’extérieur d’un bloc de code, vous devez déclarer la variable avant le bloc de code (en dehors et au-dessus du bloc de code).
- Vérifiez que les variables sont initialisées avant que votre code tente d’y accéder (pour tous les chemins d’exécution de code potentiels).