Comprendre l'égalité de valeur dans les records .NET

▸ Définir l'égalité de valeur

▸ Le problème des collections dans les records

public record OrderItem(
    string ProductName,
    int Quantity,
    decimal Price);

public record BadOrder(
    string OrderId,
    string CustomerName,
    List<OrderItem> Items);

[Test]
public void TestBadOrderEquality()
{
    OrderItem item1 = new("ProductA", 2, 10.0m);
    OrderItem item2 = new("ProductB", 1, 20.0m);

    BadOrder order1 = new("Order1", "John Doe", [item1, item2]);
    BadOrder order2 = new("Order1", "John Doe", [item1, item2]);

    Assert.Multiple(() =>
    {
        Assert.That(order1.OrderId, Is.EqualTo(order2.OrderId));
        Assert.That(order1.CustomerName, Is.EqualTo(order2.CustomerName));
        Assert.That(order1.Items[0], Is.EqualTo(order2.Items[0]));
        Assert.That(order1.Items[1], Is.EqualTo(order2.Items[1]));

        // :-( CETTE LIGNE ÉCHOUE PARCE QUE LES COLLECTIONS NE SONT PAS ÉGALES PAR VALEUR
        Assert.That(order1, Is.EqualTo(order2));
    });
}

▸ ValueCollection : une collection qui compare par valeur

public record GoodOrder(
    string OrderId,
    string CustomerName,
    ValueCollection<OrderItem> Items);

using System.Collections.ObjectModel;
using System.Text;

/// <summary>
/// Represents a collection of values.
/// </summary>
/// <param name="values">The values to initialize the collection with.</param>
/// <typeparam name="T">The type of the values in the collection.</typeparam>
public class ValueCollection<T>(params IList<T> values)
    : ReadOnlyCollection<T>(new List<T>(values))
{
    /// <summary>
    /// Adds an item to the collection.
    /// </summary>
    /// <param name="item">The object to add to the value collection.</param>
    /// <exception cref="ArgumentNullException">Thrown when item is null.</exception>
    public void Add(T item)
    {
        ArgumentNullException.ThrowIfNull(item);

        Items.Add(item);
    }

    /// <summary>
    /// Determines whether the specified object is equal to the current object.
    /// The comparison is done by comparing the items in the collection.
    /// </summary>
    /// <param name="obj">The object to compare with the current object.</param>
    /// <returns>true if the specified object is equal to the current object; otherwise, false.</returns>
    public override bool Equals(object? obj)
    {
        if (ReferenceEquals(null, obj))
        {
            return false;
        }

        if (ReferenceEquals(this, obj))
        {
            return true;
        }

        return obj is ValueCollection<T> other
               && other.Items.SequenceEqual(Items);
    }

    /// <inheritdoc />
    public override int GetHashCode()
    {
        HashCode hashCode = new();
        foreach (T item in Items)
        {
            hashCode.Add(item);
        }

        return hashCode.ToHashCode();
    }

    /// <summary>
    /// Returns a string that represents the current object.
    /// If the collection has more than 3 items, only the first 3 items are shown.
    /// </summary>
    /// <returns>A string that represents the current object.</returns>
    public override string ToString()
    {
        StringBuilder sb = new();

        sb.Append("[ ");

        // if we have more than 3 items, we only show the first 3 then "..."
        if (Items.Count > 3)
        {
            sb.AppendJoin(", ", Items.Take(3));
            sb.Append(", ...");
        }
        else
        {
            sb.AppendJoin(", ", Items);
        }

        sb.Append(" ]");

        return sb.ToString();
    }
}

▸ Tester l'égalité de valeur avec GoodOrder

[Test]
public void TestGoodOrderEquality()
{
    OrderItem item1 = new("ProductA", 2, 10.0m);
    OrderItem item2 = new("ProductB", 1, 20.0m);

    GoodOrder order1 = new("Order1", "John Doe", [item1, item2]);
    GoodOrder order2 = new("Order1", "John Doe", [item1, item2]);

    Assert.Multiple(() =>
    {
        Assert.That(order1.OrderId, Is.EqualTo(order2.OrderId));
        Assert.That(order1.CustomerName, Is.EqualTo(order2.CustomerName));
        Assert.That(order1.Items[0], Is.EqualTo(order2.Items[0]));
        Assert.That(order1.Items[1], Is.EqualTo(order2.Items[1]));

        // :-) CETTE LIGNE PASSE PARCE QUE LES COLLECTIONS SONT ÉGALES PAR VALEUR
        Assert.That(order1, Is.EqualTo(order2));
    });
}

▸ Les avantages de ValueCollection

Une sémantique d'égalité cohérente : en surchargeant Equals et GetHashCode, ValueCollection<T> garantit une égalité par valeur constante, ce qui simplifie le travail avec des records contenant des collections.
Des tests plus simples : le comportement d'égalité correspondant à la sémantique attendue, écrire et maintenir des tests unitaires devient plus direct, sans avoir à contourner des problèmes d'égalité par référence.
Une lisibilité et une maintenabilité accrues : ValueCollection<T> rend l'intention explicite, à savoir que la collection doit être traitée comme un ensemble de valeurs et pas seulement comme une référence.

▸ Points de vigilance

L'immuabilité : ValueCollection<T> s'appuie sur ReadOnlyCollection<T>, ce qui signifie que les modifications sont restreintes une fois la collection créée, sauf via la méthode Add fournie. Cette caractéristique est essentielle pour préserver l'immuabilité, fondamentale pour les records.
Les implications de performance : selon la taille de la collection, calculer un hash ou effectuer une comparaison d'égalité peut introduire un surcoût, puisque chaque élément doit être évalué individuellement.

▸ Conclusion