Skip to content

2. Installation de l'environnement de travail

En 2008, on installait Visual C# 2008 Express, qui apportait avec lui le framework .NET 3.5, le SGBD SQL Server Compact et la documentation MSDN, puis on créait des projets avec des assistants graphiques. Aujourd'hui, l'environnement de travail comprend deux éléments indépendants :

  • le SDK .NET (« Software Development Kit ») : le compilateur, la plateforme d'exécution, les bibliothèques et la commande [dotnet], qui permet de tout faire en ligne de commande (créer, compiler, exécuter, tester, publier un programme) ;
  • un éditeur ou un IDE (environnement de développement intégré) : [VS Code] avec l'extension [C# Dev Kit], ou [Visual Studio 2026], ou encore [JetBrains Rider]. L'éditeur s'appuie sur le SDK.

Ce document utilise la commande [dotnet] pour toutes les opérations : elle fonctionne de la même façon sous Windows, Linux et macOS, et quel que soit l'éditeur choisi.

2.1. Le SDK .NET 10

2.1.1. Installation

Le SDK .NET 10 se télécharge à l'adresse https://dotnet.microsoft.com/download/dotnet/10.0. Sous Windows, on peut aussi l'installer depuis un terminal (PowerShell ou invite de commandes) avec le gestionnaire de paquets [winget] :

1
winget install Microsoft.DotNet.SDK.10

Il faut choisir le SDK (qui contient tout) et non le « runtime » seul (qui ne permet que d'exécuter des programmes déjà compilés). Sous Linux, le SDK est disponible dans les dépôts des principales distributions (par exemple [sudo apt install dotnet-sdk-10.0] sous Ubuntu ; selon la version de la distribution, il peut falloir ajouter auparavant le dépôt indiqué par la documentation d'installation de Microsoft).

Après l'installation, on vérifie dans un nouveau terminal que la commande [dotnet] est disponible et donne la version du SDK :

1
2
> dotnet --version
10.0.112

La commande [dotnet --list-sdks] liste les SDK installés (plusieurs versions peuvent cohabiter) :

1
2
> dotnet --list-sdks
10.0.112 [C:\Program Files\dotnet\sdk]

La version exacte (ici [10.0.112]) dépend de la date de l'installation : Microsoft publie chaque mois une mise à jour corrective. Tous les SDK 10.0.x conviennent pour ce document. La commande [dotnet --info] donne des informations plus complètes (système d'exploitation, emplacement du SDK, versions des plateformes d'exécution installées).

2.1.2. La commande dotnet

La commande [dotnet] regroupe de nombreuses sous-commandes. Voici celles que nous utiliserons :

Commande
Rôle
[dotnet run fichier.cs]
compile et exécute une application fichier unique
[dotnet new console -n Nom]
crée un projet console dans le dossier [Nom] (autres modèles : [classlib], [mstest], [web]…)
[dotnet build]
compile le projet du dossier courant
[dotnet run]
compile (si nécessaire) et exécute le projet du dossier courant
[dotnet test]
exécute les tests unitaires (chapitre 6)
[dotnet new sln]
crée une solution (un fichier qui regroupe plusieurs projets)
[dotnet sln add Projet]
ajoute un projet à la solution
[dotnet add package Nom]
ajoute une bibliothèque NuGet au projet (chapitres 10 et 11)
[dotnet add reference ../Autre]
ajoute une référence à un autre projet (chapitre 6)
[dotnet publish]
prépare le programme pour son déploiement

Les bibliothèques qui ne font pas partie de la plateforme sont distribuées sous forme de paquets NuGet, téléchargés depuis le site https://www.nuget.org et conservés sur le poste dans le dossier [%USERPROFILE%\.nuget\packages]. En 2008, on copiait les DLL des bibliothèques (Spring.NET, NUnit, connecteur MySQL) dans un dossier [lib] du projet ; aujourd'hui, le projet déclare les paquets dont il a besoin et la commande [dotnet] les télécharge.

2.2. L'éditeur

2.2.1. VS Code

VS Code est un éditeur gratuit et multiplateforme. Pour programmer en C#, on lui ajoute l'extension C# Dev Kit de Microsoft (menu « Extensions », rechercher « C# Dev Kit »), qui installe aussi l'extension C#. On obtient :

  • la coloration syntaxique, la complétion du code et l'aide en survol ;
  • la détection des erreurs pendant la frappe ;
  • la navigation dans le code (F12 : atteindre la définition) ;
  • un explorateur de solution (vue « Solution Explorer ») ;
  • l'exécution et le débogage (F5) ;
  • l'exécution des tests unitaires (vue « Testing »).

On ouvre dans VS Code le dossier contenant les programmes (« File / Open Folder »), par exemple le dossier [csharp-oct-2026] des exemples du document. Le terminal intégré (« Terminal / New Terminal ») permet de taper les commandes [dotnet] sans quitter l'éditeur.

2.2.2. Visual Studio 2026

Sous Windows, on peut préférer l'IDE Visual Studio 2026, successeur de Visual Studio 2008 utilisé par le cours d'origine. Son édition Community est gratuite pour les particuliers, l'enseignement et les projets libres. On l'installe depuis https://visualstudio.microsoft.com en cochant la charge de travail « Développement .NET Desktop » (et « Développement web et ASP.NET » pour le chapitre 13). Visual Studio ouvre directement les solutions [.slnx] et les projets [.csproj] des exemples (« Fichier / Ouvrir / Projet/Solution »), et les exécute par [Ctrl-F5] (sans débogage) ou [F5] (avec débogage), comme en 2008.

Un troisième choix est JetBrains Rider, gratuit pour un usage non commercial.

Dans la suite du document, les opérations sont décrites avec la commande [dotnet], qui donne les mêmes résultats quel que soit l'éditeur.

2.3. Un premier programme : une application fichier unique

2.3.1. Le programme

Depuis .NET 10, un programme C# peut être un simple fichier [.cs], sans fichier de projet. On l'appelle une application fichier unique (« file-based app »). Créons le fichier [hello.cs] suivant :

1
2
// premier programme C# : une application fichier unique
Console.WriteLine("1er essai avec C# 14 et .NET 10");

et exécutons-le :

1
2
> dotnet run hello.cs
1er essai avec C# 14 et .NET 10

Commentaires :

  • ligne 1 : un commentaire. Tout ce qui suit [//] jusqu'à la fin de la ligne est ignoré par le compilateur ;
  • ligne 2 : la seule instruction du programme : elle écrit une ligne de texte à l'écran. Le programme n'a ni classe ni méthode [Main], contrairement à son équivalent de 2008 ; nous verrons au chapitre 3 que le compilateur les génère lui-même ;
  • la commande [dotnet run hello.cs] compile le programme puis l'exécute. La première exécution prend quelques secondes ; les suivantes sont presque immédiates tant que le fichier n'est pas modifié, car le résultat de la compilation est conservé dans un cache.

Les applications fichier unique conviennent aux petits programmes, et nous les utiliserons pour la plupart des exemples. Quelques directives, placées en tête du fichier, permettent de les compléter sans fichier de projet :

1
2
3
#:package MySqlConnector@2.4.0
#:property PublishAot=false
#:sdk Microsoft.NET.Sdk.Web
  • la directive [#:package] ajoute une bibliothèque NuGet (chapitre 10) ;
  • la directive [#:property] fixe une propriété de compilation (chapitre 5) ;
  • la directive [#:sdk] choisit un autre SDK, par exemple celui des applications web (chapitre 12).

Sous Windows, si les fichiers [.cs] sont enregistrés en UTF-8 (c'est le cas par défaut dans VS Code), les caractères accentués s'affichent correctement dans le terminal.

2.3.2. Transformer une application fichier unique en projet

Quand une application fichier unique grandit (plusieurs fichiers, des tests, des références à d'autres projets), on la transforme en projet :

1
> dotnet project convert hello.cs -o hello

La commande crée un dossier [hello] contenant une copie du programme et un fichier de projet [hello.csproj] :

1
2
3
4
> dir /s /b (liste des fichiers)
hello.cs
hello/hello.cs
hello/hello.csproj

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <PublishAot>true</PublishAot>
    <PackAsTool>true</PackAsTool>
    <UserSecretsId>hello-7b9b5da29436665281cfbf4b23ebf4fed6297358227418ac7d456d2e18d162bf</UserSecretsId>
  </PropertyGroup>

</Project>

Le fichier de projet reprend les propriétés implicites des applications fichier unique (par exemple [PublishAot], qui prépare une compilation anticipée en code natif). On peut retirer celles qui ne servent pas. Nous allons maintenant voir les projets plus en détail.

2.4. Un projet console

2.4.1. Création du projet

Un projet est un dossier contenant un fichier de projet [.csproj] et des fichiers source. On le crée avec la commande [dotnet new] suivie du nom d'un modèle (ici [console], une application console) :

1
2
3
4
5
6
7
8
> dotnet new console -n PremierProgramme
Le modèle « Application console » a bien été créé.

Traitement des actions postérieures à la création en cours... Merci de patienter.
Restauration de csharp-oct-2026/02-installation/PremierProgramme/PremierProgramme.csproj :
  Identification des projets à restaurer...
  Restauration effectuée de csharp-oct-2026/02-installation/PremierProgramme/PremierProgramme.csproj (en 127 ms).
Restauration réussie.

La commande a créé un dossier [PremierProgramme] contenant deux fichiers. Le fichier de projet [PremierProgramme.csproj] est le suivant :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
<Project Sdk="Microsoft.NET.Sdk">

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

</Project>
  • ligne 1 : le projet utilise le SDK [Microsoft.NET.Sdk], celui des applications console et des bibliothèques ;
  • ligne 4 : le projet produit un exécutable ([Exe]) et non une bibliothèque ;
  • ligne 5 : la plateforme cible est .NET 10 ([net10.0]) ;
  • ligne 6 : les espaces de noms les plus courants ([System], [System.IO], [System.Linq]…) sont importés automatiquement dans tous les fichiers (chapitre 3) ;
  • ligne 7 : le compilateur vérifie l'usage des références nulles et signale par des avertissements les risques d'erreur (chapitres 3 et 4).

Le fichier de 2008 décrivait chaque fichier source du projet, les références aux bibliothèques et les configurations Debug / Release sur une centaine de lignes. Le fichier de projet actuel ne contient que ce qui diffère des valeurs par défaut : tous les fichiers [.cs] du dossier font partie du projet.

Nous remplaçons le contenu du fichier [Program.cs] généré par le suivant :

1
2
// le programme principal du projet [PremierProgramme]
Console.WriteLine("1er essai avec un projet C# 14 / .NET 10");

2.4.2. Compilation et exécution

La commande [dotnet build], tapée dans le dossier du projet, compile le projet :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
> dotnet build
  Identification des projets à restaurer...
  Tous les projets sont à jour pour la restauration.
  PremierProgramme -> csharp-oct-2026/02-installation/PremierProgramme/bin/Debug/net10.0/PremierProgramme.dll

La génération a réussi.
    0 Avertissement(s)
    0 Erreur(s)

Temps écoulé 00:00:01.56
  • ligne 2 : la commande commence par restaurer le projet, c'est-à-dire télécharger les paquets NuGet dont il dépend (il n'y en a pas ici) ;
  • ligne 4 : le résultat de la compilation est une DLL [PremierProgramme.dll] placée dans le dossier [bin/Debug/net10.0] du projet. Sous Windows, le chemin affiché est un chemin Windows ([bin\Debug\net10.0\PremierProgramme.dll]).

Le dossier [bin/Debug/net10.0] contient alors les fichiers suivants :

1
2
3
4
5
6
> dir bin\Debug\net10.0 (liste des fichiers)
PremierProgramme
PremierProgramme.deps.json
PremierProgramme.dll
PremierProgramme.pdb
PremierProgramme.runtimeconfig.json
  • [PremierProgramme.dll] contient le code compilé (en code intermédiaire IL) ;
  • [PremierProgramme] (sous Windows [PremierProgramme.exe]) est un petit lanceur qui démarre la plateforme .NET et lui fait exécuter la DLL ;
  • [PremierProgramme.pdb] contient les informations utilisées par le débogueur ;
  • les deux fichiers [.json] décrivent les dépendances du programme et la version de .NET nécessaire pour l'exécuter.

On peut exécuter le lanceur directement :

1
2
> PremierProgramme
1er essai avec un projet C# 14 / .NET 10

Mais on utilise le plus souvent la commande [dotnet run], qui compile le projet si nécessaire puis l'exécute :

1
2
> dotnet run
1er essai avec un projet C# 14 / .NET 10

Comme en 2008, il existe deux configurations de compilation : Debug (par défaut, avec les informations de débogage) et Release (optimisée, pour la mise en production), choisie par l'option [-c Release] : [dotnet build -c Release] produit le programme dans le dossier [bin/Release/net10.0]. Le dossier [obj] contient des fichiers intermédiaires de la compilation. Les dossiers [bin] et [obj] peuvent être supprimés sans risque : ils sont recréés par la compilation suivante.

2.5. Une solution de plusieurs projets

2.5.1. Création de la solution

Une solution regroupe plusieurs projets. Elle permet de les ouvrir ensemble dans l'éditeur et de les compiler ensemble. Créons une solution dans le dossier qui contient le projet [PremierProgramme] :

1
2
> dotnet new sln -n 02-installation
Le modèle « Fichier solution » a bien été créé.

puis ajoutons-lui le projet :

1
2
> dotnet sln add PremierProgramme
Projet 'PremierProgramme/PremierProgramme.csproj' ajouté à la solution.

Ajoutons un second projet [DeuxMains], dont nous verrons le contenu ci-dessous :

1
2
> dotnet sln add DeuxMains
Projet 'DeuxMains/DeuxMains.csproj' ajouté à la solution.

La commande [dotnet sln list] liste les projets de la solution :

1
2
3
4
5
> dotnet sln list
Projet(s)
---------
DeuxMains/DeuxMains.csproj
PremierProgramme/PremierProgramme.csproj

Le fichier de solution [02-installation.slnx] est le suivant :

1
2
3
4
<Solution>
  <Project Path="DeuxMains/DeuxMains.csproj" />
  <Project Path="PremierProgramme/PremierProgramme.csproj" />
</Solution>

C'est un fichier XML très simple. Depuis .NET 10, c'est le format par défaut des solutions ([.slnx]). L'ancien format [.sln], celui de Visual Studio 2008, était beaucoup plus verbeux ; on le rencontre encore dans les projets existants, et la commande [dotnet new sln --format sln] permet toujours de le créer.

Dans le dossier de la solution, la commande [dotnet build] compile tous les projets de la solution. Pour exécuter un projet particulier, on se place dans son dossier avant de taper [dotnet run], ou on utilise l'option [--project] : [dotnet run --project PremierProgramme].

2.5.2. Un projet avec plusieurs méthodes Main

Le cours de 2008 montrait qu'un projet peut contenir plusieurs classes ayant chacune une méthode statique [Main], et qu'il faut alors désigner celle qui sera exécutée. C'est toujours possible. Le projet [DeuxMains] contient deux classes. La classe [P1] :

1
2
3
4
5
6
7
8
9
namespace DeuxMains;

class P1
{
    static void Main(string[] args)
    {
        Console.WriteLine("Main de la classe P1");
    }
}

et la classe [P2] :

1
2
3
4
5
6
7
8
9
namespace DeuxMains;

class P2
{
    static void Main(string[] args)
    {
        Console.WriteLine("Main de la classe P2");
    }
}

Si on compile le projet sans autre précaution, on obtient une erreur :

1
2
> dotnet build
...\DeuxMains\P1.cs(5,17): error CS0017: Plusieurs points d'entrée sont définis dans le programme. Compilez avec l'option /main pour spécifier le type qui contient le point d'entrée.

Le compilateur ne sait pas quelle méthode [Main] est le point d'entrée du programme. On le lui indique dans le fichier de projet, par la propriété [StartupObject] :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <!-- la classe dont la méthode Main est exécutée -->
    <StartupObject>DeuxMains.P2</StartupObject>
  </PropertyGroup>

</Project>
  • ligne 9 : la méthode [Main] exécutée est celle de la classe [DeuxMains.P2] (le nom complet de la classe, espace de noms compris).

Résultats :

1
2
> dotnet run
Main de la classe P2

Avec les instructions de haut niveau (chapitre 3), la question ne se pose plus : un seul fichier d'un projet peut en contenir, et c'est lui le point d'entrée.

2.6. Les exemples du document

Pour exécuter les exemples du document :

  • on récupère le dossier [csharp-oct-2026] (lien en début de document) ;
  • on l'ouvre dans VS Code (« File / Open Folder ») ou, pour un chapitre donné, on ouvre la solution [.slnx] du chapitre dans Visual Studio ;
  • dans un terminal placé dans le dossier d'un chapitre, on exécute une application fichier unique par [dotnet run nom.cs], ou un projet par [dotnet run] dans le dossier du projet.

Les chapitres 10 et 11 utilisent une base de données MySQL ; l'installation de MySQL avec [Laragon] est décrite en annexe.

https://stahe.github.io
Ce cours, rédigé par l’IA d’Anthropic Claude à la demande de Serge Tahé, est mis à la disposition du public selon les termes de la licence Creative Commons Attribution – Pas d’utilisation commerciale – ShareAlike 3.0 Unported.