Surcharge de Equals() et == qui accepte null ?

Bonjour,

Je suis sur un truc con qui me laisse perplexe...

Mettons une classe Eleve :

Code:

1
2
3
4
5
6
7
 
classe Eleve
{
    public int Id {get; set; }
    public string Nom { get; set; }
    public string Prenom { get; set; }
}

Je souhaite mettre en place une comparaison qui permette de comparer deux élèves en ne se basant que sur leur identifiant.

J'ai donc écrit :

Code:

1
2
3
4
5
6
7
8
9
10
11
 
        public override bool Equals(object autre)
        {
            if (autre == null) return false; // Une instance n'est pas nulle et est donc différente de null
 
            Eleve autreEleve = autre as Eleve;
 
            if (autreEleve == null) return false; // L'autre instance n'est pas un élève, elle est forcément différente
 
            return Id == autreEleve.Id;
        }

Afin que ce soit plus simple à lire, je surcharge == et != :

Code:

1
2
3
4
5
6
7
8
9
10
 
        public static bool operator ==(Eleve id1, Eleve id2)
        {
                return id1.Equals(id2);
        }
 
        public static bool operator !=(object id1, CrmID id2)
        {
            return !id1.Equals(id2);
        }

Ca marche très bien tant que je compare des instances.

Sauf que dans mon code, j'ai souvent ce genre de choses :

Code:

1
2
3
4
5
6
7
 
Eleve eleve = GetEleve(); // Peut renvoyer null
 
if (eleve != null)
{
    // Fait un truc
}

Et là c'est le drame !

En effet, id1 est null, donc null.Equals(null) plante.

J'ai donc tenté de modifier le code en :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
        public static bool operator ==(Eleve id1, Eleve id2)
        {
            if (id1 != null)
            {
                        return id1.Equals(id2);
            }
            return false;
        }
 
        public static bool operator !=(Eleve id1, Eleve id2)
        {
            if (id1 != null)
            {
                        return !id1.Equals(id2);
            }
            return true;
        }

Sauf que là le id1 != null dans l'opérateur != part en boucle et ça plante.

Je feinte...

Code:

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
 
        public static bool operator ==(object id1, Eleve id2)
        {
            if (id1 is Eleve)
            {
                if (id1 != null)
                {
                    Eleve me = id1 as Eleve;
                    return me.Equals(id2);
                }
                else
                {
                    return id2 == null;
                }
            }
            else
            {
                return false;
            }
        }
 
        public static bool operator !=(object id1, Eleve id2)
        {
            return !(id1 == id2);
        }

Mais ça plante sur le id2 == null car on part à nouveau en boucle infinie.

Lol, et vu que j'adore trouver des solutions en posant mes question, voici la feinte ultime ! :D

Code:

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
 
public override bool Equals(object other)
        {
            if (ReferenceEquals(this, other))
            {
                return true;
            }
            else
            {
                Eleve otherID = other as Eleve;
                if (otherID is null) return false;
                else return Id == other.Id;
            }
        }
 
        public static bool operator ==(object id1, CrmID id2)
        {
            if (id1 is null)
            {
                return id2 is null;
            }
            else
            {
                return id1.Equals(id2);
            }
        }
 
        public static bool operator !=(object id1, CrmID id2)
        {
            return !(id1 == id2);
        }

Et plus généralement... toujours utiliser "is null" plutôt que "== null", ça évite de s'emmerder pour rien.