IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C# Discussion :

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


Sujet :

C#

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Expert confirmé
    Avatar de StringBuilder
    Homme Profil pro
    Chef de projets
    Inscrit en
    Février 2010
    Messages
    4 197
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 46
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Activité : Chef de projets
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Février 2010
    Messages : 4 197
    Billets dans le blog
    1
    Par défaut Surcharge de Equals() et == qui accepte null ?
    Bonjour,

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

    Mettons une classe Eleve :
    Code csharp : Sélectionner tout - Visualiser dans une fenêtre à part
    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 csharp : Sélectionner tout - Visualiser dans une fenêtre à part
    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 csharp : Sélectionner tout - Visualiser dans une fenêtre à part
    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 csharp : Sélectionner tout - Visualiser dans une fenêtre à part
    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 csharp : 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 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 csharp : 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
     
            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 !
    Code csharp : 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
     
    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.

  2. #2
    Expert confirmé
    Avatar de popo
    Homme Profil pro
    Analyste programmeur Delphi / C#
    Inscrit en
    Mars 2005
    Messages
    2 999
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Activité : Analyste programmeur Delphi / C#
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Mars 2005
    Messages : 2 999
    Par défaut
    C'est en effet la méthode recommandée par la MSDN.

    https://web.archive.org/web/20170427...(v=vs.80).aspx

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Réponses: 3
    Dernier message: 12/12/2007, 15h35
  2. [SPL] Rewind() qui renvoie NULL
    Par fadeninev dans le forum Bibliothèques et frameworks
    Réponses: 6
    Dernier message: 06/06/2006, 15h44
  3. Réponses: 5
    Dernier message: 09/05/2006, 13h27
  4. un input qui accepte que les chiffres ?
    Par VerrNum dans le forum Général JavaScript
    Réponses: 5
    Dernier message: 27/03/2006, 13h28
  5. [JDBC]Un new qui renvoie null...
    Par Ditch dans le forum JDBC
    Réponses: 4
    Dernier message: 03/01/2005, 13h14

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo