Comment comparer au mieux les types de référence dans .NET ?

Meilleures pratiques pour la comparaison des types de référence .NET

Lors de la comparaison des types de référence dans .NET, il est important de comprendre la différence entre l'égalité de référence et l'égalité de valeur. L'égalité des références vérifie si deux références pointent vers le même objet, tandis que l'égalité des valeurs vérifie si les objets ont les mêmes données.

Remplacez l'opérateur d'égalité (==) et la méthode Equals

Il n'est pas recommandé de remplacer l'opérateur d'égalité (==) et/ou la méthode Equals pour comparer les types de référence, sauf si le type exprime une sémantique de valeur (c'est-à-dire des objets immuables qui sont considérés comme égaux en fonction de leurs données). Dans ce cas, envisagez d'implémenter l'interface System.IEquatable et trois opérateurs : Equals, GetHashCode et ==/!=.

Interface IEquatable

Si votre type de référence représente la sémantique des valeurs, implémentez System.IEquatable. Cela garantit une mise en œuvre correcte et efficace de l’égalité des valeurs, y compris la gestion séparée de l’identité des objets et de l’égalité des valeurs.

Interface IComparable

IComparable est principalement conçu pour être utilisé avec des types valeur, pas des types référence. Évitez de l'utiliser avec des types de référence.

Comparaison personnalisée

Au lieu de remplacer l'opérateur d'égalité ou d'implémenter IComparable, envisagez de créer une méthode personnalisée pour comparer les types de référence. Utilisez la méthode Equals pour vérifier l'identité de l'objet et la remplacer pour comparer les propriétés associées.

Exemple de valeurs égales

Ce qui suit est un exemple d'implémentation de l'égalité des valeurs pour la classe Point :

<code class="language-csharp">class Point : IEquatable<Point>
{
    public int X { get; }
    public int Y { get; }

    public Point(int x = 0, int y = 0) { X = x; Y = y; }

    public bool Equals(Point other)
    {
        if (other is null) return false;
        return X.Equals(other.X) && Y.Equals(other.Y);
    }

    public override bool Equals(object obj) => Equals(obj as Point);

    public static bool operator ==(Point lhs, Point rhs) => object.Equals(lhs, rhs);

    public static bool operator !=(Point lhs, Point rhs) => !(lhs == rhs);

    public override int GetHashCode() => HashCode.Combine(X, Y);
}</code>

Conclusion

Pour les types de référence avec une sémantique de valeur, implémentez System.IEquatable et les trois opérateurs d'égalité (Equals, GetHashCode, ==/!=). Pour les classes de référence qui représentent des valeurs mutables, ne remplacez pas l’opérateur ==/!=. Utilisez leur comportement par défaut pour vérifier l'identité de l'objet.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!