# C# et VB.NET dans Visual Studio Code : installer, configurer et créer vos applications .NET

> Développez en C# avec Visual Studio Code : SDK .NET, C# Dev Kit, application console, références de projets, débogage, snippets et projet VB.NET.

- URL : https://guides-numeriques.fr/developpement/vs-code-csharp-vbnet/
- Thématique : Développement web & mobile
- Mis à jour : 2026-09-26
- Formation associée : [Maîtriser VS Code, C# et VB.NET : Le cours développeur](https://espritacademique.com/formations/maitriser-vs-code-c-et-vb-net-le-cours-developpeur/)

## L'essentiel

- Pour coder en C# avec Visual Studio Code, il faut installer le SDK .NET, puis l'extension C# Dev Kit de Microsoft, qui ajoute l'explorateur de solution, IntelliSense et le débogueur.
- Les projets .NET se créent et se compilent avec l'interface en ligne de commande dotnet : dotnet new console, dotnet build et dotnet run.
- VS Code est un éditeur léger et multiplateforme ; Visual Studio est un environnement de développement complet, plus lourd, principalement orienté Windows.
- Un projet VB.NET se crée avec la même commande en ajoutant l'option -lang VB, mais l'outillage de VS Code est plus complet pour C# que pour VB.NET.
- Le débogueur de VS Code permet de poser des points d'arrêt, d'exécuter le code pas à pas et d'inspecter la valeur des variables.

Coder en **C# avec Visual Studio Code** est aujourd'hui une solution légère, gratuite et multiplateforme pour développer des applications .NET : il suffit d'installer le SDK .NET et l'extension C# Dev Kit pour obtenir l'autocomplétion, la compilation et le débogage dans un éditeur rapide, sur Windows, macOS ou Linux. La même installation permet aussi de travailler en VB.NET.

Ce guide s'adresse aux débutants en .NET comme aux développeurs habitués à Visual Studio qui veulent un environnement plus léger. Vous y verrez comment installer et configurer VS Code, créer une application console C#, organiser une solution avec plusieurs projets, compiler et déboguer, gagner du temps avec IntelliSense et les snippets, puis réaliser un petit projet en VB.NET.

## VS Code et C# : de quoi parle-t-on ?

Visual Studio Code est un éditeur de code gratuit et open source publié par Microsoft. Il ne comprend pas le C# par lui-même : ce sont le **SDK .NET**, qui fournit le compilateur et l'outil en ligne de commande `dotnet`, et l'extension **C# Dev Kit**, qui ajoute l'analyse du code, l'explorateur de solution et le débogueur, qui en font un environnement de développement .NET complet.

**.NET** est la plateforme de développement de Microsoft : un environnement d'exécution, une vaste bibliothèque de classes et plusieurs langages, principalement **C#**, **F#** et **VB.NET**. Depuis que .NET est devenu multiplateforme, une application console ou une API écrite en C# s'exécute aussi bien sous Windows que sous Linux ou macOS.

## VS Code ou Visual Studio : lequel choisir ?

Les deux outils portent presque le même nom, mais ne jouent pas dans la même catégorie.

| Critère | Visual Studio Code | Visual Studio |
|---|---|---|
| Nature | Éditeur de code extensible | Environnement de développement intégré (IDE) complet |
| Systèmes | Windows, macOS, Linux | Principalement Windows |
| Poids et rapidité | Léger, démarre en quelques secondes | Installation lourde, plus complet |
| Langages | Tous, via extensions | Centré sur .NET et C++ |
| Concepteurs visuels (Windows Forms, WPF) | Non | Oui |
| Création de projets | Commandes `dotnet` ou palette de commandes | Assistants graphiques |
| Coût | Gratuit | Édition Community gratuite sous conditions, éditions payantes |

Notre conseil : VS Code est idéal pour apprendre C#, écrire des applications console, des bibliothèques et des API web, surtout si vous travaillez aussi avec d'autres langages. Visual Studio reste préférable pour les applications de bureau Windows avec concepteur graphique et les solutions d'entreprise très volumineuses.


**Schéma — VS Code ou Visual Studio : lequel choisir pour C# ?**

| Visual Studio Code | Visual Studio |
|---|---|
| Éditeur léger et extensible | IDE complet, installation lourde |
| Windows, macOS et Linux | Principalement Windows |
| Projets créés avec les commandes dotnet | Concepteurs Windows Forms et WPF |
| Gratuit | Community gratuite sous conditions |


## Pourquoi développer en C# avec Visual Studio Code ?

- **Un seul éditeur pour tout** : C#, JavaScript, Python, SQL, Markdown, sans changer d'outil.
- **Multiplateforme** : le même environnement sur un PC Windows, un Mac ou une machine Linux.
- **Léger** : il fonctionne confortablement sur un ordinateur modeste.
- **Maîtrise de la chaîne** : en utilisant les commandes `dotnet`, vous comprenez ce que fait réellement la compilation, ce qui aide pour l'intégration continue et le déploiement.
- **Écosystème d'extensions** : Git intégré, conteneurs, tests, formateurs, assistants de code par IA.

## Configurer VS Code pour C# et .NET : les étapes


**Schéma — Configurer VS Code pour C# et .NET : les étapes clés**

1. **Installer VS Code** : Options « Ouvrir avec Code » et ajout au PATH
2. **Installer le SDK .NET** : Version LTS, vérifiée avec dotnet --version
3. **Ajouter C# Dev Kit** : Extension Microsoft, panneau Ctrl+Maj+X
4. **Régler les paramètres** : Auto Save, Format On Save, settings.json
5. **Créer une console** : dotnet new console -n Boutique
6. **Compiler et déboguer** : dotnet build, dotnet run, F5


### Étape 1 — Installer Visual Studio Code

Téléchargez VS Code depuis son site officiel et installez-le. Sous Windows, cochez les options **Ajouter l'action « Ouvrir avec Code »** au menu contextuel et **Ajouter à PATH** : vous pourrez ensuite ouvrir un dossier d'un clic droit ou en tapant `code .` dans un terminal.

Au premier lancement, prenez le temps de repérer les zones de l'interface : la **barre d'activité** à gauche (Explorateur, Recherche, Contrôle de code source, Exécuter et déboguer, Extensions), la **barre latérale**, l'**éditeur**, le **panneau** du bas (terminal, problèmes, sortie) et la **barre d'état**. La **palette de commandes**, ouverte avec **Ctrl+Maj+P**, donne accès à toutes les fonctions par leur nom.

### Étape 2 — Installer le SDK .NET

Téléchargez le **SDK .NET** (et non le seul runtime) sur le site officiel de Microsoft, en choisissant de préférence la version LTS. Vérifiez l'installation dans un terminal :

```bash
dotnet --version
dotnet --list-sdks
```

Si la commande n'est pas reconnue, fermez puis rouvrez le terminal (et VS Code) pour qu'il prenne en compte la nouvelle variable PATH.

### Étape 3 — Installer l'extension C# Dev Kit

Ouvrez le panneau Extensions (**Ctrl+Maj+X**), recherchez **C# Dev Kit** et installez l'extension publiée par Microsoft. Elle installe automatiquement l'extension **C#**, qui fournit le service de langage et le débogueur, ainsi que l'outil d'installation du runtime .NET.

C# Dev Kit ajoute notamment :

- un **explorateur de solution**, qui affiche les projets et leurs dépendances comme dans Visual Studio ;
- la création de projets depuis la palette de commandes (**.NET: New Project**) ;
- l'exécution et le débogage en un clic ;
- l'exploration et le lancement des tests unitaires.

### Étape 4 — Personnaliser les paramètres de VS Code

Ouvrez les paramètres avec **Ctrl+,**. Quelques réglages rendent le travail plus confortable :

- **Files: Auto Save** sur `afterDelay`, pour ne plus perdre de modifications ;
- **Editor: Format On Save** activé, pour formater le code à chaque enregistrement ;
- **Editor: Font Size** et le thème de couleur, selon votre confort visuel ;
- **Editor: Render Whitespace** sur `boundary`, pour repérer les espaces parasites.

Ces paramètres sont stockés dans un fichier `settings.json`, accessible via l'icône en haut à droite de l'écran des paramètres. Placés dans un dossier `.vscode` à la racine d'un projet, ils ne s'appliquent qu'à ce projet et peuvent être partagés avec l'équipe.

### Étape 5 — Créer une application console C#

Dans un terminal (menu **Terminal > Nouveau terminal**) :

```bash
dotnet new console -n Boutique
cd Boutique
code .
```

Le modèle crée un fichier `Boutique.csproj`, qui décrit le projet, et un fichier `Program.cs`. Les versions récentes utilisent les **instructions de niveau supérieur** : pas besoin de classe ni de méthode `Main`, le code s'écrit directement.

```csharp
Console.OutputEncoding = System.Text.Encoding.UTF8;

Console.Write("Votre prénom : ");
string? prenom = Console.ReadLine();

Console.WriteLine($"Bonjour {prenom}, bienvenue dans votre première application console C# !");
```

Lancez le programme avec `dotnet run`, ou avec **F5** depuis VS Code. Le dossier `bin` contient le résultat de la compilation, et le dossier `obj` des fichiers intermédiaires : ni l'un ni l'autre ne se modifie à la main.

### Étape 6 — Structurer une solution avec plusieurs projets

Dès qu'un programme grandit, on sépare la logique métier dans une **bibliothèque de classes**, référencée par l'application. Depuis le dossier parent :

```bash
dotnet new sln -n Magasin
dotnet new classlib -n Catalogue
dotnet sln add Boutique/Boutique.csproj Catalogue/Catalogue.csproj
dotnet add Boutique/Boutique.csproj reference Catalogue/Catalogue.csproj
```

Dans le projet `Catalogue`, remplacez le fichier `Class1.cs` par `Produit.cs` :

```csharp
namespace Catalogue;

public record Produit(string Nom, decimal Prix);

public static class Tarifs
{
    public static decimal AppliquerRemise(decimal prix, decimal taux)
    {
        if (taux < 0 || taux > 1)
            throw new ArgumentOutOfRangeException(nameof(taux), "Le taux doit être compris entre 0 et 1.");
        return prix * (1 - taux);
    }
}
```

Puis utilisez-le dans `Program.cs` :

```csharp
using Catalogue;

Console.OutputEncoding = System.Text.Encoding.UTF8;

var produits = new List<Produit>
{
    new("Clavier", 49.90m),
    new("Souris", 19.90m),
};

foreach (var p in produits)
{
    decimal prixRemise = Tarifs.AppliquerRemise(p.Prix, 0.10m);
    Console.WriteLine($"{p.Nom} : {prixRemise:F2} €");
}
```

L'explorateur de solution de C# Dev Kit affiche désormais les deux projets et la référence qui les relie. Pour les montants, utilisez toujours le type **decimal** (suffixe `m`) plutôt que `double`, afin d'éviter les erreurs d'arrondi.

### Étape 7 — Compiler, exécuter et déboguer

Les trois commandes de base de la ligne de commande .NET :

| Commande | Rôle |
|---|---|
| `dotnet build` | Compile la solution et signale les erreurs |
| `dotnet run --project Boutique` | Compile puis exécute le projet indiqué |
| `dotnet clean` | Supprime les fichiers compilés |

Pour déboguer, cliquez dans la marge à gauche d'une ligne (ou appuyez sur **F9**) pour poser un **point d'arrêt**, puis lancez avec **F5**. L'exécution s'interrompt sur la ligne, et la vue **Exécuter et déboguer** affiche les variables locales, la pile d'appels et les expressions surveillées.

Les raccourcis à connaître : **F10** exécute la ligne suivante sans entrer dans les fonctions, **F11** entre dans la fonction appelée, **Maj+F11** en ressort, **F5** reprend jusqu'au prochain point d'arrêt. Un clic droit sur un point d'arrêt permet d'y ajouter une **condition**, par exemple `p.Prix > 30`, pour ne s'arrêter que dans les cas qui vous intéressent.

Pour sécuriser la logique métier, ajoutez enfin un projet de **tests unitaires** à la solution :

```bash
dotnet new xunit -n Catalogue.Tests
dotnet sln add Catalogue.Tests/Catalogue.Tests.csproj
dotnet add Catalogue.Tests/Catalogue.Tests.csproj reference Catalogue/Catalogue.csproj
dotnet test
```

Chaque méthode marquée de l'attribut `[Fact]` vérifie un comportement précis, par exemple qu'une remise de 10 % sur 100 donne bien 90. Avec C# Dev Kit, la vue **Test** de VS Code liste ces tests, les exécute d'un clic et affiche en vert ou en rouge ceux qui passent ou échouent. Relancez-les après chaque modification : vous saurez immédiatement si vous avez cassé quelque chose.

> **Formation recommandée** : [Maîtriser VS Code, C# et VB.NET : Le cours développeur](https://espritacademique.com/formations/maitriser-vs-code-c-et-vb-net-le-cours-developpeur/) — 2h15 de vidéo, 44 €.

## Gagner du temps : IntelliSense, snippets et extensions

### IntelliSense

**IntelliSense** propose l'autocomplétion des types, méthodes et paramètres pendant la saisie. Quelques gestes à adopter :

- **Ctrl+Espace** relance les suggestions à tout moment ;
- **Ctrl+.** ouvre les actions rapides : ajouter un `using` manquant, générer un constructeur, implémenter une interface, extraire une méthode ;
- **F12** va à la définition d'un symbole, **Maj+F12** liste toutes ses références ;
- **F2** renomme un symbole partout dans la solution.

### Snippets de code

Les **snippets** insèrent un bloc de code à partir d'un mot court suivi de Tab. L'extension C# en fournit plusieurs, comme `prop` pour une propriété ou `ctor` pour un constructeur. Vous pouvez créer les vôtres avec **Fichier > Préférences > Configurer les extraits de code**, puis en choisissant `csharp` :

```json
{
  "Méthode de test": {
    "prefix": "testm",
    "body": [
      "[Fact]",
      "public void ${1:NomDuTest}()",
      "{",
      "    // Arrange",
      "    $0",
      "}"
    ],
    "description": "Squelette de méthode de test xUnit"
  }
}
```

`${1:NomDuTest}` est un emplacement que la touche Tab permet de remplir, `$0` la position finale du curseur.

### Extensions utiles

En plus de C# Dev Kit, quelques extensions rendent service au quotidien : **EditorConfig** pour partager les règles de mise en forme, **GitLens** pour l'historique Git ligne par ligne, **Error Lens** pour afficher les erreurs directement dans le code, et une extension de conteneurs si vous travaillez avec Docker. Installez-les au fur et à mesure des besoins : trop d'extensions ralentissent l'éditeur.

L'éditeur intègre aussi Git nativement ; si vous débutez avec le versionnage, notre guide pour [apprendre Git et GitHub](https://guides-numeriques.fr/developpement/git-github/) vous donnera les bons réflexes. Côté assistance par IA, des éditeurs dérivés de VS Code comme [Cursor](https://guides-numeriques.fr/ia/cursor-ia/) ou des agents en ligne de commande comme [Claude Code](https://guides-numeriques.fr/ia/claude-code-mcp/) s'utilisent avec le même SDK .NET.

## Développer en VB.NET avec VS Code : un projet guidé

VB.NET reste présent dans de nombreuses applications d'entreprise. Le SDK .NET permet de créer un projet console en VB.NET avec l'option `-lang` :

```bash
dotnet new console -lang VB -n GestionStock
cd GestionStock
dotnet run
```

Notez que l'outillage de VS Code est nettement plus riche pour C# que pour VB.NET : coloration, compilation et exécution fonctionnent, mais l'assistance à la saisie est plus limitée. Pour un projet VB.NET d'envergure, Visual Studio reste plus confortable.

Voici un petit programme qui modélise des produits, calcule une remise et affiche le résultat :

```vb
Public Class Produit
    Public Property Nom As String
    Public Property Prix As Decimal

    Public Sub New(nom As String, prix As Decimal)
        Me.Nom = nom
        Me.Prix = prix
    End Sub
End Class

Module Program
    Function CalculerRemise(prix As Decimal, taux As Decimal) As Decimal
        If taux < 0D OrElse taux > 1D Then
            Throw New ArgumentOutOfRangeException(NameOf(taux))
        End If
        Return prix * (1D - taux)
    End Function

    Sub Main()
        Dim produits As New List(Of Produit) From {
            New Produit("Clavier", 49.9D),
            New Produit("Souris", 19.9D)
        }

        For Each p In produits
            Dim prixRemise = CalculerRemise(p.Prix, 0.1D)
            Console.WriteLine($"{p.Nom} : {prixRemise:F2} EUR")
        Next
    End Sub
End Module
```

Posez un point d'arrêt sur la ligne `Return` de la fonction, lancez le débogage et observez les valeurs de `prix` et `taux` à chaque passage. C'est le meilleur moyen de vérifier une logique métier.

## Les erreurs fréquentes en C# sous VS Code

| Erreur ou symptôme | Cause | Solution |
|---|---|---|
| `dotnet` n'est pas reconnu | SDK absent ou terminal ouvert avant l'installation | Installer le SDK, redémarrer le terminal et VS Code |
| Aucune autocomplétion | Extension non chargée ou dossier ouvert au mauvais niveau | Ouvrir le dossier qui contient le `.csproj` ou le `.sln`, vérifier la sortie de l'extension C# |
| « The type or namespace name could not be found » | Référence de projet ou `using` manquant | `dotnet add reference`, puis Ctrl+. pour ajouter le `using` |
| Accents ou symbole euro mal affichés dans la console | Encodage de la console Windows | `Console.OutputEncoding = System.Text.Encoding.UTF8;` |
| Le point d'arrêt reste grisé | Programme lancé sans débogueur ou code non compilé | Lancer avec F5, relancer `dotnet build` |
| Plusieurs projets proposés au lancement | Solution à plusieurs projets exécutables | Choisir le projet de démarrage, ou préciser `--project` |
| Warnings sur les valeurs nulles (`string?`) | Types de référence nullables activés par défaut | Tester la valeur avant usage ou fournir une valeur par défaut |

## Comment progresser en C# avec Visual Studio Code ?

Voici un parcours réaliste pour devenir autonome :

1. **Premier jour** : installation de VS Code, du SDK .NET et de C# Dev Kit, visite de l'interface, réglages de base.
2. **Première semaine** : applications console, variables, conditions, boucles, collections, méthodes. Un petit programme par jour.
3. **Deuxième semaine** : classes, propriétés, records, solution à plusieurs projets, débogage pas à pas.
4. **Troisième semaine** : un projet complet (gestion de stock, carnet d'adresses), avec tests unitaires et versionnage Git.
5. **Ensuite** : une spécialisation, par exemple une API web avec ASP.NET Core ou un jeu avec un moteur qui utilise C#.

Si vous pratiquez déjà un autre langage dans VS Code, comme [JavaScript](https://guides-numeriques.fr/developpement/apprendre-javascript/), vous retrouverez les mêmes réflexes d'éditeur : seul le langage change.

Pour être accompagné pas à pas, [la formation vidéo pour développer en C# et VB.NET dans VS Code](https://espritacademique.com/formations/maitriser-vs-code-c-et-vb-net-le-cours-developpeur/) d'EspritAcadémique dure 2 h 15 et ne demande aucun prérequis. Elle couvre notamment :

- les différences entre VS Code et Visual Studio, l'installation de l'éditeur et du SDK .NET ;
- la découverte de l'interface et la personnalisation des paramètres ;
- la création d'un premier projet .NET, la gestion des fichiers et les références entre projets C# ;
- la compilation, l'exécution et le débogage ;
- l'extension C# Dev Kit, IntelliSense, les extensions utiles et les snippets ;
- un projet VB.NET complet : classe Produit, liste, fonction de remise et débogage.

## En résumé

Pour coder en C# avec Visual Studio Code, installez le SDK .NET et l'extension C# Dev Kit, créez vos projets avec `dotnet new`, organisez-les en solution avec des références, puis compilez et déboguez avec F5 et les points d'arrêt. IntelliSense, les actions rapides et les snippets accélèrent l'écriture. VB.NET fonctionne avec le même SDK, avec un outillage plus limité dans VS Code.

## Sources et documentation officielle

- [Working with C# (documentation Visual Studio Code)](https://code.visualstudio.com/docs/languages/csharp)
- [Getting Started with C# in VS Code (documentation Visual Studio Code)](https://code.visualstudio.com/docs/csharp/get-started)
- [Guide C# (Microsoft Learn)](https://learn.microsoft.com/fr-fr/dotnet/csharp/)
- [Documentation Visual Basic (Microsoft Learn)](https://learn.microsoft.com/fr-fr/dotnet/visual-basic/)

## Questions fréquentes

### Peut-on développer en C# gratuitement avec VS Code ?

Oui. Visual Studio Code et le SDK .NET sont gratuits et disponibles sur Windows, macOS et Linux. L'extension C# est open source. L'extension C# Dev Kit est soumise à des conditions de licence propres à Microsoft, gratuites pour de nombreux usages individuels : consultez la page de l'extension pour vérifier les conditions applicables à votre organisation.

### VS Code peut-il remplacer Visual Studio pour le C# ?

Pour les applications console, les bibliothèques, les API web ASP.NET Core et de nombreux projets multiplateformes, oui. En revanche, Visual Studio reste plus adapté aux concepteurs visuels (Windows Forms, WPF), au profilage avancé et aux très grosses solutions d'entreprise. Beaucoup de développeurs utilisent d'ailleurs les deux selon le projet.

### Quelle est la différence entre C# et VB.NET ?

Les deux langages s'exécutent sur la même plateforme .NET et partagent les mêmes bibliothèques. Leur différence est surtout syntaxique : C# utilise des accolades et des points-virgules, dans la famille du C et de Java, tandis que VB.NET privilégie des mots-clés en anglais comme Sub, End If ou Dim. C# concentre aujourd'hui l'essentiel des nouveautés du langage.

### Faut-il installer .NET Framework ou .NET pour coder dans VS Code ?

Installez le SDK .NET moderne, multiplateforme, disponible sur le site officiel de Microsoft. Le .NET Framework historique ne fonctionne que sous Windows et reste réservé à la maintenance d'applications anciennes. Pour apprendre, choisissez la dernière version avec support à long terme (LTS) proposée sur la page de téléchargement.

### Comment lancer un programme C# dans VS Code ?

Ouvrez le dossier du projet, puis appuyez sur F5 pour lancer avec le débogueur, ou sur Ctrl+F5 pour exécuter sans débogage. Vous pouvez aussi ouvrir le terminal intégré avec Ctrl+ù sur un clavier AZERTY et taper dotnet run. La première exécution restaure les dépendances et compile le projet automatiquement.