Discussion :

[scheme]

Bonjour à tous, j'aimerais savoir pourquoi, avec ce code, la méthode Equals me renvoie false. A part les références, je ne vois pas ce qui diffère entre ces deux objets, et je pensais que c'est la méthode ReferenceEquals qui comparent les références, pas Equals. Merci d'avance pour vos lumières

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
List<int> integerList = new List<int>();
List<int> integerList2 = new List<int>();
integerList.Add(1);
integerList2.Add(1);
Console.Out.WriteLine(integerList.Equals(integerList2));

[Invité]

La méthode te renverra toujours False du fait que List<int> est un type référence donc ta classe List<int> n'implémentant pas ou du moins n'ayant pas rédéfinie la méthode Equals, elle utilisera la méthode du même nom de sa classe de base qui elle vérifie si les deux objets integerList et integerList2 partagent la même référence.

Tu dois pour pouvoir renvoyer True dans ton cas actuel, créer une classe dérivant de List<int> et redéfinir (à ta propre sauce) la méthode Equals.

[tomlev]

L'implémentation par défaut de Equals teste l'égalité des références, et comme Equals n'est pas redéfinie dans List<T>, c'est ce qui est utilisé ici.

Pour tester si deux listes sont "égales", tu peux utiliser la méthode d'extension SequenceEqual de Linq :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Console.Out.WriteLine(integerList.SequenceEqual(integerList2));

(tient compte de l'ordre)

Pour ne pas tenir compte de l'ordre, tu peux faire quelque chose comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Console.Out.WriteLine(!integerList.Except(integerList2).Any());

[Invité]

+1000.

Je ne suis pas l'initiateur du thread mais j'ai remarqué qu'avec tes réponses, j'apprend toujours des trucs.

J'étais parti, avec ma première réponse, créer une classe personnalisée dérivant de List<T> et redéfinissant la méthode Equals. Bref j'allais réinventer la roue quoi.

Merci.

[calagan99]

Tomlev : tout comme h2s84, quand j'ai vu la demande j'ai pensé à redéfinir Equals. Et tout comme h2s84, ta méthode à le mérite d'utiliser l'existant.
Merci pour ce tuyau.

[tomlev]

Au fait, pour que ça fonctionne, il faut que les éléments de la liste redéfinissent eux-même Equals, sinon ils sont comparés par référence. On peut aussi implémenter IEquatable<T>, ou encore fournir un IEqualityComparer<T> en paramètre de SequenceEqual ou Except

[scheme]

Merci beaucoup de vos conseils

J'ai pris comme exemple une list<int> car ça me semblait assez simple. Dans la pratique je dois comparer 2 classes en redéfinissant la méthode equals. La difficulté est que je ne dois pas comparer membre à membre mais que je dois faire appel à la réflexivité. Du coup j'ai écris ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public override bool Equals(object objet)
{
    PropertyInfo[] propertiesThis = this.GetType().GetProperties();
    PropertyInfo[] propertiesObj = objet.GetType().GetProperties();
 
    if (propertiesThis.Length == propertiesObj.Length)
    {
        for (int i = 0; i < propertiesThis.Length; i++)
        {
            if (!propertiesThis[i].GetValue(this, null).Equals(propertiesObj[i].GetValue(objet, null)))
            {
                return false;
            }
        }
        return true;
    }
    return false;
}

Et bien sûr ça ne fonctionne pas... Je précise que dans cette classe j'ai une classe imbriquée et plusieurs listes d'objets différents (dont une qui contient des instances de la classe imbriquée). Ces listes sont bien déclarées au moyen de propriétés

A votre avis, existe-il de comparer les classes de cette manière, ou doit-on obligatoirement passer par la comparaison membre à membre ?

[tomlev]

Pourquoi tu fais comme ça, tu connais pas à l'avance le type des objets à comparer ?

[scheme]

C'est pour un exercice en fait. Au début j'avais comparé membre à membre et forcément ça marche bien, et comme j'avais de l'avance mon prof m'a dit d'essayer de faire comme ça. Donc j'essaie et ça marche pas des masses pour l'instant^^

Si je connais les types des objets, mais c'est pour pas énumérer chaque membre quoi

[tomlev]

Si je connais les types des objets, mais c'est pour pas énumérer chaque membre quoi

D'une manière générale, garde quand même à l'esprit qu'utiliser la réflexion est BEAUCOUP plus lent que de comparer les membres directement.

Cela dit, c'est effectivement un exercice intéressant...

Tu n'as pas précisé en quoi ça ne marchait pas : exception ? pas le résultat attendu ? A mon avis, la principale raison pour laquelle ton code ne fonctionne pas, c'est le cas où une propriété de l'objet courant (this) est nulle. Dans ce cas l'appel à Equals cause une NullReferenceException.

Donc il faut gérer le cas où la valeur de la propriété est nulle, et plutôt que de réinventer la roue, autant utiliser ce qui existe déjà : la méthode statique objet.Equals (celle qui prend 2 paramètres)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
            object valueThis = propertiesThis[i].GetValue(this, null);
            object valueObj = propertiesObj[i].GetValue(objet, null);
            if (!object.Equals(valueThis, valueObj))
            {
                return false;
            }

[scheme]

Ok mais quelle est la différence avec mon code ?

En gros j'ai une classe qui une structure qui ressemble à ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class A
{
    public int attributA { get; set; }
 
    public class B
    {
        public int attributB { get; set; }
 
        public B(int attrB)
        {
            attributB = attrB;
        }
    }
 
    public List<B> listOfB { get; set; }
    public List<int> listOfInt { get; set; }
 
    public A(int attrA)
    {
        attributA = attrA;
        listOfB = new List<B>();
        listOfInt = new List<int>();
    }
}

Donc j'ai surchargé la méthode Equals, et ça plante quand ça compare la liste de B. C'est vrai que je n'ai pas géré d'exception... C'est le fait que ce soit une liste ou une liste d'objets d'une classe imbriquée qui pose problème ?

[tomlev]

ça plante quand ça compare la liste de B.

"Ca plante", c'est à dire ? Il y a une erreur ? Ca fait pas ce que tu veux ?

[scheme]

La comparaison me renvoie false quand ça "passe" sur la liste de B, alors que ça devrait renvoyer vrai (a moins que equals compare les références des listes, auquel cas c'est réglé :s)

[tomlev]

La comparaison me renvoie false quand ça "passe" sur la liste de B, alors que ça devrait renvoyer vrai (a moins que equals compare les références des listes, auquel cas c'est réglé :s)

Ca compare les références, donc c'est normal... chaque instance de A a sa propre instance de List<B>.