Accueil › Les fondations › Chapitre 1

C'est quoi .NET ?

Avant de parler de code, il faut savoir où on met les pieds. Ce chapitre installe le décor : qui exécute ton programme, qui le traduit, qui nettoie derrière lui, et pourquoi il existe autant de numéros de version.

En une phrase

.NET est une plateforme : un moteur qui exécute des programmes, une immense bibliothèque de code déjà écrit, et des outils pour fabriquer tout ça. C# est un langage qu'on utilise pour écrire ces programmes. Les deux sont différents, comme la route et la voiture.

Les cinq noms qu'on confond tout le temps

Que se passe-t-il quand tu appuies sur « Exécuter » ?

Ton fichier .cs est un fichier texte. Le processeur ne comprend pas le texte. Il faut donc traduire — et .NET le fait en deux temps, ce qui est la clé pour comprendre beaucoup de comportements.

Pourquoi deux étapes plutôt qu'une ?

• Portabilité : le même .dll tourne sur Windows, Linux, macOS, ARM ou x64. La traduction finale s'adapte à la machine qui l'exécute.
• Optimisation à l'usage : le JIT voit ton programme tourner. Il peut se rendre compte qu'une méthode est appelée un million de fois et la recompiler mieux.
• Sécurité et outillage : l'IL est vérifiable, inspectable, et permet aux profileurs et débogueurs de savoir exactement où on en est.

SDK ou runtime : lequel installer ?

dotnet --list-sdks
dotnet new webapi -o MonApi
dotnet run

dotnet --list-runtimes

{ "sdk": { "version": "10.0.100", "rollForward": "latestFeature" } }

La mémoire, gérée pour toi

En C, le développeur réserve et libère la mémoire à la main. En .NET, le ramasse-miettes s'en charge : dès qu'un objet n'est plus accessible par personne, sa place est récupérée. Tu ne libères rien, tu ne comptes rien.

La bibliothèque de base et NuGet

Une part énorme de la valeur de .NET tient à ce qui est déjà écrit. Manipuler des dates, lire un fichier, appeler une API HTTP, trier une liste, parser du JSON : tout est fourni.

using System.Text.Json;                       // JSON
using System.Net.Http.Json;                   // appels HTTP + JSON

var texte = File.ReadAllText("data.txt");                  // fichiers
var demain = DateTime.Today.AddDays(1);                    // dates
var mots = texte.Split(' ', StringSplitOptions.RemoveEmptyEntries);
var json = JsonSerializer.Serialize(new { mots = mots.Length });

using var http = new HttpClient();
var meteo = await http.GetFromJsonAsync<Meteo>("https://api.exemple.fr/meteo");

Quand la bibliothèque de base ne suffit pas, on va chercher un paquet sur NuGet :

dotnet add package Serilog.AspNetCore     # ajoute la dépendance au .csproj
dotnet list package --outdated            # ce qui a une nouvelle version
dotnet list package --vulnerable          # failles de sécurité connues

Anatomie d'un projet

MonApi/
├── MonApi.csproj        # la fiche d'identité du projet
├── Program.cs           # le point d'entrée : tout commence ici
├── appsettings.json     # la configuration
├── Properties/
│   └── launchSettings.json   # ports et profils de lancement (dev seulement)
├── bin/                 # résultat de la compilation  → jamais dans Git
└── obj/                 # fichiers temporaires        → jamais dans Git

<Project Sdk="Microsoft.NET.Sdk.Web">
  <PropertyGroup>
    <TargetFramework>net10.0</TargetFramework>   <!-- version de .NET visée -->
    <Nullable>enable</Nullable>                   <!-- alerte sur les null : à garder -->
    <ImplicitUsings>enable</ImplicitUsings>       <!-- using System; etc. automatiques -->
    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>  <!-- recommandé -->
  </PropertyGroup>
</Project>

Pas de liste de fichiers : tous les .cs du dossier sont inclus automatiquement. Un projet se compile en un seul assembly (le .dll dans bin/), et cette frontière compte : c'est elle que délimite le mot-clé internal (chapitre 6).

#!/usr/bin/env dotnet
#:package Humanizer@2.14.1

Console.WriteLine(TimeSpan.FromMinutes(90).Humanize());

Les versions : LTS, STS, et laquelle choisir

Une version de .NET sort chaque année en novembre. Les numéros pairs sont LTS : trois ans de correctifs. Les impairs sont STS : dix-huit mois.

La règle simple : nouveau projet ou migration → .NET 10. Les versions STS servent à ceux qui mettent à jour en continu et veulent les nouveautés tôt. Monter de version majeure est en général peu coûteux en .NET moderne : changer net8.0 en net10.0, recompiler, lire les breaking changes annoncés.

Les commandes du quotidien

dotnet new webapi -o MonApi
cd MonApi
dotnet watch

Vérifie que c'est passé

Fiches de révision

Clique pour retourner la carte.