Windows Forms en C# : c'est quoi, et créer ton premier projet

Windows Forms, ou WinForms, est la bibliothèque de .NET qui permet de construire en C# des applications de bureau pour Windows : des fenêtres que l'on dessine à la souris dans Visual Studio, puis dont on programme les réactions. Ce chapitre situe WinForms parmi les autres façons de faire une application, explique quelle version de .NET viser en 2026, présente le projet fil rouge et te fait créer la solution qui servira dans tout le cours.

Client lourd, client léger : où s'exécute ton code ?

Une application WinForms s'installe sur le poste de l'utilisateur et s'y exécute : on parle de client lourd (ou application de bureau, desktop). Une application web, au contraire, s'exécute dans un navigateur qui charge ses pages depuis un serveur : c'est un client léger, il n'y a rien à installer.

Les clients lourds restent très présents en entreprise : logiciels de caisse, gestion de production, logiciels métier des cabinets médicaux, outils internes du service informatique. Ce sont des applications utilisées toute la journée par les mêmes personnes, sur des postes Windows maîtrisés, souvent reliées à du matériel.

Une application de bureau peut parler à sa base de données de deux façons. Soit elle s'y connecte directement (le cas le plus fréquent dans les projets de BTS, et celui des chapitres 9 et 10), soit elle passe par une API hébergée sur un serveur, qui seule accède à la base (chapitre 11). La seconde architecture est plus sûre, tu verras pourquoi au chapitre 12.

Au BTS SIO, le référentiel décrit l'environnement technologique dans lequel tes réalisations d'E6 sont construites : elles doivent couvrir au moins trois des quatre situations « poste fixe (client lourd), navigateur, terminal mobile, serveur », et comporter des appels à des services applicatifs distants (détail des exigences). Un client lourd C# en est l'exemple le plus classique.

WinForms, WPF, MAUI ou Avalonia ?

Microsoft propose plusieurs bibliothèques d'interface pour .NET. Toutes s'écrivent en C# ; elles diffèrent par la façon de décrire les fenêtres et par les systèmes visés.

WinForms n'est pas une technologie abandonnée : elle fait partie de .NET 10, Microsoft continue de la faire évoluer (mode sombre, fenêtres asynchrones, nouveau presse-papiers en .NET 10), et des milliers d'entreprises l'utilisent. Elle reste la meilleure porte d'entrée pour comprendre la programmation événementielle : ce que tu apprends ici (événements, contrôles, liaison de données, couches) se retrouve presque tel quel en WPF ou en MAUI.

.NET 10 ou .NET Framework 4.8 ?

C'est la première source de confusion. Il existe deux plateformes .NET, qui n'ont pas la même histoire.

• .NET Framework (2002 à 2019) est l'ancienne plateforme, livrée avec Windows. Sa dernière version est la 4.8.1 : elle ne recevra plus de nouvelles fonctionnalités, seulement des correctifs de sécurité, aussi longtemps que la version de Windows qui l'embarque est maintenue.
• .NET (appelé .NET Core jusqu'à la version 3.1, puis simplement .NET 5, 6, 7…) est la plateforme actuelle, libre et multiplateforme. Une nouvelle version sort chaque mois de novembre. WinForms y est disponible depuis 2019.

Les versions paires sont à support long (LTS, trois ans), les impaires à support standard (STS, deux ans). Au 2 novembre 2026, la situation est la suivante :

Pour un nouveau projet, vise .NET 10. C'est la version LTS en cours, celle que propose Visual Studio 2026, et elle sera maintenue pendant toute ta formation. Un projet en .NET 8 doit être migré tout de suite : en général, il suffit de changer net8.0-windows en net10.0-windows dans le fichier projet et de mettre à jour les paquets NuGet.

Tu rencontreras pourtant .NET Framework en stage ou en entreprise. Beaucoup d'applications métier écrites entre 2005 et 2020 tournent encore en .NET Framework 4.7 ou 4.8, parfois en VB.NET. Elles fonctionnent, sont maintenues, mais leur migration vers .NET coûte du temps : les bibliothèques tierces anciennes, les rapports Crystal Reports ou les composants COM ne suivent pas toujours. Savoir reconnaître ces projets fait partie du métier.

Ce que .NET 10 et C# 14 changent dans ton code

Le langage est expliqué dans le cours Programmation orientée objet (les bases de C#). Voici seulement les nouveautés récentes que tu vas croiser dans le code de ce cours, et qui n'existaient pas en .NET Framework.

• Les types référence nullables (C# 8, activés par défaut dans les nouveaux projets). string? signifie « peut être null », string signifie « jamais null ». Le compilateur t'avertit quand tu risques une NullReferenceException. Le prénom d'un patient est facultatif : string? Prenom.
• Les using implicites : System, System.Linq, System.Windows.Forms et quelques autres sont importés d'office, d'où des fichiers plus courts.
• Les espaces de noms de fichier : namespace Gsb.Ui; en haut du fichier remplace les accolades d'un bloc namespace.
• Les enregistrements (record, C# 9) : une classe de données en une ligne, comparée par valeur. Idéal pour une ligne de résultat ou un objet reçu d'une API.
• Les constructeurs principaux (C# 12) : public class PatientService(IPatientRepository depot) déclare le constructeur et son paramètre dans l'en-tête de la classe.
• Les expressions de collection (C# 12) : List<Patient> liste = []; ou int[] notes = [12, 15];.
• Les chaînes brutes (C# 11) : un texte entre """ peut s'étaler sur plusieurs lignes sans échappement, parfait pour une requête SQL.
• Le mot-clé field (C# 14) : dans une propriété, il désigne le champ caché que le compilateur crée. Tu peux ajouter un contrôle à une propriété automatique sans déclarer de champ privé.

public class Patient
{
    public string Nom
    {
        get;
        set => field = string.IsNullOrWhiteSpace(value)
            ? throw new ArgumentException("Le nom est obligatoire.")
            : value.Trim();
    } = "";

    public string? Prenom { get; set; }
}

Le get; reste automatique ; le set vérifie la valeur avant de la ranger dans field. Le = "" initialise le champ : le compilateur sait ainsi que Nom n'est jamais null. Enfin, async et await (C# 5) existent depuis longtemps, mais toute la bibliothèque moderne en dépend : le chapitre 7 leur est consacré.

Le projet fil rouge : GSB Ordonnances

Le cas s'inspire du contexte fictif GSB (Galaxy Swiss Bourdin), bien connu des étudiants de BTS SIO, transposé chez un éditeur de logiciels médicaux : GSB fournit à ses cabinets médicaux clients une application de bureau, GSB Ordonnances. La secrétaire médicale y gère les patients ; le médecin y rédige les ordonnances, chacune composée de plusieurs lignes (un médicament, une posologie, une durée).

Les besoins, tels qu'un client les exprimerait :

1. se connecter avec un identifiant et un mot de passe personnels ;
2. consulter la liste des patients, la filtrer par nom, ajouter, modifier ou supprimer un patient ;
3. créer une ordonnance pour un patient : choisir le médecin, ajouter des médicaments avec posologie et durée ;
4. consulter les ordonnances récentes avec le nom du patient et du médecin ;
5. rechercher un médicament dans le référentiel des médicaments de l'éditeur, exposé par une API web ;
6. exporter la liste des patients pour un courrier.

Les données sont rangées dans une base MySQL, gsb_ordonnances. Le chapitre 9 donne son script complet.

Sous forme de schéma relationnel, comme dans les sujets (la clé primaire, soulignée dans un sujet, est ici en gras ; les clés étrangères sont précédées d'un #) :

medecin (numMedecin, nom, prenom, numeroRpps, specialite)

patient (numPatient, nom, prenom, dateNaissance, numeroSecu)

medicament (codeMedicament, nom, dosage)

ordonnance (numOrdonnance, dateEmission, #numMedecin, #numPatient)

contenir (#numOrdonnance, #codeMedicament, posologie, dureeJours)

utilisateur (numUtilisateur, login, hashMotDePasse, role)

Installer Visual Studio 2026

Visual Studio 2026 (version 18) est l'environnement de développement de Microsoft pour .NET 10. L'édition Community est gratuite pour les étudiants, les particuliers et les petites équipes.

1. Télécharge le programme d'installation sur le site de Visual Studio et lance-le.
2. Dans l'onglet Charges de travail, coche Développement .NET Desktop. Elle installe le SDK .NET, les modèles WinForms et WPF et le concepteur de formulaires.
3. Si tu veux aussi faire du web ASP.NET ou des tests de navigateur plus tard, ajoute Développement web et ASP.NET ; ce n'est pas utile pour ce cours.
4. Clique sur Installer. Compte plusieurs gigaoctets et un bon moment.

Vérifie ensuite le SDK dans un terminal (PowerShell ou l'invite de commandes) :

dotnet --list-sdks

Tu dois voir une ligne qui commence par 10.0.. Si la commande est inconnue, le SDK n'est pas installé ou le terminal a été ouvert avant l'installation : ferme-le et rouvre-le.

Créer la solution pas à pas

Dans Visual Studio, une solution regroupe plusieurs projets. Une application bien construite en contient plusieurs : l'interface, la couche métier, l'accès aux données et les tests (le chapitre 8 explique pourquoi). Pour l'instant, crée la solution et son premier projet, l'interface.

1. Fichier > Nouveau > Projet (ou, à l'accueil, Créer un projet).
2. Dans la recherche, tape Windows Forms, choisis Application Windows Forms en C# (pas la version .NET Framework, pas Visual Basic), puis Suivant.
3. Nom du projet : Gsb.Ui. Nom de la solution : GsbOrdonnances. Décoche « Placer la solution et le projet dans le même répertoire ». Suivant.
4. Framework : .NET 10.0 (prise en charge à long terme). Créer.

Visual Studio ouvre le concepteur (designer) avec une fenêtre vide, Form1. Tu peux déjà lancer l'application avec F5 : une fenêtre grise apparaît. Ferme-la.

La même solution se crée en ligne de commande, ce qui est utile sur un poste sans Visual Studio ou pour un script :

dotnet new sln -n GsbOrdonnances
dotnet new winforms -n Gsb.Ui -o Gsb.Ui
dotnet new classlib -n Gsb.Metier -o Gsb.Metier
dotnet new classlib -n Gsb.Donnees -o Gsb.Donnees
dotnet new mstest -n Gsb.Tests -o Gsb.Tests
dotnet sln add Gsb.Ui Gsb.Metier Gsb.Donnees Gsb.Tests

Depuis le SDK .NET 10, le fichier de solution créé est un GsbOrdonnances.slnx, un format XML plus court que l'ancien .sln. Visual Studio 2026 ouvre les deux.

Ce que contient le projet

Dans l'Explorateur de solutions, le projet Gsb.Ui contient quatre fichiers utiles.

GsbOrdonnances/
├── GsbOrdonnances.slnx
└── Gsb.Ui/
    ├── Gsb.Ui.csproj        le fichier projet : plateforme, options, paquets
    ├── Program.cs           le point d'entrée : ce qui s'exécute au lancement
    ├── Form1.cs             ton code : les réactions aux événements
    └── Form1.Designer.cs    le code écrit par le concepteur : les contrôles

Un fichier Form1.resx (images, textes traduits) apparaît sous Form1.cs dès que tu ajoutes une ressource au formulaire, une icône par exemple.

Le fichier projet. Il tient en quelques lignes :

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>WinExe</OutputType>
    <TargetFramework>net10.0-windows</TargetFramework>
    <Nullable>enable</Nullable>
    <UseWindowsForms>true</UseWindowsForms>
    <ImplicitUsings>enable</ImplicitUsings>
  </PropertyGroup>

</Project>

Les paquets NuGet ajoutés plus tard (MySqlConnector, BCrypt.Net-Next…) apparaîtront dans ce fichier sous forme de lignes <PackageReference>.

Program.cs. C'est la méthode Main, la première exécutée :

namespace Gsb.Ui;

static class Program
{
    [STAThread]
    static void Main()
    {
        ApplicationConfiguration.Initialize();
        Application.Run(new Form1());
    }
}

• [STAThread] place le programme dans le mode de fonctionnement qu'exigent les composants Windows (presse-papiers, boîtes de dialogue de fichiers). Ne le retire jamais.
• ApplicationConfiguration.Initialize() applique les réglages de l'application : styles visuels, police par défaut, gestion des écrans haute résolution.
• Application.Run(new Form1()) crée la fenêtre principale, l'affiche et lance la boucle de messages : le programme attend désormais les actions de l'utilisateur (chapitre 3). Quand cette fenêtre se ferme, Run se termine et l'application aussi.

Form1.cs et Form1.Designer.cs. Un formulaire est une classe qui hérite de Form. Elle est écrite dans deux fichiers grâce au mot-clé partial : le concepteur écrit dans Form1.Designer.cs, toi dans Form1.cs. À la compilation, les deux morceaux ne forment qu'une seule classe.

Quand tu poses un bouton dans le concepteur, Visual Studio ajoute dans Form1.Designer.cs un champ private Button button1; et, dans la méthode InitializeComponent(), les lignes qui le créent et règlent sa position, son texte, sa taille. Le constructeur de Form1.cs appelle InitializeComponent() : c'est à ce moment que les contrôles existent.

namespace Gsb.Ui;

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();   // crée les contrôles dessinés dans le concepteur
    }
}

Renommer le formulaire. Form1 ne dit rien. Dans l'Explorateur de solutions, fais un clic droit sur Form1.cs, Renommer, tape FrmPatients.cs et accepte quand Visual Studio propose de renommer aussi la classe et ses références. Renommer à la main dans le code seulement casse le lien avec Program.cs et le fichier .resx.

Compiler, lancer et déboguer

Compiler transforme ton code C# en un fichier Gsb.Ui.dll (le code intermédiaire, ou IL) accompagné d'un lanceur Gsb.Ui.exe, dans le dossier bin\Debug\net10.0-windows\. Au lancement, le runtime .NET compile ce code intermédiaire en instructions du processeur, au fur et à mesure.

Le débogueur est ton meilleur allié. Pose un point d'arrêt (pastille rouge) sur une ligne, lance avec F5 et déclenche l'action : l'exécution s'arrête avant cette ligne. Survole une variable pour voir sa valeur, ou ouvre les fenêtres Variables locales et Espion. Avance ligne à ligne avec F10. Quand une exception n'est pas interceptée, Visual Studio s'arrête sur la ligne fautive et affiche le type de l'exception et son message : lis-les avant de modifier quoi que ce soit. Le cours Maintenance applicative détaille la lecture d'une pile d'appels.

Exercices

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>WinExe</OutputType>
    <TargetFramework>net8.0-windows</TargetFramework>
    <Nullable>disable</Nullable>
    <UseWindowsForms>true</UseWindowsForms>
  </PropertyGroup>
</Project>