Discussion :

[bornetjulien]

Bonjour j'ai une question.
Voila je dois crée une pseudo couche d'accès à des données stockées dans des fichiers XML. L'idée c'est que tous ces objets possèdent un identifiant. Je voudrais donc implémenter dans une classe de base (qui sera abstraite) un certain nombre de méthode dont la méthode Equals de l'interface IEquatable.

Ainsi lorsuqe je manipulerai des liste d'objets héritant de cette classe de base je pourrais utiliser la méthode contains.

Mon problème est que visiblement la méthode Equals (implémenté dans la classe de base) ne semble pas être appeler lors de l'appel d'un contains. Y a t'il moyen d'y parvenir. Suis-je condamné à overridé la méthode equals dans toutes mes classes héritant de la classe de base.

D'avance merci .


PS : comme un petit exemple vaut mieux qu'on long discours voici un exemple

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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
public abstract class BaseEntity : IEquatable<EDRBaseEntity>
    {
        protected string _ID;
 
        public string GetID()
        {
            return _ID;
        }
 
        #region IEquatable<EDRBaseEntity> Membres
 
        public bool Equals(EDRBaseEntity other)
        {
            return _ID.Equals(other.GetID());
        }
 
        #endregion
    }
 
 
***********************************************
 
    public class EntityById : BaseEntity
    {
        #region Propriétés
        [XmlAttribute]
        public string ID
        {
            get { return _ID; }
            set { _ID = value; }
        }
        #endregion
 
        #region Constructeurs
        public EntityById()
        {
            _ID = String.Empty;
        }
 
        public EntityById(string id)
        {
            _ID = id;
        }
        #endregion
 
        #region Méthodes
        public Entity GetEntity()
        {
            if (!String.IsNullOrEmpty(_ID))
            {
                return Entity.GetEntityById(_ID);
            }
            else
            {
                return null;
            }
        }
        #endregion
    }
 
 
************************************************
 
foreach (EntityById entityById in collection)
{ 
     if (refList.Contains(entityById))
     {
           ...
     }
}

[tomlev]

Selon le type de collection, l'implémentation de Contains peut varier... Par exemple, une List<T> utilise comme comparateur Comparer<T>.Default, qui lui-même utilise l'interface IComparable<T>. C'est donc cette interface qu'il faut implémenter, et non IEquatable<T>.

Sinon, tu peux aussi utiliser la méthode d'extension Contains, qui peut prendre en paramètre un IEqualityComparer<T>

[StormimOn]

Selon le type de collection, l'implémentation de Contains peut varier... Par exemple, une List<T> utilise comme comparateur Comparer<T>.Default, qui lui-même utilise l'interface IComparable<T>. C'est donc cette interface qu'il faut implémenter, et non IEquatable<T>.

IEquatable<T> est utilisé avec le Contains, IndexOf, ... sur une List<T> comme sur d'autres. Si la classe implémente IEquatable<T> alors le comparateur par défaut se base dessus.

Sinon l'implémentation de IEquatable<T> demande de toute façon de redéfinir object.Equals (qui appellera IEquatable<T>.Equals histoire de bien faire) et object.GetHashCode sur l'objet afin de rester cohérent. On a ainsi le bon comportement quelle que soit la méthode appelée (object.Equals ou IEquatable<T>.Equals).

[tomlev]

IEquatable<T> est utilisé avec le Contains, IndexOf, ... sur une List<T> comme sur d'autres. Si la classe implémente IEquatable<T> alors le comparateur par défaut se base dessus.

au temps pour moi... c'est bizarre, j'avais vérifié sur MSDN, et en regardant de nouveau je trouve plus la même chose

[MetalGeek]

Salut,
et est-ce que les surchargse des méthodes object.Equals() + object.GetHashCode() ne font pas l'affaire ? Ou alors j'ai lu trop vite ? Parce qu'il me semble qu'elles sont appelées avant les autres Equals<T> et Cie non ?