Lors de la surcharge de l'opérateur ==
en C#, évitez la récursion infinie lorsque vous traitez des valeurs nulles
Il existe un problème courant lors de la gestion des valeurs nulles lors de la surcharge de l'opérateur ==
en C#. Considérez l'extrait de code suivant :
Foo foo1 = null; Foo foo2 = new Foo(); Assert.IsFalse(foo1 == foo2); public static bool operator ==(Foo foo1, Foo foo2) { if (foo1 == null) return foo2 == null; // 潜在的无限递归 return foo1.Equals(foo2); }
Dans ce cas, la surcharge ==
utilise l'opérateur ==
lui-même pour vérifier les valeurs nulles. Cela peut conduire à une récursivité infinie car si foo1
est vide, foo2 == null
sera également évalué comme vide, provoquant l'appel de la méthode ==
à l'infini.
Pour éviter ce problème, la surcharge ==
doit utiliser ReferenceEquals
au lieu de ==
pour vérifier les valeurs nulles. ReferenceEquals
n'effectue pas d'appels récursifs, il peut donc déterminer en toute sécurité si un ou deux objets sont nuls sans provoquer de récursion infinie. Le code corrigé est le suivant :
Foo foo1 = null; Foo foo2 = new Foo(); Assert.IsFalse(foo1 == foo2); public static bool operator ==(Foo foo1, Foo foo2) { if (object.ReferenceEquals(foo1, null)) return object.ReferenceEquals(foo2, null); return foo1.Equals(foo2); }
En modifiant la vérification nulle pour utiliser ReferenceEquals
, la surcharge ==
gère efficacement les valeurs nulles sans déclencher une récursion infinie. Il compare correctement les valeurs nulles de Equals
et foo1
avant de passer à la comparaison foo2
. Cette approche garantit que le comportement de l'opérateur est toujours cohérent et fiable, même en présence de valeurs nulles.
Cette explication révisée clarifie le problème et la solution de manière plus concise. L'image reste dans son format et son emplacement d'origine.
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!