Est-il complet IEquatable mise en œuvre de référence?

Je crois à obtenir quelque chose d'aussi simple que la vérification des objets pour l'égalité correcte est un peu délicat avec .NET design.

Pour Struct

1) mettre en Œuvre IEquatable<T>. Il améliore les performances sensiblement.

2) Puisque vous allez avoir votre propre Equals maintenant, remplacer GetHashCode, et être compatible avec les différents égalité vérification de remplacer object.Equals ainsi.

3) Surcharge == et != les opérateurs n'ont pas besoin d'être religieusement fait depuis le compilateur avertira si vous involontairement assimiler une structure à l'autre avec une == ou !=, mais son bon de le faire pour être cohérent avec Equals méthodes.

public struct Entity : IEquatable<Entity>
{
    public bool Equals(Entity other)
    {
        throw new NotImplementedException("Your equality check here...");
    }

    public override bool Equals(object obj)
    {
        if (obj == null || !(obj is Entity))
            return false;

        return Equals((Entity)obj);
    }

    public static bool operator ==(Entity e1, Entity e2)
    {
        return e1.Equals(e2);
    }

    public static bool operator !=(Entity e1, Entity e2)
    {
        return !(e1 == e2);
    }

    public override int GetHashCode()
    {
        throw new NotImplementedException("Your lightweight hashing algorithm, consistent with Equals method, here...");
    }
}

Pour La Classe

À partir de MS:

La plupart des types de référence ne doit pas surcharger l'opérateur d'égalité, même si elles l'emportent sur d'égal à Égal.

Pour moi == se sent comme la valeur de l'égalité, de plus en plus comme un sucre syntaxique pour Equals méthode. Écrit a == b est beaucoup plus intuitif que d'écrire a.Equals(b). Rarement nous aurons besoin de vérifier la référence de l'égalité. En résumé les niveaux traiter avec la logique des représentations d'objets physiques, ce n'est pas quelque chose que nous devons vérifier. Je pense avoir différentes sémantiques pour == et Equals peut effectivement être source de confusion. Je crois qu'il doit avoir été == pour la valeur de l'égalité et de Equals de référence (ou un nom comme IsSameAs) l'égalité à la première place. J'aimerais pas prendre MS directive au sérieux ici, et pas seulement parce qu'il n'est pas naturel pour moi, mais aussi parce que la surcharge == ne fait pas de mal majeure. C'est à la différence de pas primordial non générique Equals ou GetHashCode qui peut mordre en retour, parce que le cadre n'utilise pas == n'importe où, mais seulement si nous avons nous-même de l'utiliser. Le seul réel avantage, je le gain de ne pas surcharger == et != sera la cohérence avec la conception de l'ensemble du cadre sur lequel je n'ai aucun contrôle. Et c'est en effet une grande chose, donc, malheureusement je m'en tiendrai à ce.

Avec référence sémantique (mutable objets)

1) Remplacer Equals et GetHashCode.

2) la mise en Œuvre de IEquatable<T> n'est pas un must, mais serait sympa si vous en avez un.

public class Entity : IEquatable<Entity>
{
    public bool Equals(Entity other)
    {
        if (ReferenceEquals(this, other))
            return true;

        if (ReferenceEquals(null, other))
            return false;

        //if your below implementation will involve objects of derived classes, then do a 
        //GetType == other.GetType comparison
        throw new NotImplementedException("Your equality check here...");
    }

    public override bool Equals(object obj)
    {
        return Equals(obj as Entity);
    }

    public override int GetHashCode()
    {
        throw new NotImplementedException("Your lightweight hashing algorithm, consistent with Equals method, here...");
    }
}

Avec la valeur sémantique (des objets immuables)

C'est la partie la plus délicate. Peut obtenir facilement foiré si pas pris en charge..

1) Remplacer Equals et GetHashCode.

2) Surcharge == et != pour correspondre à Equals. Assurez-vous qu'il fonctionne pour les valeurs null.

2) la mise en Œuvre de IEquatable<T> n'est pas un must, mais serait sympa si vous en avez un.

public class Entity : IEquatable<Entity>
{
    public bool Equals(Entity other)
    {
        if (ReferenceEquals(this, other))
            return true;

        if (ReferenceEquals(null, other))
            return false;

        //if your below implementation will involve objects of derived classes, then do a 
        //GetType == other.GetType comparison
        throw new NotImplementedException("Your equality check here...");
    }

    public override bool Equals(object obj)
    {
        return Equals(obj as Entity);
    }

    public static bool operator ==(Entity e1, Entity e2)
    {
        if (ReferenceEquals(e1, null))
            return ReferenceEquals(e2, null);

        return e1.Equals(e2);
    }

    public static bool operator !=(Entity e1, Entity e2)
    {
        return !(e1 == e2);
    }

    public override int GetHashCode()
    {
        throw new NotImplementedException("Your lightweight hashing algorithm, consistent with Equals method, here...");
    }
}

Prendre soin de voir comment elle devait s'en sortent si votre classe peut être hérité, dans de tels cas, vous aurez à déterminer si un objet de classe de base peut être égal à un objet de classe dérivée. Idéalement, si aucun objet de la classe dérivée est utilisée pour l'égalité de la vérification, puis une classe de base peut être égale à une classe dérivée de l'instance et, dans ce cas, il n'est pas nécessaire de vérifier Type l'égalité dans le générique Equals de la classe de base.

En général, prendre soin de ne pas dupliquer le code. J'aurais pu faire un générique classe de base abstraite (IEqualizable<T> ou presque) comme un modèle pour permettre la ré-utilisation plus facile, mais malheureusement, en C# qui ne m'empêche de dériver de classes supplémentaires.

J'ai trouvé une autre référence, c'est l' .NET Type Anonyme de mise en œuvre. Pour un type anonyme avec un int et un double que les propriétés j'ai démonté le code C# suivant:

public class f__AnonymousType0
{
    //Fields
    public int A { get; }
    public double B { get; }

    //Methods
    public override bool Equals(object value)
    {
        var type = value as f__AnonymousType0;
        return (((type != null)
            && EqualityComparer<int>.Default.Equals(this.A, type.A))
            && EqualityComparer<double>.Default.Equals(this.B, type.B));
    }

    public override int GetHashCode()
    {
        int num = -1134271262;
        num = (-1521134295 * num) + EqualityComparer<int>.Default.GetHashCode(this.A);
        return ((-1521134295 * num) + EqualityComparer<double>.Default.GetHashCode(this.B);
    }

    public override string ToString()
    {
        StringBuilder builder = new StringBuilder();
        builder.Append("{ A = ");
        builder.Append(this.A);
        builder.Append(", B = ");
        builder.Append(this.B);
        builder.Append(" }");
        return builder.ToString();
    }
}