Renvoie une variable dès qu'elle est définie sur une certaine valeur. Egalité de surcharge

Question

Je surcharge la méthode Egalité pour la comparaison de valeurs et je me demandais s'il existait un moyen propre de renvoyer false dès que l'une des comparaisons de valeur retourne false. Par exemple, voici l'idée de base:

public class MyClass 
{ 
    private int _valOne; 
    private int _valTwo; 
    private int _valThree; 

    public MyClass(int valOne, int valTwo, int valThree) 
    { 
     _valOne = valOne; 
     _valTwo = valTwo; 
     _valThree = valThree; 
    } 

    public override bool Equals(object obj) 
    { 
     // If the object is null return false 
     if (obj == null) 
     { 
      return false; 
     } 

     // If the object is not of MyClass type return false 
     MyClass myClass = obj as MyClass; 
     if (myClass == null) 
     { 
      return false; 
     } 

     // Now compare all the field values 
     bool areEqual = false; 
     areEqual = (this._valOne == myClass._valOne); 
     areEqual = (this._valTwo == myClass._valTwo); 
     areEqual = (this._valThree == myClass._valThree); 

     return areEqual; 
    } 
} 

Dites les _valOne « s ne sont pas égaux. Le moyen le plus efficace de comparer est de retourner false dès que l'on sait que deux valeurs ne sont pas égales. Quelque chose comme ce qui suit ...

 // Now compare all the field values 
     bool areEqual = false; 

     areEqual = (this._valOne == myClass._valOne); 
     if (!areEqual) 
     { 
      return false; 
     } 

     areEqual = (this._valTwo == myClass._valTwo); 
     if (!areEqual) 
     { 
      return false; 
     } 

     areEqual = (this._valThree == myClass._valThree); 

     return areEqual; 

Alors maintenant, après la comparaison des _valOne s pas plus de comparaisons de valeur sont faites. Cela semble très répétitif, maladroit, et (surtout) horrible pour la lisibilité. Je veux savoir s'il y a moyen de réduire ce code de la même manière sans utiliser l'opérateur & &.

Answer 1

Utilisez un et l'état:

areEqual = (this._valOne == myClass._valOne) 
    && (this._valTwo == myClass._valTwo) 
    && (this._valThree == myClass._valThree); 

& & implémente un court-circuit par défaut.

Answer 2

Vous pouvez profiter de l'opérateur nature de la logique (&&) short-circuiting, comme ceci:

return this._valOne == myClass._valOne 
    && this._valTwo == myClass._valTwo 
    && this._valThree == myClass._valThree; 

Dès que l'une des comparaisons est évaluée à faux, la condition entière est évaluée à false. Si tous les trois sont vrais, la condition renvoie true.

Answer 3

Une autre façon pourrait être de le faire:

if (this._valOne != myClass._valOne) 
     return false; 
    if (this._valTwo != myClass._valTwo) 
     return false; 
    if (this._valThree != myClass._valThree) 
     return false; 
    return true; 

Une question de choix que je suppose. Je pense que le & & un est plus lisible ..