C# : Le Nouveau Contrat | Faites Entrer C#

La ville dormait sous une pluie de bits.
Entre les ombres des vieux langages, un nouveau joueur arrivait.
Propre. Structuré. Trop propre pour être honnête.
Il s'appelait C#, et il venait changer les règles du jeu.

Introduction générale

Le terminal fumait encore du vieux C++, des relents de Java traînaient dans les caniveaux.
C# est arrivé par la porte de service, en 2000. Un costume de class bien coupé, un regard de interface qui ne promet que ce qu'il peut tenir.

Microsoft l'a fait naître. Anders Hejlsberg l'a façonné.
Une réponse au Java, un défi au C++.
Un langage managed, sous la protection du CLR.
Un écosystème qui grandira dans l'ombre du .NET.

.NET : la machine.
Le Framework d'abord, lourd, Windowsien.
Puis Core, agile, cross-platform.
Enfin .NET 5, 6, 7… la fusion. Un seul nom, pour tous les fronts.

Présentation de C#

C'est un langage orienté objet, fortement typé.
Élégant comme un plan bien exécuté, robuste comme un coffre-fort.

// C'est propre. Trop propre.
public class Operation
{
    public string Code { get; }
    public DateTime DateDebut { get; }
    
    public Operation(string code)
    {
        Code = code;
        DateDebut = DateTime.Now;
    }
    
    public void Executer()
    {
        Console.WriteLine($"Opération {Code} lancée.");
        // L'élégance est dans la clarté
        // La puissance, dans la simplicité
    }
}

Il gère ta mémoire (le GC veille).
Il vérifie tes types (le compilateur est tatillon).
Il te donne des outils pour tout faire, et des garde-fous pour ne pas tout casser.

Historique et écosystème .NET

2002 : .NET Framework 1.0. Les débuts. Balbutiements.
2005 : .NET 2.0, les génériques. On commence à parler sérieusement.
2007 : .NET 3.5, LINQ. Une révolution. Interroger des données comme on parle.
2010 : .NET 4.0, dynamic. La porte vers l'ombre.
2016 : .NET Core. La rupture. Cross-platform. Open source.
2020 : .NET 5. La fusion. Plus de Framework, plus de Core. Juste .NET.

Aujourd'hui : .NET 8, 9, bientôt 10.
Chaque année, une nouvelle version.
Chaque version, de nouvelles armes.

L'écosystème :

NuGet : le marché noir des packages. Des bibliothèques pour tout. Certaines propres, d'autres pleines de surprises.
Visual Studio : le QG. Lourd, puissant. Tout-en-un.
VS Code : le petit frère agile. Léger, rapide, extensible.
Rider : l'outsider de JetBrains. Rapide, intelligent. Cher.

Cas d'usage

Applications console

Le travail discret. Le script qui tourne la nuit. Le daemon qui surveille.

// Program.cs
// Simple. Direct. Sans fioriture.
Console.WriteLine("Début de la surveillance...");
while (true)
{
    Surveiller();
    Thread.Sleep(5000);  // Toutes les 5 secondes
    // Pas de GUI, pas de fenêtre
    // Juste du texte et du travail
}

Applications desktop (WPF, WinForms)

Les interfaces lourdes. Les postes de commande. Les outils qui restent ouverts des jours.

// WPF - XAML et C#
<Window>
    <Button Click="OnExecuteClick">Exécuter</Button>
</Window>

// Code-behind
private void OnExecuteClick(object sender, RoutedEventArgs e)
{
    // Le clic qui déclenche tout
    ExecuteOperation();
}

WinForms : l'ancien monde. Simple, rapide, vieillot.
WPF : le moderne. Data-binding, templates, élégant. Plus complexe.

Applications web & API (ASP.NET)

Le web. Les sites. Les services. Ce qui écoute sur le port 80, 443.

// ASP.NET Core Web API
[ApiController]
[Route("api/[controller]")]
public class ContratsController : ControllerBase
{
    [HttpGet("{id}")]
    public IActionResult GetContrat(int id)
    {
        // Écoute les requêtes HTTP
        // Retourne du JSON
        // Vit dans un conteneur, derrière un reverse proxy
        return Ok(new { Id = id, Statut = "Actif" });
    }
}

MVC : le pattern éprouvé.
Razor Pages : plus simple.
Blazor : C# dans le navigateur. Une magie noire.

Microservices

La division du travail. Chaque service, un petit programme. Chaque programme, une responsabilité.

// Un service qui gère les utilisateurs
// Un autre qui gère les paiements
// Un autre qui loggue tout
// Tous communiquent par HTTP, gRPC, messages...
public class UserService : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            // Travail en continu
            await ProcessQueue();
            await Task.Delay(1000, stoppingToken);
        }
    }
}

Installation de l'environnement

.NET SDK

La boîte à outils. Sans elle, tu ne fais rien.

# Téléchargement sur https://dotnet.microsoft.com
# Installation
# Puis vérification
dotnet --version
# 9.0.100
# Ou 8.0, ou 7.0...

Le SDK contient :

dotnet new : créer des projets
dotnet run : exécuter
dotnet build : compiler
dotnet test : tester
dotnet publish : déployer

IDE : Rider / Visual Studio

Le choix de l'arme.

Visual Studio (Windows) :

Lourd, complet
IntelliSense, debugger, profiler, designer
Community (gratuit), Professional, Enterprise

Visual Studio Code :

Léger, extensible
Avec l'extension C#, il fait presque tout
Cross-platform

Rider (JetBrains) :

Rapide, intelligent
Refactorings puissants
Payant, mais les pirates trouvent toujours des licences

Structure d'un projet C#

L'organisation du crime.

MonProjet/
├── MonProjet.csproj          # La définition du projet
├── Program.cs                # Point d'entrée
├── Controllers/              # Pour le web
├── Models/                   # Les données
├── Services/                 # La logique métier
├── Views/                    # Pour le desktop/web
└── appsettings.json          # Configuration

Le .csproj : le fichier qui dit tout.

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net9.0</TargetFramework>
  </PropertyGroup>
  
  <ItemGroup>
    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
  </ItemGroup>
</Project>

Premier programme

// Program.cs
using System;

namespace PremiereMission
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Le programme commence.");
            
            string message = args.Length > 0 ? args[0] : "Pas d'ordre";
            Console.WriteLine($"Ordre reçu : {message}");
            
            // Le premier pas dans le monde .NET
            // Simple. Propre.
            // Trop propre.
        }
    }
}

Exécution :

dotnet run "Éliminer la cible"
# Le programme commence.
# Ordre reçu : Éliminer la cible

C'est fait.
Tu as signé le contrat.
Tu connais l'histoire, les outils, les cas d'usage.

C# n'est pas qu'un langage.
C'est un écosystème. Une façon de penser.
Une rigueur qui promet la sécurité, mais exige la discipline.

Le CLR sera ton garde du corps.
Le GC, ton nettoyeur.
Les exceptions, tes échecs gérés.

Maintenant, les fondamentaux t'attendent.
Les variables, les boucles, les conditions.
Les bases sur lesquelles tout se construit.

Puis la POO.
Les classes, l'héritage, les interfaces.
Là où la complexité naît, et où l'élégance la dompte.

Bienvenue dans le .NET.
Tout est contrôlé.
Tout est surveillé.
Sauf, peut-être, ce que tu caches entre les lignes.