0Pricing
C# Academy · Leçon

Égalité des valeurs et déconstruction

Comprenez l’égalité structurelle des records, surchargez Equals/GetHashCode et utilisez les modèles de déconstruction.

Égalité des valeurs et déconstruction est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. 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 4 leçons au total.

Analyse approfondie de l’égalité des enregistrements

Les enregistrements génèrent automatiquement Equals, GetHashCode et les opérateurs ==/!=, qui comparent structurellement toutes les propriétés. Comprendre ce fonctionnement vous aide à utiliser correctement les enregistrements et à remplacer ce comportement lorsque nécessaire.

Fonctionnement de l’égalité générée automatiquement

Le compilateur génère du code qui compare chaque propriété à l’aide de EqualityComparer<T>.Default. Pour les propriétés de type référence, il s’agit de leur propre Equals, et non d’une égalité par référence.

public record Address(string Street, string City);
public record Person(string Name, Address HomeAddress);

var a = new Person("Alice", new Address("123 Main", "NYC"));
var b = new Person("Alice", new Address("123 Main", "NYC"));

Console.WriteLine(a == b); // True — deep structural equality
// Equality checks:
// Name: "Alice" == "Alice" ✓
// HomeAddress: compares Address properties recursively ✓

Remplacer l’égalité générée

Vous pouvez remplacer Equals et GetHashCode sur un enregistrement lorsque vous souhaitez appliquer une logique d’égalité personnalisée, par exemple en ne comparant qu’un sous-ensemble des propriétés.

public record Customer(int Id, string Name, string Email)
{
    // Consider customers equal if they have the same ID,
    // regardless of name or email changes
    public virtual bool Equals(Customer? other)
        => other is not null && Id == other.Id;

    public override int GetHashCode() => Id.GetHashCode();
}

Les enregistrements dans les collections

Comme les enregistrements implémentent l’égalité structurelle, ils fonctionnent correctement comme clés de dictionnaire, dans les HashSets et avec LINQ, notamment avec Distinct et GroupBy.

public record Tag(string Name, string Color);

var tags = new List<Tag>
{
    new("C#", "blue"), new("C#", "blue"), new("dotnet", "purple")
};

var unique = tags.Distinct().ToList(); // [Tag(C#, blue), Tag(dotnet, purple)]

var set = new HashSet<Tag>(tags);
set.Contains(new Tag("C#", "blue")); // true

Déconstruction : notions fondamentales

Les enregistrements positionnels génèrent automatiquement une méthode Deconstruct avec des paramètres out pour chaque propriété positionnelle. Cela permet un déballage semblable à celui des tuples.

public record Point(double X, double Y);
public record RGB(byte R, byte G, byte B);

var p = new Point(3.0, 4.0);
var (x, y) = p; // deconstruct
Console.WriteLine($"{x}, {y}");

var color = new RGB(255, 128, 0);
var (r, g, b) = color;
Console.WriteLine($"R={r}, G={g}, B={b}");

Déconstruction dans la mise en correspondance de motifs

La déconstruction des enregistrements dans les expressions switch permet une puissante mise en correspondance de motifs positionnels.

public record Point(int X, int Y);

string Classify(Point p) => p switch
{
    (0, 0)           => "Origin",
    (int x, 0)       => $"X-axis at {x}",
    (0, int y)       => $"Y-axis at {y}",
    (int x, int y) when x == y => $"Diagonal at {x}",
    (int x, int y)   => $"Point ({x}, {y})"
};

Console.WriteLine(Classify(new Point(0, 0)));  // Origin
Console.WriteLine(Classify(new Point(3, 3)));  // Diagonal at 3

Méthodes Deconstruct personnalisées

Les enregistrements non positionnels, comme toute classe, peuvent ajouter manuellement une méthode Deconstruct. Les méthodes d’extension peuvent également ajouter la déconstruction à des types existants.

public class Temperature
{
    public double Celsius { get; }
    public Temperature(double c) => Celsius = c;

    // Manual Deconstruct
    public void Deconstruct(out double celsius, out double fahrenheit)
    {
        celsius    = Celsius;
        fahrenheit = Celsius * 9 / 5 + 32;
    }
}

var t = new Temperature(100);
var (c, f) = t;
Console.WriteLine($"{c}°C = {f}°F"); // 100°C = 212°F

Ignorer certaines parties de la déconstruction

Utilisez les rejets (_) pour ignorer les parties inutiles d’une déconstruction, comme avec les rejets de tuples.

public record Order(int Id, string Customer, decimal Total, DateTime Date);

var order = new Order(42, "Alice", 99.99m, DateTime.UtcNow);

// Only want Id and Total
var (id, _, total, _) = order;
Console.WriteLine($"Order {id}: ${total}");

// In switch: ignore some fields
string Classify(Order o) => o switch
{
    (_, _, > 1000, _) => "High value",
    (_, _, > 100, _)  => "Medium value",
    _                 => "Low value"
};

Motifs de propriétés et motifs positionnels

Les enregistrements prennent en charge les motifs positionnels (selon la position) et les motifs de propriétés (selon le nom). Les motifs de propriétés sont plus lisibles pour les enregistrements comportant de nombreuses propriétés.

public record Order(int Id, string Status, decimal Total);

// Positional pattern:
string DescribePos(Order o) => o switch
{
    (_, "Shipped", > 100) => "High-value shipped",
    _                     => "Other"
};

// Property pattern (more readable):
string DescribeProp(Order o) => o switch
{
    { Status: "Shipped", Total: > 100 } => "High-value shipped",
    { Status: "Cancelled" }             => "Cancelled",
    _                                   => "Other"
};

Cas réel : motif de type Result

Un type Result de style union discriminée utilisant des enregistrements et la déconstruction : une approche fonctionnelle de la gestion des erreurs.

public abstract record Result<T>;
public record Success<T>(T Value) : Result<T>;
public record Failure<T>(string Error) : Result<T>;

Result<Order> PlaceOrder(CreateOrderRequest req)
{
    if (req.Quantity <= 0)
        return new Failure<Order>("Quantity must be positive");
    var order = CreateOrder(req);
    return new Success<Order>(order);
}

// Consuming:
var result = PlaceOrder(request);
switch (result)
{
    case Success<Order>(var order):
        return Results.Created($"/orders/{order.Id}", order);
    case Failure<Order>(var error):
        return Results.BadRequest(error);
}

Vérification rapide

Que fait l’utilisation d’un rejet (_) dans une expression de déconstruction ?

Récapitulatif : égalité par valeur et déconstruction

Points clés à retenir :

  • L’égalité générée automatiquement compare toutes les propriétés de manière structurelle et récursive
  • Redéfinissez Equals/GetHashCode sur les enregistrements pour appliquer une logique d’identité personnalisée
  • Les enregistrements fonctionnent correctement comme éléments d’un HashSet et comme clés de dictionnaire
  • Les enregistrements positionnels génèrent automatiquement Deconstruct — utilisez var (a, b) = record
  • Les valeurs ignorées (_) permettent d’écarter les valeurs positionnelles inutiles lors de la déconstruction
  • Les motifs de propriétés ({Status: "X"}) sont plus lisibles que les motifs positionnels pour les enregistrements complexes

Questions Fréquemment Posées

La leçon « Égalité des valeurs et déconstruction » est-elle gratuite ?

Oui — le texte complet de « Égalité des valeurs et déconstruction » 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 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Égalité des valeurs et déconstruction » ?

Comprenez l’égalité structurelle des records, surchargez Equals/GetHashCode et utilisez les modèles de déconstruction. 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 3 sur 4.

Combien de temps prend la leçon « Égalité des valeurs et déconstruction » ?

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

  1. Types record : notions de base et syntaxe
  2. Immuabilité avec init et with
  3. Égalité des valeurs et déconstruction
  4. Records dans la conception pilotée par le domaine
← Retour à C# Academy