C#

Des bases du langage à LINQ, async/await et l’écosystème .NET ; fonctionnalités modernes et bonnes pratiques pour des applications prêtes pour la production.

Qu’est-ce que C# ?

C# est un langage à typage statique développé par Microsoft qui combine des fonctionnalités orientées objet et fonctionnelles. Avec .NET 8, il est multiplateforme (Windows, Linux, macOS) et s’utilise pour des API web, des applications de bureau, des services cloud, des tâches en arrière-plan et des jeux (Unity) sur un large éventail.

Écosystème : ASP.NET Core (web), Entity Framework Core (accès aux données), xUnit/NUnit (tests), NuGet (gestion des paquets) et la CLI dotnet (ligne de commande).

TL;DR

C# moderne : records, correspondance de motifs (pattern matching), async/await, et span/memory pour la performance.
Services REST rapides avec Minimal APIs ; CRUD efficace et LINQ avec EF Core.
Architecture en couches + injection de dépendances pour un design testable.

Bases du langage

Les bases de la syntaxe C#, du système de types et du contrôle de flux. Le premier arrêt pour comprendre la logique du langage.

Introduction à C# et à l’écosystème .NET

11 janvier 2026 • Bases du langage

C# est un langage moderne, sûr et orienté objet. Avec l’écosystème .NET, il est possible de développer des applications web, mobiles, de bureau et des jeux.

Bases de C# C#

Lire →

Premier projet C#

11 janvier 2026 • Bases du langage

Première application console en C# avec Visual Studio 2022 : utilisation de WriteLine, ReadKey et ReadLine.

Lire →

Types de données de base en C#

11 janvier 2026 • Bases du langage

Types de données de base en C# : numériques, textuels, logiques, orientés objet et nullables.

Bases de C# C# Variables

Lire →

Structure de la syntaxe C#

13 janvier 2026 • Bases du langage

Découvrez les bases de la syntaxe C#, incluant les blocs de code, les commentaires et les règles de nommage des variables.

Lire →

Opérateurs et expressions en C#

13 janvier 2026 • Bases du langage

Opérateurs et expressions en C# : utilisation des opérateurs arithmétiques, de comparaison, logiques, d’incrémentation/décrémentation, ternaire et null-coalescing.

Lire →

Structures conditionnelles en C# (if, else, switch)

13 janvier 2026 • Bases du langage

Structures conditionnelles en C# : apprenez à utiliser if, else if, else et switch pour exécuter différentes actions selon les conditions.

C# Instruction else Instruction if Instruction switch

Lire →

En C#, FirstOrDefault() peut retourner null. Vérifiez toujours le résultat avant de l’utiliser pour éviter les erreurs.


// Utilisation risquée
var user = users.FirstOrDefault();
Console.WriteLine(user.Name); // peut provoquer une erreur

// Utilisation sûre
var safeUser = users.FirstOrDefault();
if (safeUser != null)
{
    Console.WriteLine(safeUser.Name);
}

En C#, il est préférable d’utiliser une boucle for plutôt que foreach lorsque l’index est nécessaire ou lorsque la collection doit être modifiée.


// foreach : pas d’index disponible
foreach (var item in items)
{
    Console.WriteLine(item);
}

// for : lorsque l’index est nécessaire
for (int i = 0; i < items.Count; i++)
{
    Console.WriteLine($"{i}: {items[i]}");
}

// for : plus sûr pour supprimer des éléments
for (int i = items.Count - 1; i >= 0; i--)
{
    items.RemoveAt(i);
}

En C#, l’opérateur ?. permet d’accéder de manière sécurisée à une propriété ou une méthode. Si l’objet est null, aucune erreur ne se produit et le résultat est null.


Person? person = null;

// Ancienne méthode
string name1 = person != null ? person.Name : null;

// Méthode recommandée
string? name2 = person?.Name;

Console.WriteLine(name1); // null
Console.WriteLine(name2); // null

En C#, utilisez TryParse au lieu de Parse lors de la conversion de données utilisateur ou externes afin d’éviter les erreurs à l’exécution.


// Utilisation risquée
int age = int.Parse(input);

// Utilisation sûre
if (int.TryParse(input, out int result))
{
    Console.WriteLine(result);
}
else
{
    Console.WriteLine("Nombre invalide");
}

En C#, évitez d’appeler ToList() si vous n’avez pas réellement besoin d’une liste. Une utilisation inutile entraîne un coût en mémoire et en performances.


// Appel inutile de ToList()
var activeUsers = users
    .Where(u => u.IsActive)
    .ToList();

foreach (var user in activeUsers)
{
    Console.WriteLine(user.Name);
}

// Meilleure approche
var activeUsersBetter = users
    .Where(u => u.IsActive);

foreach (var user in activeUsersBetter)
{
    Console.WriteLine(user.Name);
}

Lors de la comparaison de chaînes de caractères en C#, l’utilisation de StringComparison permet d’éviter les erreurs liées à la culture et à la casse.


string a = "paris";
string b = "PARIS";

bool eq1 = a == b;
bool eq2 = string.Equals(a, b, StringComparison.OrdinalIgnoreCase);

Console.WriteLine(eq1); // False
Console.WriteLine(eq2); // True

En C#, il est préférable d’éviter de capturer l’Exception générale. Capturez uniquement les exceptions que vous prévoyez de gérer.


// Utilisation risquée : masque le vrai problème
try
{
    int number = int.Parse(input);
}
catch (Exception)
{
    Console.WriteLine("Une erreur est survenue");
}

// Utilisation recommandée : exception spécifique
try
{
    int number = int.Parse(input);
}
catch (FormatException)
{
    Console.WriteLine("Nombre non valide");
}

En C#, utilisez is et is not pour des vérifications de type plus lisibles et des correspondances de modèles.


// Ancienne approche (utilisation de "as" et vérification de null)
object obj = "Bonjour, le monde!";
if (obj is string)
{
    Console.WriteLine(((string)obj).ToUpper()); // BONJOUR, LE MONDE!
}

// Méthode recommandée (utilisation de is)
if (obj is string str)
{
    Console.WriteLine(str.ToUpper()); // BONJOUR, LE MONDE!
}

// Utilisation de "is not" pour la négation
if (obj is not int)
{
    Console.WriteLine("Ce n’est pas un entier");
}

En C#, utilisez Any() au lieu de vérifier Count > 0 pour savoir si une collection contient des éléments. Cette approche est plus lisible et souvent plus efficace.


// Moins lisible
if (items.Count > 0)
{
    Console.WriteLine("Éléments présents");
}

// Méthode recommandée
if (items.Any())
{
    Console.WriteLine("Éléments présents");
}

En C#, vérifier uniquement null ou une chaîne vide n’est pas suffisant. Utiliser string.IsNullOrWhiteSpace() est plus sûr.


// Vérifications risquées
if (text == null || text == "")
{
    Console.WriteLine("Texte invalide");
}

// Vérification sûre et recommandée
if (string.IsNullOrWhiteSpace(text))
{
    Console.WriteLine("Texte invalide");
}