Comment remplacer l'opérateur égal == pour une interface en C #?

J'ai défini l'interface suivante

public interface IHaveAProblem
{
    string Issue { get; set; }
}

Et ici est la mise en œuvre de la IHaveAProblem

public class SomeProblem : IHaveAProblem
{
    public string Issue { get; set; }

    public override bool Equals(object obj)
    {
        SomeProblem otherObj = obj as SomeProblem;

        if (otherObj == null)
        {
            return false;
        }

        return this.Issue == otherObj.Issue;
    }

    public override int GetHashCode()
    {
        return base.GetHashCode();
    }

    public static bool operator ==(SomeProblem rhs, SomeProblem lhs)
    {
        //Null check
        if (Object.ReferenceEquals(rhs, null) || Object.ReferenceEquals(lhs, null))
        {
            if (Object.ReferenceEquals(rhs, null) && Object.ReferenceEquals(lhs, null))
            {
                //Both are null.  They do equal each other
                return true;
            }

            //Only 1 is null the other is not so they do not equal
            return false;
        }

        return rhs.Equals(lhs);
    }

    public static bool operator !=(SomeProblem rhs, SomeProblem lhs)
    {
        //Null check
        if (Object.ReferenceEquals(rhs, null) || Object.ReferenceEquals(lhs, null))
        {
            if (Object.ReferenceEquals(rhs, null) && Object.ReferenceEquals(lhs, null))
            {
                //Both are null.  They do equal each other
                return false;
            }

            //Only 1 is null the other is not so they do not equal
            return true;
        }

        return !rhs.Equals(lhs);
    }
}

Lorsque j'utilise l'objet que je peut obtenir des résultats corrects pour l' == comparer.

SomeProblem firstTest = new SomeProblem()
    {
        Issue = "Hello World"
    };

SomeProblem secondTest = new SomeProblem()
    {
        Issue = "Hello World"
    };

//This is true
bool result = firstTest == secondTest;

Cependant lorsque j'essaie de comparer les interfaces qu'il est en train de faire un mémoire de comparer plutôt que l'opérateur == sur SomeProblem

IHaveAProblem firstProblem = new SomeProblem()
    {
        Issue = "Hello World"
    };

IHaveAProblem secondProblem = new SomeProblem()
    {
        Issue = "Hello World"
    };

Est-il possible d'avoir l'interface de l'utilisation de l' == sur SomeProblem plutôt que d'une mémoire de comparer?

Je sais que je peux faire un firstProblem.Equals(secondProblem) et obtenir le bon résultat, mais je suis entrain de créer un cadre de travail et je sais pas comment il est utilisé dans la fin. J'ai pensé == fonctionnerait correctement.

source d'informationauteur David Basarab

  1. 23

    L'opérateur == est statique. Vous ne pouvez pas définir des méthodes statiques pour les interfaces en C#. Aussi, pour tous les opérateurs au moins un des types d'argument doit être du même type que la classe qu'il est défini dans l', donc: Pas de surcharge d'opérateur pour les interfaces 🙁

    Ce que vous POUVEZ faire est d'utiliser une classe abstraite au lieu - et de définir l'opérateur. Encore une fois, l'opérateur ne peut PAS être virtuel (depuis les méthodes statiques ne peuvent pas être virtuel...)

    [Édité, raison pour voir les commentaires.]

  2. 4

    IIRC (et j'ai peut-être tort ici), C# interfaces ne permet pas la surcharge d'opérateur.

    Mais dans ce cas ce n'est pas grave. L'opérateur==, normalement, les cartes de référence de l'égalité. Il semble que vous voulez de la valeur de l'égalité, et qui signifie que vous voulez forcer à remplacer la .Equals() (et par conséquent aussi .GetHashCode()) de fonctions. Pour cela, vous devez avoir votre interface hérite de IEquatable().

  3. 2

    J'connaître, c'est une vieille question, mais tous les exemples montrent comment comparer deux instances de classe, et pas l'un des points comment comparer deux interface instances.

    Dans certains cas, c'est la plus secs de comparer les interfaces.

    public interface IHaveAProblem
{
    string Issue { get; set; }
}

public class IHaveAProblemComparer : IComparer<IHaveAProblem>, IEqualityComparer<IHaveAProblem>
{
    public int Compare(IHaveAProblem x, IHaveAProblem y)
    {
        return string.Compare(x.Issue, y.Issue);
    }

    public bool Equals(IHaveAProblem x, IHaveAProblem y)
    {
        return string.Equals(x.Issue, y.Issue);
    }

    public int GetHashCode(IHaveAProblem obj)
    {
        return obj.GetHashCode();
    }
}

    Utilisation?

    IHaveAProblemComparer comparer = new IHaveAProblemComparer();

List<IHaveAProblem> myListOfInterfaces = GetSomeIHaveAProblemObjects();
myListOfInterfaces.Sort(comparer); //items ordered by Issue

IHaveAProblem obj1 = new SomeProblemTypeA() { Issue = "Example1" };
IHaveAProblem obj2 = new SomeProblemTypeB() { Issue = "Example2" };

bool areEquals = comparer.Equals(obj1, obj2); //False
  4. 0

    Avez-vous essayé de mise en œuvre de IComparable?

    Comme ceci:

    public interface IHaveAProblem : IComparable
{
    string Issue { get; set; }
}

    Puis dans la mise en œuvre de la classe:

    public class SomeProblem : IHaveAProblem
{
    public string Issue { get; set; }

    ...

    public int CompareTo(object obj)
    {
        return Issue.CompareTo(((SomeProblem)obj).Issue);
    }
}

    Noter que, cela ne fonctionne que lorsque vous comparez les deux instances de SomeProblem, mais pas toutes les autres implémentations de la IHaveAProblem interface.

    Ne sais pas si il pourrait se produire une NullReferenceException.