surcharge == (et! =, Bien sûr) opérateur, puis-je contourner == pour déterminer si l'objet est nul

Question

lorsque j'essaie de surcharger l'opérateur == et! = En C#, et remplacer Equal comme recommandé, j'ai trouvé Je n'ai aucun moyen de distinguer un objet normal et null. Par exemple, j'ai défini un complexe de classe.

public static bool operator ==(Complex lhs, Complex rhs) 
{ 
    return lhs.Equals(rhs); 
} 

public static bool operator !=(Complex lhs, Complex rhs) 
{ 
    return !lhs.Equals(rhs); 
} 

public override bool Equals(object obj) 
{ 
    if (obj is Complex) 
    { 
     return (((Complex)obj).Real == this.Real && 
        ((Complex)obj).Imaginary == this.Imaginary); 
    } 
    else 
    { 
     return false; 
    } 
} 

Mais quand je veux utiliser

if (temp == null) 

quand la température est vraiment nulle, une exception se produit. Et je ne peux pas utiliser == pour déterminer si le lhs est nul, ce qui provoquera une boucle infinie.

Que dois-je faire dans cette situation?

Une façon dont je peux penser est à nous quelque chose comme Class.Equal (objet, objet) (si elle existe) pour contourner le == lorsque je fais la vérification.

Quelle est la manière normale de résoudre le problème?

Merci.

Answer 1

Vous devriez envisager d'utiliser la méthode statique Equals dans les opérateurs de surcharge (qui appellera l'instance méthode Equals):

public static bool operator ==(Complex lhs, Complex rhs) 
{ 
    return Equals(lhs, rhs); 
} 

public static bool operator !=(Complex lhs, Complex rhs) 
{ 
    return !Equals(lhs, rhs); 
} 

Remarque: Vous pouvez également vérifier null dans la méthode Equals.

Vous pouvez également lire le Object.Equals Topic on MSDN, qui est une excellente source d'échantillons.

Answer 2

Vous pouvez utiliser ce qui suit en haut de votre Equals Prioritaire:

if (Object.ReferenceEquals(obj, null)) 
    return false; 

L'exception que vous obtenez est probablement un StackOverflowException parce que votre opérateur == provoquera une récursion infinie.

EDIT:

Si complexe est un struct vous ne devriez pas avoir de problèmes avec NullReferenceExceptions. ! Si complexe est une classe, vous pouvez modifier l'implémentation du == et l'opérateur = Surcharges pour éviter l'exception (Laurent Etiemble a déjà souligné dans sa réponse):

public static bool operator ==(Complex lhs, Complex rhs) 
{ 
    return Equals(lhs, rhs); 
} 

public static bool operator !=(Complex lhs, Complex rhs) 
{ 
    return !Equals(lhs, rhs); 
} 

Answer 3

Il y a une meilleure approche puis en utilisant les opérateurs is et cast:

Complex c = obj as Complex; 
return (c != null) && (c.Real == this.Real) && (c.Imaginary == this.Imaginary); 

Voici un test rapide inquiétant Equals remplacement de l'opérateur et la comparaison avec null:

class Complex 
{ 
    public override bool Equals(object obj) 
    { 
     if (obj is Complex) 
     { 
      return true; 
     } 
     else 
     { 
      return false; 
     } 
    } 
} 

Debugging n'étape pas en Corps de l'opérateur:

var b = (new Complex() == new Complex()); 

Answer 4

public static bool operator ==(Complex lhs, Complex rhs) 
{ 
    if (Object.ReferenceEquals(lhs, null)) 
    { 
     return Object.ReferenceEquals(rhs, null); 
    } 

    return lhs.Equals(rhs); 
} 

public static bool operator !=(Complex lhs, Complex rhs) 
{ 
    return !(lhs == rhs); 
} 

test de l'unité de l'homme pauvre

Action<Complex, Complex> tester = (left, right) => 
{ 
    Console.WriteLine(left == right); 
    Console.WriteLine(left != right); 
    Console.WriteLine(left == null); 
    Console.WriteLine(left != null); 
    Console.WriteLine("---"); 
}; 

tester(new Complex(), new Complex()); 
tester(null, new Complex()); 
tester(null, null); 
tester(new Complex(), null); 

Answer 5

Je pense que vous tester pour null qui devraient dans la mise en œuvre de l'opérateur ==. Sinon, quand lhs est nul, vous appelleriez Complex (null). Equals (je ne sais pas pour C#, mais en Java ce serait une exception Nullpointer)

Pour tester null, je suggère quelque chose comme:

if (null == lhs && null == rhs) return true 
else if (null == lhs) return false 
else return lhs.Equals(rhs); 

Ainsi, Object.Equals sera appelé pour toutes les comparaisons == ci-dessus.