Structures : sémantique de valeur et modèle d’immuabilité
Comprenez la sémantique de valeur des structures en C# 6 et construisez un modèle de structure immuable (copie lors des modifications).
Structures : sémantique de valeur et modèle d’immuabilité est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 3 leçons au total.
Vue d’ensemble des structures
Objectif : utiliser les structures en toute sécurité.
- Sémantique de valeur (copie lors de l’affectation)
- Modèle de structure immuable en C# 6
- Passage par valeur ou par référence
- Remarque sur la mise en boîte
Sémantique de copie
Les structures sont des types valeur : l’affectation crée une copie. Modifier la copie ne modifie pas l’original.
using System;
// Simple struct with public fields for demo (okay for small POD data)
public struct Point
{
public int X;
public int Y;
}
public class Program
{
public static void Main(string[] args)
{
Point a = new Point();
a.X = 1; a.Y = 2;
Point b = a; // copy the value
b.X = 9; // change the copy
Console.WriteLine("a=(" + a.X + "," + a.Y + ")");
Console.WriteLine("b=(" + b.X + "," + b.Y + ")"); // different from a
}
}
Modèle de structure immuable
Préférez les structures immuables : des fields readonly, un constructeur pour l’état requis et de petits utilitaires With pour créer de nouvelles valeurs.
using System;
// Immutable struct pattern (C# 6): readonly fields + constructor + With method
public struct Money
{
private readonly decimal _amount;
private readonly string _currency;
public decimal Amount { get { return _amount; } }
public string Currency { get { return _currency; } }
public Money(decimal amount, string currency)
{
_amount = amount;
_currency = currency ?? "USD";
}
// Copy-on-change: returns a new value with updated amount
public Money WithAmount(decimal amount)
{
return new Money(amount, _currency);
}
}
public class Program
{
public static void Main(string[] args)
{
Money m1 = new Money(10m, "USD");
Money m2 = m1.WithAmount(15m); // new value
Console.WriteLine("m1: " + m1.Amount + " " + m1.Currency);
Console.WriteLine("m2: " + m2.Amount + " " + m2.Currency);
}
}
Par valeur ou par référence
Par défaut, les méthodes reçoivent une copie. Utilisez ref pour modifier la structure de l’appelant.
using System;
public struct Counter
{
public int Value;
}
public class Program
{
static void IncrementByValue(Counter c)
{
c.Value = c.Value + 1; // changes only the local copy
}
static void IncrementByRef(ref Counter c)
{
c.Value = c.Value + 1; // changes the caller's variable
}
public static void Main(string[] args)
{
Counter a = new Counter();
IncrementByValue(a);
Console.WriteLine("After by-value: " + a.Value); // 0
IncrementByRef(ref a);
Console.WriteLine("After by-ref: " + a.Value); // 1
}
}
Notions de base sur la mise en boîte
La mise en boîte copie une structure dans une reference d’objet ou d’interface. La conversion inverse crée une autre copie.
using System;
public interface IShow { string Show(); }
public struct Temperature : IShow
{
public int C;
public string Show() { return C + "C"; }
}
public class Program
{
public static void Main(string[] args)
{
Temperature t = new Temperature();
t.C = 25;
object boxed = t; // boxing: copy into object
Temperature copy = (Temperature)boxed; // unbox (another copy)
copy.C = 30;
Console.WriteLine("t = " + t.C); // 25
Console.WriteLine("copy = " + copy.C); // 30
}
}
Conseils sur les structures
Conseils :
- Utilisez les structures pour de petits objets valeur immuables (coordonnées, argent).
- Évitez les structures volumineuses ou très modifiables.
- N’oubliez pas les copies lors de l’affectation et du passage par valeur.
- Faites attention à la mise en boîte lors d’une conversion vers object ou interface.
Sémantique de valeur des structures
Récapitulatif
Récapitulatif : les structures sont des types valeur. Préférez les conceptions petites et immuables (constructeur + fields readonly + With). Comprenez comment le passage par valeur ou avec ref et la mise en boîte influencent les copies.
Questions Fréquemment Posées
La leçon « Structures : sémantique de valeur et modèle d’immuabilité » est-elle gratuite ?
Oui — le texte complet de « Structures : sémantique de valeur et modèle d’immuabilité » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 3 leçons au total.
Qu'est-ce que j'apprendrai dans « Structures : sémantique de valeur et modèle d’immuabilité » ?
Comprenez la sémantique de valeur des structures en C# 6 et construisez un modèle de structure immuable (copie lors des modifications). Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer C# Academy ?
Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 3.
Combien de temps prend la leçon « Structures : sémantique de valeur et modèle d’immuabilité » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?
Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Structures : sémantique de valeur et modèle d’immuabilité
- Types similaires aux enregistrements et égalité fondée sur les valeurs (modèle)
- Énumérations et [Flags]