Cours C# Complet 💜

namespace MonApp

// C# moderne — top-level statements (.NET 6+)
Console.WriteLine(« Bonjour le monde ! »);

# Créer un projet console
dotnet new console -n MonApp
cd MonApp

# Exécuter
dotnet run

# Compiler (produit un .dll ou .exe)
dotnet build

// Interpolation (recommandée)
string salut = $ »Bonjour , vous avez ans »;

// Concaténation
string s = « Hello » +  » World »;

// Verbatim string (pas d'échappement)
string path = @ »C:\Users\Alice\docs »;

// Raw string literal (C# 11+)
string json = «  » »

«  » »;

// Méthodes string
nom.Length // 5
nom.ToUpper() // « ALICE »
nom.ToLower() // « alice »
nom.Contains(« lic ») // true
nom.StartsWith(« A ») // true
nom.Substring(0, 3) // « Ali »
nom.Replace(« A », « a ») // « alice »
nom.Trim() // Supprime espaces
nom.Split(',') // string[]
string.IsNullOrEmpty(s) // null ou «  »
string.IsNullOrWhiteSpace(s) // null, «  » ou espaces

// var — inférence de type (le compilateur déduit)
var age = 25; // int
var liste = new List<string>(); // List

// Vérifier et utiliser
if (age.HasValue)

// ?? — valeur par défaut si null
int result = age ?? 0;

// ??= — assigner si null
age ??= 18;

// ?. — null-conditional (évite NullReferenceException)
string? ville = user?.Address?.City;

// Division entière (comme Java)
7 / 2 // 3 (pas 3.5 !)
7.0 / 2 // 3.5

// Comparaison
== != < > <= >=

// Logique
&& || !

// Ternaire
string status = age >= 18 ? « majeur » : « mineur »;

// Null-coalescing (??) et null-conditional (?.)
string nom = input ?? « Inconnu »;
int? len = text?.Length;

// is — vérifier le type (pattern matching)
if (obj is string s)

// as — cast sûr (retourne null si impossible)
string? s = obj as string;

// Switch expression (C# 8+) — concis, retourne une valeur
string label = day switch
;

// Pattern matching dans switch (C# 9+)
string category = age switch
;

// foreach — parcourir une collection
string[] fruits = ;
foreach (var fruit in fruits)

// while et do-while
while (i < 10)
do while (i < 10);

// Accès
nombres[0] // 1
nombres[^1] // 5 (dernier — Index from end)
nombres[1..3] // (Range — C# 8+)

// Propriétés et méthodes
nombres.Length // 5
Array.Sort(nombres);
Array.Reverse(nombres);
Array.IndexOf(nombres, 3);
Array.Exists(nombres, x => x > 3);

// required (C# 11) — oblige l'initialisation
public class Config

var config = new Config ;

public class Dog : Animal

// Polymorphisme
Animal a = new Dog(« Rex », « Labrador »);
a.Speak(); // « Rex : Wouf ! » — appelle la version Dog

var p = new Point(3, 4);
p.X // 3
Console.WriteLine(p); // « Point  »

// Comparaison par valeur (pas par référence)
var p2 = new Point(3, 4);
p == p2 // true (compare les valeurs)

// Copie avec modification (with expression)
var p3 = p with ; // Point

// record struct (C# 10) — type valeur
public readonly record struct Color(byte R, byte G, byte B);

public interface IValidatable

// Implémentation multiple
public class User : ISerializable, IValidatable

public class Circle(double radius) : Shape

catch (DivideByZeroException ex)

catch (Exception ex) // Attrape tout le reste

finally

// Lever une exception
public void SetAge(int age)

// Exception personnalisée
public class InsufficientFundsException : Exception

// Dictionary
var ages = new Dictionary<string, int>
;
ages[« Alice »] // 25
ages.TryGetValue(« Eve », out var age); // false, age = 0
ages.ContainsKey(« Bob »); // true

// HashSet — éléments uniques
var ids = new HashSet<int> ; //

// Queue et Stack
var queue = new Queue<string>(); // FIFO
var stack = new Stack<string>(); // LIFO

// Classe générique
public class Result<T>

// Contraintes where
// where T : class — type référence
// where T : struct — type valeur
// where T : new() — constructeur sans paramètre
// where T : IComparable — implémente l'interface
// where T : BaseClass — hérite de BaseClass

// Func = retourne une valeur
// Action = void (pas de retour)
// Predicate = retourne bool

// Where — filtrer
var pairs = nombres.Where(n => n % 2 == 0); //

// Select — transformer
var doubles = nombres.Select(n => n * 2); //

// Chaînage complet
var result = nombres
.Where(n => n > 3)
.Select(n => n * 2)
.OrderByDescending(n => n)
.Take(3)
.ToList(); //

// Opérations utiles
nombres.First() // 1
nombres.FirstOrDefault() // 1 (ou 0 si vide)
nombres.Last() // 10
nombres.Any(n => n > 5) // true
nombres.All(n => n > 0) // true
nombres.Count() // 10
nombres.Sum() // 55
nombres.Average() // 5.5
nombres.Min() // 1
nombres.Max() // 10
nombres.Distinct() // Dédupliquer
nombres.GroupBy(n => n % 2) // Grouper
nombres.ToDictionary(n => n, n => n * 2) // Dict

// void async = Task (pas de retour)
public async Task SaveAsync(string data)

// Parallèle
var task1 = FetchDataAsync(« url1 »);
var task2 = FetchDataAsync(« url2 »);
var results = await Task.WhenAll(task1, task2);

// Écrire
await File.WriteAllTextAsync(« out.txt », « Contenu »);
await File.AppendAllTextAsync(« log.txt », « Nouvelle ligne\n »);

// Vérifier
File.Exists(« file.txt »);
Directory.Exists(« folder »);

// Property pattern
string GetDiscount(User user) => user switch
;

// List pattern (C# 11)
int[] arr = ;
if (arr is [1, .., 3])