Installer .NET 9 et créer son premier programme C# pas à pas

📌 Article principal de la série : C# et .NET : développement d’applications modernes pour développeurs
Ce tutoriel fait partie de la série C# et .NET. Pour la vue d’ensemble du langage et de l’écosystème, consultez l’article principal.

Avant d’écrire la moindre ligne de C#, il faut disposer du SDK .NET correctement installé et d’un environnement de développement opérationnel. Ce tutoriel couvre l’installation du SDK .NET 9 sur Linux (Ubuntu/Debian), macOS et Windows, la création et l’exécution d’un premier programme en ligne de commande, la compréhension de la structure d’un projet C#, et la configuration de VS Code avec l’extension C# Dev Kit — le tout vérifié étape par étape. À la fin, vous aurez un environnement de développement C# professionnel fonctionnel et vous connaîtrez les commandes dotnet essentielles du quotidien.

Prérequis

• Un ordinateur sous Linux (Ubuntu 22.04+ / Debian 12), macOS 13+ ou Windows 10/11
• Accès administrateur ou sudo
• Connexion Internet
• Niveau : débutant — aucune expérience C# ou .NET requise
• Temps estimé : 30 à 45 minutes

Étape 1 — Installer le SDK .NET 9 sous Linux (Ubuntu/Debian)

Microsoft propose des dépôts APT officiels pour les distributions Debian et Ubuntu, ce qui permet d’installer et de mettre à jour .NET via le gestionnaire de paquets système. C’est la méthode recommandée sur ces distributions car elle intègre .NET dans le cycle de mise à jour habituel du système.

# Note : depuis Ubuntu 24.04, Canonical empaquette dotnet-sdk-9.0 directement,
# vous pouvez sauter le dépôt Microsoft et faire simplement « sudo apt install dotnet-sdk-9.0 »
# Ajouter le dépôt Microsoft pour Ubuntu 22.04 / 24.04
wget https://packages.microsoft.com/config/ubuntu/$(lsb_release -rs)/packages-microsoft-prod.deb \
  -O packages-microsoft-prod.deb
sudo dpkg -i packages-microsoft-prod.deb
rm packages-microsoft-prod.deb

# Mettre à jour l'index des paquets et installer le SDK .NET 9
sudo apt update
sudo apt install -y dotnet-sdk-9.0

# Vérifier l'installation
dotnet --version
dotnet --list-sdks

La commande wget télécharge le paquet de configuration du dépôt Microsoft pour la version Ubuntu détectée automatiquement par lsb_release -rs. dpkg -i installe ce paquet de configuration qui ajoute le dépôt Microsoft et sa clé GPG. L’installation du SDK (dotnet-sdk-9.0) inclut tout ce dont vous avez besoin : le SDK (compilateur Roslyn, MSBuild, NuGet), le runtime ASP.NET Core et le runtime .NET de base. La commande dotnet --version doit afficher 9.0.x. La commande dotnet --list-sdks liste toutes les versions installées — utile si plusieurs versions coexistent.

# Résultat attendu de dotnet --version
9.0.100

# Résultat attendu de dotnet --list-sdks
9.0.100 [/usr/lib/dotnet/sdk]

Si dotnet: command not found s’affiche après l’installation, fermez et rouvrez le terminal pour recharger le PATH, ou exécutez source ~/.bashrc (bash) / source ~/.zshrc (zsh) selon votre shell.

Étape 2 — Installer le SDK .NET 9 sous macOS

Sur macOS, l’installateur PKG officiel de Microsoft est la méthode la plus simple. Téléchargez le SDK .NET 9 depuis la page officielle dotnet.microsoft.com/download/dotnet/9.0 — sélectionnez « macOS » et l’architecture correcte (Arm64 pour les Mac Apple Silicon M1/M2/M3/M4, x64 pour les Mac Intel).

# Après l'installation du PKG, vérifier dans un nouveau terminal
dotnet --version

# Alternative via Homebrew (si Homebrew est déjà installé)
brew install dotnet@9
echo 'export PATH="/opt/homebrew/opt/dotnet@9/bin:$PATH"' >> ~/.zshrc
source ~/.zshrc
dotnet --version

L’installateur PKG place le SDK dans /usr/local/share/dotnet/ et configure automatiquement le PATH. La vérification doit afficher 9.0.x. Si vous utilisez Homebrew, la formule dotnet@9 installe la version spécifique 9 — l’ajout au PATH est manuel via le echo puis le source pour recharger le profil. Sur les Mac Apple Silicon, vérifiez que vous avez téléchargé la version Arm64 — utiliser la version x64 via Rosetta fonctionne mais est moins performant.

Étape 3 — Installer le SDK .NET 9 sous Windows

Sur Windows, l’installateur officiel est disponible sur la même page dotnet.microsoft.com/download/dotnet/9.0. Téléchargez le « SDK x64 Installer » pour Windows 64-bit. L’installation est standard (suivant, suivant, installer) et configure automatiquement les variables d’environnement.

# Après l'installation, ouvrir un nouveau PowerShell et vérifier
dotnet --version
dotnet --list-sdks

# Alternative via winget (PowerShell administrateur)
winget install Microsoft.DotNet.SDK.9

Après l’installation, il est impératif d’ouvrir un nouveau PowerShell (fermer l’ancien et en ouvrir un nouveau) pour que les variables d’environnement soient rechargées. dotnet --version doit afficher 9.0.x. Si la commande n’est pas reconnue, vérifiez que C:\Program Files\dotnet\ est dans la variable d’environnement PATH (Paramètres système → Variables d’environnement avancées → PATH). Via winget, l’installation est non interactive et configure automatiquement le PATH.

Étape 4 — Comprendre la CLI dotnet

La CLI dotnet est l’outil central du développement .NET. Contrairement à l’écosystème Java où Maven et Gradle sont des outils séparés à installer, dotnet est inclus dans le SDK et couvre toutes les opérations du cycle de développement.

# Les commandes dotnet essentielles
dotnet new list                    # Lister les templates disponibles
dotnet new console -n MonProjet    # Créer un projet console
dotnet new webapi -n MonApi        # Créer un projet ASP.NET Core Web API
dotnet run                         # Compiler et exécuter (dans le répertoire du projet)
dotnet build                       # Compiler sans exécuter
dotnet test                        # Exécuter les tests
dotnet publish -c Release          # Publier pour déploiement
dotnet add package Newtonsoft.Json # Ajouter un paquet NuGet
dotnet list package                # Lister les paquets installés
dotnet restore                     # Restaurer les dépendances NuGet

La commande dotnet new list affiche la liste de tous les templates disponibles — il en existe plus de 50 dans un SDK standard : console, webapi, mvc, blazorserver, blazorwasm, classlib, xunit, mstest, etc. dotnet run combine la compilation et l’exécution en une commande — le rechargement automatique est disponible avec dotnet watch run qui surveille les modifications des fichiers source et relance l’application automatiquement, indispensable pendant le développement. dotnet add package modifie directement le fichier .csproj et restaure les dépendances NuGet — pas besoin de modifier XML manuellement.

Étape 5 — Créer et analyser un premier projet console

Le template console est le point d’entrée le plus simple pour apprendre C# : il crée une application avec une méthode Main qui s’exécute en ligne de commande, sans infrastructure web ni UI. C’est aussi le template idéal pour explorer les fonctionnalités du langage.

# Créer le projet dans un nouveau répertoire
dotnet new console -n premiers-pas-csharp
cd premiers-pas-csharp

# Voir les fichiers générés
ls -la   # Linux/macOS
dir      # Windows

La commande génère un projet minimal. Examinez chaque fichier généré pour comprendre la structure :

premiers-pas-csharp/
├── premiers-pas-csharp.csproj    ← Fichier projet MSBuild
├── Program.cs                    ← Point d'entrée (top-level statements C# 9+)
└── obj/                          ← Fichiers générés par MSBuild (ignorés par git)

Ouvrez premiers-pas-csharp.csproj dans votre éditeur. Voici son contenu minimal :

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net9.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
  </PropertyGroup>
</Project>

Ce fichier .csproj en SDK-style est remarquablement concis comparé aux anciens formats MSBuild ou aux pom.xml Maven. Les 4 propriétés clés : OutputType=Exe indique qu’on produit un exécutable (pas une bibliothèque). TargetFramework=net9.0 cible .NET 9. Nullable=enable active les nullable reference types — fortement recommandé pour tout nouveau projet. ImplicitUsings=enable inclut automatiquement les namespaces les plus courants (System, System.IO, System.Linq, etc.) sans avoir à les importer explicitement dans chaque fichier. Ouvrez maintenant Program.cs — il contient une seule ligne :

// Program.cs généré par dotnet new console
Console.WriteLine("Hello, World!");

Cette ligne unique utilise les top-level statements de C# 9, qui éliminent le boilerplate de la méthode Main et de la déclaration de classe. Le compilateur génère automatiquement la classe et la méthode Main — le code reste équivalent à l’ancien static void Main(string[] args) { ... }. Exécutez-le :

dotnet run

Le terminal doit afficher Hello, World!. Si vous voyez cette sortie, votre installation .NET est opérationnelle. La première exécution compile le projet — les suivantes utilisent le cache de compilation (obj/Debug/) et sont instantanées si aucun fichier n’a changé.

Étape 6 — Écrire un programme C# plus élaboré

Remplacez le contenu de Program.cs par ce programme qui illustre les fonctionnalités C# fondamentales : types, collections, LINQ, classes et méthodes :

// Programme de gestion d'une liste de produits — C# 9+ avec top-level statements

var produits = new List<Produit>
{
    new("Laptop ThinkPad",    850_000m, 10),
    new("Souris USB",          15_000m, 50),
    new("Clé USB 64GB",         8_000m, 200),
    new("Casque Bluetooth",    35_000m,  0),
    new("Moniteur 24 pouces", 180_000m,  5),
};

// LINQ : filtrer et trier les produits disponibles
var disponibles = produits
    .Where(p => p.Stock > 0)
    .OrderByDescending(p => p.Prix)
    .ToList();

Console.WriteLine($"Produits disponibles ({disponibles.Count}/{produits.Count}) :");
foreach (var p in disponibles)
{
    Console.WriteLine($"  - {p.Nom,-25} {p.Prix,12:N0} FCFA  (stock: {p.Stock})");
}

// Calcul et affichage du total en stock
decimal valeurStock = produits.Sum(p => p.Prix * p.Stock);
Console.WriteLine($"\nValeur totale du stock : {valeurStock:N0} FCFA");

// Pattern matching
Console.WriteLine("\nClassification des produits :");
foreach (var p in produits)
{
    string categorie = p.Prix switch
    {
        <= 20_000m  => "Accessoire",
        <= 100_000m => "Milieu de gamme",
        _           => "Haut de gamme"
    };
    Console.WriteLine($"  {p.Nom,-25} → {categorie}");
}

// Définition du record Produit (bottom du fichier dans les top-level statements)
record Produit(string Nom, decimal Prix, int Stock);

Ce programme combine plusieurs fonctionnalités C# modernes : la syntaxe d’initialisation de liste (new List<T> { ... }), les records positionnels, le LINQ avec Where/OrderByDescending/Sum, les chaînes interpolées avec formatage (:N0 pour nombres avec séparateurs de milliers, ,-25 pour alignement à gauche), les foreach, et la switch expression pour le pattern matching. Exécutez-le :

dotnet run

La sortie attendue liste les produits disponibles triés par prix décroissant, la valeur totale du stock calculée, puis la classification de chaque produit par gamme. Si vous obtenez des erreurs de compilation, lisez attentivement les messages du compilateur Roslyn — ils sont remarquablement précis et indiquent la ligne, la colonne et la nature de l’erreur. La syntaxe p.Prix,12:N0 dans l’interpolation formate le nombre avec 12 caractères de large et séparateurs de milliers — si l’alignement ne s’affiche pas correctement, c’est souvent dû à une police non monospace dans le terminal.

Étape 7 — Configurer VS Code avec C# Dev Kit

Visual Studio Code avec l’extension C# Dev Kit de Microsoft offre une expérience de développement C# complète : autocomplétion IntelliSense, navigation dans le code, débogueur intégré, et exécution de tests. C’est la solution recommandée pour Linux et macOS, et une alternative légère à Visual Studio sur Windows.

# Ouvrir le projet dans VS Code
code .

Dans VS Code, ouvrez l’onglet Extensions (Ctrl+Shift+X ou Cmd+Shift+X) et installez :

• C# Dev Kit (Microsoft, identifiant ms-dotnettools.csdevkit) — inclut automatiquement l’extension C# de base, IntelliCode pour C# et le serveur de langage OmniSharp/Roslyn

Après l’installation, rouvrez VS Code dans le répertoire du projet. L’extension analyse automatiquement le .csproj et configure l’IntelliSense. Créez maintenant un fichier launch.json pour configurer le débogueur :

# VS Code génère ce fichier automatiquement avec C# Dev Kit :
# appuyez sur F5 (Run and Debug) puis sélectionnez ".NET 5+ and .NET Core"

Pour déboguer : posez un point d’arrêt en cliquant dans la marge gauche à côté d’une ligne de code (un cercle rouge apparaît), puis appuyez sur F5. L’exécution s’arrêtera à ce point d’arrêt, permettant d’inspecter les variables dans le panneau « Variables » et d’avancer pas à pas avec F10 (step over) ou F11 (step into). Pour exécuter sans débogage, utilisez Ctrl+F5.

Étape 8 — Ajouter un paquet NuGet et l’utiliser

Avant de terminer, testons l’ajout d’une dépendance NuGet pour valider que le gestionnaire de paquets fonctionne correctement. Newtonsoft.Json (Json.NET) est l’une des bibliothèques .NET les plus téléchargées de tous les temps — plus de 3 milliards de téléchargements sur NuGet.org.

# Ajouter le paquet NuGet
dotnet add package Newtonsoft.Json

# Vérifier qu'il est dans le .csproj
cat premiers-pas-csharp.csproj

Après cette commande, ouvrez .csproj — vous verrez qu’une ligne <PackageReference Include="Newtonsoft.Json" Version="13.x.x" /> a été ajoutée automatiquement par la CLI dotnet. Mettez à jour Program.cs pour utiliser ce paquet :

using Newtonsoft.Json;

var produit = new { Nom = "Laptop ThinkPad", Prix = 850_000m, Stock = 10 };

// Sérialisation en JSON
string json = JsonConvert.SerializeObject(produit, Formatting.Indented);
Console.WriteLine("Sérialisation JSON :");
Console.WriteLine(json);

// Désérialisation depuis JSON
string jsonSource = """{"Nom":"Souris USB","Prix":15000,"Stock":50}""";
var deserialise = JsonConvert.DeserializeObject<dynamic>(jsonSource);
Console.WriteLine($"\nDésérialisé : {deserialise?.Nom} à {deserialise?.Prix:N0} FCFA");

dotnet run

La sortie doit afficher le produit sérialisé en JSON formaté avec indentation, puis le résultat de la désérialisation. Le raw string literal """...""" (C# 11+) dans jsonSource permet d’inclure du JSON directement dans le code sans échapper les guillemets — une amélioration significative de la lisibilité pour les chaînes multi-lignes contenant des guillemets. Si la commande dotnet run réussit sans erreur et affiche le JSON attendu, votre environnement de développement C# est pleinement opérationnel.

Erreurs fréquentes

Tutoriels frères

• Créer une API REST avec ASP.NET Core pas à pas — Étape suivante naturelle : construire une vraie API web avec ASP.NET Core à partir de l’environnement configuré ici

Pour aller plus loin

• 🔝 Retour à l’article principal : C# et .NET : développement d’applications modernes pour développeurs
• Documentation CLI dotnet — Microsoft Learn
• Tour du langage C# — Microsoft Learn
• NuGet.org — Galerie de paquets .NET

FAQ

Faut-il installer Visual Studio ou VS Code suffit-il ?

VS Code avec C# Dev Kit suffit pour la quasi-totalité des projets .NET : développement web, APIs, console, bibliothèques, tests. Visual Studio 2022 (Community gratuit) offre des fonctionnalités supplémentaires pour le développement Windows-spécifique (WPF, WinUI 3, MAUI sur Windows) et l’intégration Azure DevOps. Sur Linux et macOS, VS Code est le choix naturel car Visual Studio pour Mac a été abandonné en août 2024.

Quelle différence entre dotnet run et dotnet build ?

dotnet build compile le projet et produit les binaires dans bin/Debug/net9.0/ sans l’exécuter. dotnet run compile si nécessaire puis exécute immédiatement. Pour le développement quotidien, dotnet run est plus pratique. Pour la CI/CD, dotnet build --configuration Release puis dotnet publish séparément permettent plus de contrôle. dotnet watch run combine compilation, exécution et rechargement automatique à chaque modification.

Peut-on cibler plusieurs frameworks dans un même projet ?

Oui, avec le multi-targeting : dans le .csproj, remplacez <TargetFramework> par <TargetFrameworks>net8.0;net9.0</TargetFrameworks>. Le projet sera compilé pour les deux cibles et produira deux sets de binaires. C’est la technique utilisée par les auteurs de bibliothèques NuGet pour supporter plusieurs versions de .NET dans un seul paquet.