C# Come trovare se due oggetti sono uguali

Question

Ho bisogno di sapere il modo migliore per confrontare due oggetti e scoprire se ci sono uguali. Sto sovrascrivendo sia GethashCode che Equals. Quindi una classe base si presenta come:

public class Test 
{ 
    public int Value { get; set; } 
    public string String1 { get; set; } 
    public string String2 { get; set; } 

    public override int GetHashCode() 
    { 
     return Value^String1.GetHashCode()^String2.GetHashCode(); 
    } 

    public override bool Equals(object obj) 
    { 
     return GetHashCode() == obj.GetHashCode(); 
    } 
} 

Così, per scopi di test ho creato due oggetti:

Test t = new Test() 
{ 
    Value = 1, 
    String1 ="One", 
    String2 = "One" 
}; 

Test t2 = new Test() 
{ 
    Value = 1, 
    String1 = "Two", 
    String2 = "Two" 
}; 

bool areEqual = t.Equals(t2); 

a testare questa areEqual ritorna vero evento se entrambi gli oggetti sono diversi. Mi rendo conto che ciò è dovuto al fatto che String1 e String2 hanno lo stesso valore in ogni oggetto e quindi si annullano a vicenda quando si esegue l'hashing.

C'è un modo migliore di utilizzare l'oggetto hashing che risolverà il problema?

Answer 1

Il tuo attuale metodo di uguaglianza è rotto - ci sono più valori di possibili codici hash. È del tutto ragionevole (e atteso) che di tanto in tanto si disponga di valori non uguali ma che diano lo stesso hash. Uguale dovrebbe controllare i valori effettivi:

public override bool Equals(object obj) 
{ 
    Test test = obj as Test; 
    if (obj == null) 
    { 
     return false; 
    } 
    return Value == test.Value && 
     String1 == test.String1 && 
     String2 == test.String2; 
} 

Poche cose da notare:

• Il tuo modo di generare il codice hash darà lo stesso valore per qualsiasi fisso Value se String1 e String2 sono il stesso; esploderà anche se String1 o String2 è nullo. Questo è un aspetto sfortunato dell'uso di XOR per l'hashing. Io preferisco qualcosa di simile:

  // Put this extension method in a utility class somewhere 
  public static int SafeGetHashCode<T>(this T value) where T : class 
  { 
      return value == null ? 0 : value.GetHashCode(); 
  } 
  
  // and this in your actual class 
  public override int GetHashCode() 
  { 
      int hash = 19; 
      hash = hash * 31 + Value; 
      hash = hash * 31 + String1.SafeGetHashCode(); 
      hash = hash * 31 + String2.SafeGetHashCode(); 
      return hash; 
  } 
  

• In generale, l'uguaglianza diventa difficile quando l'ereditarietà viene coinvolto. Puoi prendere in considerazione di sigillare la tua classe.

• Si consiglia inoltre di implementare IEquatable<Test>

Answer 2

tuo Equals non è corretto - che dovrebbe definire cosa significa per due cose siano uguali - e avere lo stesso hash-codice non uguaglianza media (tuttavia, un diverso codice hash fa significa non uguaglianza). Se "uguaglianza" significa "entrambe le stringhe sono uguali a coppie", quindi test.

Re un hash migliore; xor è noto per questo, dato che è banale ottenere 0 da xor un valore con se stesso. Un approccio migliore potrebbe essere qualcosa di simile:

int i = 0x65407627; 
i = (i * -1521134295) + Value.GetHashCode(); 
i = (i * -1521134295) + (String1 == null ? 0 : String1.GetHashCode()); 
i = (i * -1521134295) + (String2 == null ? 0 : String2.GetHashCode()); 
return i; 

Answer 3

Per due oggetti, l'uguaglianza oggetto implica hash uguaglianza codice, tuttavia , uguaglianza codice hash non implica l'uguaglianza oggetto. Da Object.GetHashCode su MSDN:

Una funzione hash deve avere le seguenti proprietà :

Se due oggetti risultano uguali, il metodo GetHashCode per ogni oggetto deve restituire lo stesso valore.Tuttavia, se due oggetti non vengono confrontati come uguale a , i due metodi GetHashCode per l'oggetto non devono restituire valori diversi .

In altre parole, il tuo Equals è stato scritto male. Dovrebbe essere qualcosa di simile:

public override bool Equals(object obj) 
{ 
    Test other = obj as Test; 
    if (other == null) 
     return false; 

    return (Value == other.Value) 
     && (String1 == other.String1) 
     && (String2 == other.String2); 
} 

GetHashCode è un bene per le collezioni (come Dictionary<K, V>) per determinare rapidamente l'uguaglianza approssimativa. Equals serve per confrontare se due oggetti sono realmente uguali.

Answer 4

In aggiunta a tutte le grandi risposte che vi consiglio di leggere questo article da Alois Kraus

Answer 5

sarebbe non una funzione è sempre uguale testare solo contro lo stesso tipo, non dovrebbe essere:

//override 
    public bool Equals(Test other)//(object obj) 
    { 
     //return GetHashCode() == obj.GetHashCode(); 
     return (Value == other.Value) && 
       (String1 == other.String1) && 
       (String2 == other.String2); 
    } 

saluti Oops

Answer 6

Bene !!!!! (MSDN)

Answer 7

semplice

Object.Equals(obj1, obj2); 

Answer 8

Si potrebbe puntate i due oggetti a JSON, quindi confrontare le due stringhe per vedere se sono gli stessi.

Per esempio

JavaSriptSerializer serialiser = new JavaScriptSerializer(); 

string t1String = serialiser.Serialize(t); 
string t2String = serialiser.Serialize(t2); 

if(t1String == t2String) 
    return true; //they are equal 
else 
    return false;