Une structure semblable à Equals() pour les classes .NET?

Question

Étant donné que deux objections ne contiennent pas de boucles de référence, connaissez-vous une méthode qui teste leur égalité de façon «générique» (par réflexion)?

Je veux fondamentalement la même sémantique que l'équivalence de struct, seulement sur les classes.

Answer 1

Je pense qu'il n'y a pas une telle méthode disponible dans le framework, mais c'est assez facile à écrire. Peut-être pas la plus courte mise en œuvre, mais est semble faire le travail:

private bool AreEqual(object x, object y) 
{ 
    // if both are null, they are equal 
    if (x == null && y == null) 
    { 
     return true; 
    } 
    // if one of them are null, they are not equal 
    else if (x == null || y == null) 
    { 
     return false; 
    } 

    // if they are of different types, they can't be compared 
    if (x.GetType() != y.GetType()) 
    { 
     throw new InvalidOperationException("x and y must be of the same type"); 
    } 

    Type type = x.GetType(); 
    PropertyInfo[] properties = type.GetProperties(); 

    for (int i = 0; i < properties.Length; i++) 
    { 
     // compare only properties that requires no parameters 
     if (properties[i].GetGetMethod().GetParameters().Length == 0) 
     { 
      object xValue = properties[i].GetValue(x, null); 
      object yValue = properties[i].GetValue(y, null); 

      if (properties[i].PropertyType.IsValueType && !xValue.Equals(yValue)) 
      { 
       return false; 
      } 
      else if (!properties[i].PropertyType.IsValueType) 
      { 
       if (!AreEqual(xValue, yValue)) 
       { 
        return false; 
       } 
      } // if 
     } // if 
    } // for 

    return true; 

} 

Answer 2

Si vous voulez faire sans faire une réflexion sur chaque appel, vous voudrez peut-être envisager de construire une DynamicMethod sur le premier appel et en utilisant au lieu . (J'avais un lien vers l'article qui fait cela, mais je l'ai perdu - désolé -. Googler si vous êtes intéressé essayer)

Answer 3

BTW

Expression.Lambda<Func<T,T,bool>> Compile() 

peut être utilisé en tant que constructeur de méthode dynamique.

doivent encore utiliser la réflexion tout en construisant la Expresison

Answer 4

Voici une version mise à jour de la réponse de Fredrik Mörk qui tient compte Nullable et références récursives:

public static bool AreEqual<T>(T x, T y) => 
    AreEqual(x, y, new HashSet<object>(new IdentityEqualityComparer<object>())); 

private static bool AreEqual(object x, object y, ISet<object> visited) 
{ 
    // if both are null, they are equal 
    if (x == null && y == null) return true; 

    // if one of them are null, they are not equal 
    if (x == null || y == null) return false; 

    // if they are of different types, they can't be compared 
    if (x.GetType() != y.GetType()) 
    { 
     throw new InvalidOperationException("x and y must be of the same type"); 
    } 

    // check for recursive references 
    if (visited.Contains(x)) return true; 
    if (visited.Contains(y)) return true; 
    visited.Add(x); 
    visited.Add(y); 

    var type = x.GetType(); 
    var properties = type.GetProperties(); 

    foreach (var property in properties) 
    { 
     // compare only properties that requires no parameters 
     if (property.GetGetMethod().GetParameters().Length == 0) 
     { 
      object xValue = property.GetValue(x, null); 
      object yValue = property.GetValue(y, null); 

      if (property.PropertyType.IsValueType) 
      { 
       // check for Nullable 
       if (xValue == null && yValue == null) continue; 
       if (xValue == null || yValue == null) return false; 
       if (!xValue.Equals(yValue)) return false; 
      } 

      if (!property.PropertyType.IsValueType) 
      { 
       if (!AreEqual(xValue, yValue, visited)) return false; 
      } 
     } 
    } 

    return true; 
} 

private class IdentityEqualityComparer<T> : IEqualityComparer<T> where T : class 
{ 
    public int GetHashCode(T value) => RuntimeHelpers.GetHashCode(value); 
    public bool Equals(T left, T right) => left == right; 
}