Aller au contenu
learn
Menu global

1. Installer .NET et exécuter ton premier programme

Code : examples/l01_hello.cs, examples/l01_statements.cs, les extraits refusés dans compile_fail/ et le projet l01-project/Hello.

Ce qu’est un programme

Section intitulée « Ce qu’est un programme »

Un programme est une liste d’instructions pour l’ordinateur, écrite dans un langage que les humains peuvent lire. L’ordinateur ne peut pas exécuter ce texte directement : un outil appelé compilateur commence par le vérifier et le traduire.

Avec C#, la traduction se fait en deux étapes :

flowchart LR
    A["hello.cs<br/>ton code C#"] -->|"le compilateur C#<br/>vérifie et traduit"| B["hello.dll<br/>langage intermédiaire"]
    B -->|"runtime .NET<br/>traduit en code machine pendant l'exécution"| C["Sortie<br/>Hello, world!"]
  1. Le compilateur C# lit ton fichier .cs. Si quelque chose ne va pas, il s’arrête et affiche une erreur. Sinon, il écrit un fichier .dll dans un langage intermédiaire (IL), le même sur tous les ordinateurs.
  2. Le runtime .NET charge la .dll et la transforme en instructions pour ton processeur pendant que le programme s’exécute.

Tu installes les deux d’un coup avec le SDK .NET (Software Development Kit, kit de développement). Il contient aussi la commande dotnet, qui te servira pour tout : créer, compiler, exécuter et tester des programmes. La présentation de .NET décrit les pièces plus en détail.

Ce cours utilise .NET 10, une version à support long terme, et C# 14, la version du langage qui l’accompagne.

Ouvrir un terminal

Section intitulée « Ouvrir un terminal »

Un terminal est une fenêtre où tu tapes des commandes. Chaque commande de ce cours se tape là, puis s’exécute avec Entrée.

Appuie sur Win, tape Terminal, et ouvre Terminal. Il démarre PowerShell. Sous Windows 10, si Terminal n’est pas installé, ouvre plutôt Windows PowerShell.

Installer le SDK .NET

Section intitulée « Installer le SDK .NET »

Windows inclut le gestionnaire de paquets WinGet. Dans le terminal :

Fenêtre de terminal
winget install Microsoft.DotNet.SDK.10

Ferme le terminal et ouvres-en un nouveau, pour qu’il trouve la commande dotnet. Tu peux aussi télécharger l’installeur depuis la page de téléchargement de .NET. Le guide d’installation pour Windows liste les autres méthodes.

Vérifie ensuite que le SDK répond :

> dotnet --version
10.0.112

Toute version qui commence par 10.0 convient. Si le terminal dit que dotnet n’est pas reconnu, ou command not found, ouvre un nouveau terminal ; si ça échoue encore, reprends le guide d’installation de ton OS.

Ton premier programme

Section intitulée « Ton premier programme »

Crée un dossier pour le cours, et crée dedans un fichier nommé hello.cs avec n’importe quel éditeur de texte (Bloc-notes, TextEdit, nano, ou les éditeurs décrits à la fin de cette leçon). Tapes-y cette seule ligne :

Console.WriteLine("Hello, world!");

Enregistre le fichier, va dans son dossier dans le terminal avec cd, et exécute-le :

> dotnet run hello.cs
Hello, world!

dotnet run a compilé le fichier, puis l’a exécuté. Exécuter à nouveau le même fichier est plus rapide : le SDK garde le programme compilé et ne recompile que si le fichier change. Un fichier .cs unique exécuté ainsi est une application basée sur un fichier (file-based app), une nouveauté de .NET 10. La plupart des exemples de ce cours sont des applications basées sur un fichier.

Lisons la ligne morceau par morceau :

Morceau Sens
Console la console : la fenêtre de texte dans laquelle ton programme écrit
. « dans » : WriteLine appartient à Console
WriteLine une méthode, un travail qui porte un nom : écrire une ligne de texte
( … ) ce que tu donnes à la méthode pour travailler, son argument
"Hello, world!" une chaîne (string) : du texte, entre guillemets droits doubles
; la fin de l’instruction, comme le point à la fin d’une phrase

C# est sensible à la casse : Console et console sont deux noms différents, et seul le premier existe. Les guillemets ne sont pas affichés : ils indiquent seulement au compilateur où le texte commence et où il finit.

Plusieurs instructions

Section intitulée « Plusieurs instructions »

Un programme exécute ses instructions l’une après l’autre, de haut en bas :

// Un commentaire commence par deux barres obliques : le compilateur l'ignore
Console.WriteLine("Guitar Alchemist tunes a guitar like this:");
Console.Write("E2 A2 D3 ");   // Write ne passe pas à la ligne suivante
Console.Write("G3 B3 E4");
Console.WriteLine();          // un WriteLine vide termine la ligne
Console.WriteLine("Six strings, from the lowest to the highest.");


/* Un commentaire peut aussi
   s'étendre sur plusieurs lignes */
Console.WriteLine(6 * 12);    // l'ordinateur calcule, puis affiche le résultat
> dotnet run examples/l01_statements.cs
Guitar Alchemist tunes a guitar like this:
E2 A2 D3 G3 B3 E4
Six strings, from the lowest to the highest.
72
  • Console.Write écrit du texte et reste sur la même ligne ; Console.WriteLine écrit du texte et passe à la ligne suivante.
  • Un commentaire est une note pour les humains. // met en commentaire le reste de la ligne ; /* et */ entourent un commentaire qui peut s’étendre sur plusieurs lignes.
  • 6 * 12 n’a pas de guillemets : ce n’est pas du texte, c’est un calcul. Le programme calcule 72 et affiche le nombre. Avec des guillemets, "6 * 12" afficherait les caractères 6 * 12.

L’accordage vient de Guitar Alchemist, une application C# consacrée à la musique : son accordage par défaut s’écrit E2 A2 D3 G3 B3 E4 dans Tuning.cs. Une lettre est une note en notation anglaise (E pour mi, A pour la…), le nombre est son octave.

Dans une application basée sur un fichier, les instructions en haut du fichier sont le point de départ du programme. La documentation C# les appelle instructions de niveau supérieur.

Lire une erreur du compilateur

Section intitulée « Lire une erreur du compilateur »

Tout le monde fait des erreurs en tapant du code. Le compilateur les trouve avant que le programme ne s’exécute. Ici, il manque le point-virgule à la fin de la première ligne :

Console.WriteLine("Hello, world!")
Console.WriteLine("Goodbye!");
> dotnet run l01_missing_semicolon.cs
C:\Users\spare\source\repos\learn\code\csharp-beginner\compile_fail\l01_missing_semicolon.cs(1,35): error CS1002: ; expected


The build failed. Fix the build errors and run again.

La ligne d’erreur a cinq parties :

Partie Ici Sens
fichier C:\…\l01_missing_semicolon.cs quel fichier
position (1,35) ligne 1, colonne 35 : le caractère où le compilateur a remarqué le problème
type error le programme ne peut pas être compilé ; un warning (avertissement) le laisserait s’exécuter
code CS1002 le numéro de l’erreur : cherche-le dans la liste des messages du compilateur
message ; expected ce que le compilateur s’attendait à trouver (ici, un ;)

La colonne 35 est juste après la parenthèse fermante, là où devrait se trouver le ;. Rien ne s’est exécuté : pas même la deuxième ligne. Le chemin complet du fichier dépend de ton dossier, donc la suite du cours n’affiche que le nom du fichier.

Deux autres erreurs que fait chaque débutant. Un console en minuscules :

console.WriteLine("Hello, world!");
l01_lowercase.cs(1,1): error CS0103: The name 'console' does not exist in the current context

Un guillemet fermant manquant :

Console.WriteLine("Hello, world!);
l01_missing_quote.cs(1,19): error CS1010: Newline in constant
l01_missing_quote.cs(1,35): error CS1026: ) expected
l01_missing_quote.cs(1,35): error CS1002: ; expected

Une faute, trois erreurs. Sans le guillemet fermant, la chaîne va jusqu’au bout de la ligne (CS1010, « newline in constant », retour à la ligne dans une constante), et elle avale la ) et le ;, qui manquent donc aussi. Corrige d’abord la première erreur, puis relance : les suivantes disparaissent souvent avec elle.

Exécuter un fichier comme un script

Section intitulée « Exécuter un fichier comme un script »

Sous Linux et macOS, une application basée sur un fichier peut s’exécuter comme n’importe quelle autre commande. Sa première ligne, qui commence par un dièse et un point d’exclamation, #! (un shebang), dit au système de l’exécuter avec dotnet :

#!/usr/bin/env -S dotnet --
Console.WriteLine("Hello from a script!");

Windows ne lit pas les lignes shebang. dotnet run l01_shebang.cs fonctionne quand même : le compilateur ignore la première ligne.

Un projet

Section intitulée « Un projet »

Un seul fichier est parfait pour apprendre et pour les petits outils. Les programmes plus gros ont beaucoup de fichiers, et un projet les regroupe. dotnet new console en crée un :

> dotnet new console -o HelloApp
The template "Console App" was created successfully.


Processing post-creation actions...
Restoring C:\Users\spare\…\HelloApp\HelloApp.csproj:
  Determining projects to restore...
  Restored C:\Users\spare\…\HelloApp\HelloApp.csproj (in 66 ms).
Restore succeeded.

-o HelloApp donne le nom du dossier de sortie, et le projet prend ce nom. Le dossier contient deux fichiers, et un dossier obj utilisé par la compilation :

HelloApp/
├── HelloApp.csproj   ← le fichier projet : comment compiler le programme
├── Program.cs        ← le code
└── obj/
<Project Sdk="Microsoft.NET.Sdk">


  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>


</Project>
  • OutputType Exe : le projet produit un programme que tu peux exécuter, pas une bibliothèque pour d’autres programmes.
  • TargetFramework net10.0 : le programme s’exécute sur .NET 10.
  • ImplicitUsings et Nullable activent deux commodités sur lesquelles revient la leçon 4. Les applications basées sur un fichier les activent aussi.

Program.cs contient le même genre de code que hello.cs :

// See https://aka.ms/new-console-template for more information
Console.WriteLine("Hello, World!");

Dans le dossier du projet, dotnet run n’a pas besoin de nom de fichier : il trouve le fichier .csproj.

> cd HelloApp
> dotnet run
Hello, World!

dotnet build se contente de compiler, et écrit le programme dans bin/Debug/net10.0/ : HelloApp.dll, et sous Windows un HelloApp.exe qui le lance.

Quand une application basée sur un fichier grandit, dotnet project convert hello.cs la transforme en projet : la commande crée un dossier avec un fichier .csproj et une copie du code.

Tu veux Application basée sur un fichier Projet
Créer n’importe quel éditeur : un fichier .cs dotnet new console -o Name
Exécuter dotnet run hello.cs dotnet run, dans le dossier
Seulement compiler dotnet build hello.cs dotnet build
Plusieurs fichiers de code un seul fichier ; les SDK 10.0.300 et suivants ajoutent #:include oui
Idéal pour apprendre, les scripts, les petits outils les applications, les bibliothèques, les tests

Choisir un éditeur

Section intitulée « Choisir un éditeur »

N’importe quel éditeur de texte fonctionne, mais un éditeur de code colore le code, complète les noms pendant que tu tapes, souligne les erreurs avant l’exécution, et te laisse exécuter le programme pas à pas avec un débogueur (leçon 3). Trois éditeurs sont faits pour C# :

Éditeur Fonctionne sous Prix Remarques
Visual Studio Code avec l’extension C# Dev Kit Windows, Linux, macOS gratuit ; le C# Dev Kit est gratuit pour les particuliers léger, le choix le plus courant pour apprendre
Visual Studio Community Windows gratuit pour les particuliers et les étudiants un environnement complet et volumineux
JetBrains Rider Windows, Linux, macOS gratuit pour un usage non commercial un environnement complet de JetBrains

Rider et VS Code sont installés sur l’ordinateur sur lequel ce cours a été écrit. Les licences changent avec le temps : lis les conditions de chaque éditeur quand tu l’installes (à vérifier).

À retenir

Section intitulée « À retenir »
  • Le SDK .NET contient le compilateur C#, le runtime .NET et la commande dotnet ; dotnet --version vérifie qu’il est installé.
  • dotnet run hello.cs compile et exécute un fichier ; dans le dossier d’un projet, dotnet run compile et exécute le projet.
  • Une instruction se termine par ;, les chaînes se mettent entre guillemets doubles, et C# est sensible à la casse.
  • Une erreur du compilateur donne le fichier, la ligne et la colonne, un code comme CS1002, et un message : corrige d’abord la première erreur.
  • dotnet new console crée un projet : un fichier .csproj qui dit comment compiler, et Program.cs.

Exercices

Section intitulée « Exercices »
  1. Écris une application basée sur un fichier chord.cs qui affiche le nom d’un accord, les six cordes, et les cases à appuyer pour un accord de do majeur (x 3 2 0 1 0 : x veut dire « ne pas jouer cette corde »). Sur une dernière ligne, affiche la somme des trois numéros de case, calculée par le programme.
Solution

exercises/l01_ex_chord.cs :

// Un accord de do majeur (x32010), dessiné avec un WriteLine par ligne
Console.WriteLine("C major");
Console.WriteLine("E A D G B E");
Console.WriteLine("x 3 2 0 1 0");
Console.WriteLine("Frets played: " + (3 + 2 + 1));
C major
E A D G B E
x 3 2 0 1 0
Frets played: 6

"Frets played: " + (3 + 2 + 1) calcule d’abord les parenthèses, 6, puis + colle le texte et le nombre. Sans les parenthèses, le résultat serait Frets played: 321 : de gauche à droite, le texte plus 3 donne le texte Frets played: 3, et ainsi de suite. La leçon 2 explique pourquoi.

  1. Ce programme contient trois fautes. Exécute-le, corrige ce que signale le compilateur, et relance-le jusqu’à ce qu’il fonctionne. Combien de fois as-tu dû l’exécuter ?
Console.Writeline("Strings of a guitar:");
Console.WriteLine("E A D G B E")
Console.WriteLine("That makes " + 6 + " strings);
Solution

La première exécution signale le ; manquant ligne 2 et le guillemet manquant ligne 3 :

l01_ex_broken.cs(2,33): error CS1002: ; expected
l01_ex_broken.cs(3,39): error CS1010: Newline in constant
l01_ex_broken.cs(3,50): error CS1026: ) expected
l01_ex_broken.cs(3,50): error CS1002: ; expected

Elle ne dit rien de Writeline ligne 1. Le compilateur travaille par étapes : il vérifie d’abord que le texte a la forme du C# (la syntaxe), et seulement si c’est le cas, que les noms existent. Une fois les lignes 2 et 3 corrigées, la deuxième exécution trouve la troisième faute :

l01_ex_broken_step2.cs(1,9): error CS0117: 'Console' does not contain a definition for 'Writeline'

La méthode s’appelle WriteLine, avec un L majuscule. La troisième exécution fonctionne (exercises/l01_ex_fixed.cs) :

Strings of a guitar:
E A D G B E
That makes 6 strings
  1. Crée un projet avec dotnet new console -o Tuning, remplace le code de Program.cs par le programme de Plusieurs instructions, et exécute-le. Ensuite, toujours dans le dossier, lance dotnet build et trouve le fichier .dll. Quel est son nom ?
Solution

dotnet run affiche les mêmes quatre lignes que dotnet run l01_statements.cs. dotnet build écrit bin/Debug/net10.0/Tuning.dll : le programme porte le nom du projet, pas celui de Program.cs. dotnet bin/Debug/net10.0/Tuning.dll l’exécute sans recompiler.

Sources

Section intitulée « Sources »