Types, mémoire, valeur vs référence

// --- type VALEUR (int) ---
int a = 1;
int b = a;          // photocopie
b = 99;
Console.WriteLine(a);       // 1  ← a n'a pas bougé

// --- type RÉFÉRENCE (une classe) ---
var l1 = new List<string> { "x" };
var l2 = l1;        // lien vers le MÊME objet
l2.Add("y");
Console.WriteLine(l1.Count);   // 2  ← surprise : l1 a changé aussi

class Client { public string Nom = "Ada"; }

void Renommer(Client c)      => c.Nom = "Bob";      // modifie l'objet pointé  → visible dehors
void Remplacer(Client c)     => c = new Client();   // remplace la copie d'adresse → invisible dehors
void RemplacerRef(ref Client c) => c = new Client();// remplace la variable elle-même → visible dehors

var client = new Client();
Renommer(client);      Console.WriteLine(client.Nom);   // Bob
Remplacer(client);     Console.WriteLine(client.Nom);   // Bob (rien n'a changé !)
RemplacerRef(ref client); Console.WriteLine(client.Nom);// Ada (nouvel objet)

var s = "bonjour";
s.ToUpper();                     // ← ne fait RIEN d'utile : le résultat est jeté
Console.WriteLine(s);            // bonjour

s = s.ToUpper();                 // ← il faut réaffecter
Console.WriteLine(s);            // BONJOUR

// Conséquence en boucle : chaque += crée une NOUVELLE chaîne
var mauvais = "";
for (int i = 0; i < 10_000; i++) mauvais += i;      // 10 000 objets alloués 😱

var bon = new System.Text.StringBuilder();          // ← un seul tampon réutilisé
for (int i = 0; i < 10_000; i++) bon.Append(i);
var resultat = bon.ToString();

// Avec <Nullable>enable</Nullable> dans le .csproj (activé par défaut sur les nouveaux projets) :
string nom  = null;    // ⚠️ avertissement CS8600 : string ne devrait pas être null
string? sur = null;    // ✅ explicitement « peut être null »

Console.WriteLine(sur.Length);      // ⚠️ CS8602 : déréférencement possible d'un null

// Les trois outils à connaître :
Console.WriteLine(sur?.Length);              // ?. → null au lieu d'exploser
Console.WriteLine(sur ?? "valeur par défaut"); // ?? → si null, prends ça
if (sur is not null) Console.WriteLine(sur.Length);  // vérification explicite

class ClientClasse  { public string Nom = ""; }
record ClientRecord(string Nom);
struct Point { public int X, Y; }

var c1 = new ClientClasse { Nom = "Ada" };
var c2 = new ClientClasse { Nom = "Ada" };
Console.WriteLine(c1 == c2);        // False ← deux objets différents (comparaison d'adresses)

var r1 = new ClientRecord("Ada");
var r2 = new ClientRecord("Ada");
Console.WriteLine(r1 == r2);        // True  ← record : comparaison par contenu, offerte

Console.WriteLine(new Point { X = 1 }.Equals(new Point { X = 1 }));  // True (struct : contenu)

Console.WriteLine(ReferenceEquals(r1, r2));   // False ← « est-ce le même objet ? »

// Le bon struct : petit, immuable, sans identité
public readonly record struct Argent(decimal Montant, string Devise)
{
    public Argent Plus(Argent autre) => Devise == autre.Devise
        ? new Argent(Montant + autre.Montant, Devise)
        : throw new InvalidOperationException("Devises différentes");
}

int i = 42;
object o = i;          // BOXING : allocation dans le tas
int j = (int)o;        // UNBOXING : déballage, avec vérification de type

// Cas fréquents, souvent involontaires :
object[] melange = { 1, 2, 3 };               // 3 boxings
ArrayList vieux = new(); vieux.Add(42);        // API pré-générique → boxing systématique
string s = $"valeur = {i}";                   // ⚠️ historiquement un boxing, optimisé aujourd'hui