¿Cómo compara HashSet elementos para la igualdad?

Question

tengo una clase que es IComparable:

public class a : IComparable 
{ 
    public int Id { get; set; } 
    public string Name { get; set; } 

    public a(int id) 
    { 
     this.Id = id; 
    } 

    public int CompareTo(object obj) 
    { 
     return this.Id.CompareTo(((a)obj).Id); 
    } 
} 

Cuando agrego una lista de objetos de esta clase a un conjunto de hash:

a a1 = new a(1); 
a a2 = new a(2); 
HashSet<a> ha = new HashSet<a>(); 
ha.add(a1); 
ha.add(a2); 
ha.add(a1); 

todo está bien y ha.count es 2, pero:

a a1 = new a(1); 
a a2 = new a(2); 
HashSet<a> ha = new HashSet<a>(); 
ha.add(a1); 
ha.add(a2); 
ha.add(new a(1)); 

Ahora ha.count es 3.

1. Por qué no HashSet respecto a 's CompareTo método.
2. ¿Es HashSet la mejor manera de tener una lista de objetos únicos?

Answer 1

Utiliza un IEqualityComparer<T> (EqualityComparer<T>.Default a menos que especifique uno diferente en la construcción).

Cuando agrega un elemento al conjunto, encontrará el código hash usando IEqualityComparer<T>.GetHashCode y almacenará el código hash y el elemento (después de verificar si el elemento ya está en el conjunto, por supuesto).

Para buscar un elemento, primero usará el IEqualityComparer<T>.GetHashCode para encontrar el código hash, luego para todos los elementos con el mismo código hash, usará IEqualityComparer<T>.Equals para comparar para igualdad real.

Eso significa que tiene dos opciones:

• pase una costumbre IEqualityComparer<T> al constructor. Esta es la mejor opción si no puede modificar el T en sí mismo, o si desea una relación de igualdad no predeterminada (por ejemplo, "todos los usuarios con un ID de usuario negativo se consideran iguales"). Esto casi nunca se implementa en el tipo en sí (es decir, Foo no implementa IEqualityComparer<Foo>) pero en un tipo separado que solo se usa para las comparaciones.
• Implementa la igualdad en el tipo en sí, anulando GetHashCode y Equals(object). Idealmente, implemente IEquatable<T> en el tipo, especialmente si se trata de un tipo de valor. Estos métodos serán llamados por el comparador de igualdad predeterminado.

Nota cómo nada de esto es en términos de una comparación ordenada - lo cual tiene sentido, ya que sin duda hay situaciones en las que se pueden especificar fácilmente la igualdad, pero no un orden total. Esto es todo lo mismo que Dictionary<TKey, TValue>, básicamente.

Si desea utilizar un juego que utiliza ordenar en lugar de sólo las comparaciones de igualdad, se debe utilizar SortedSet<T> de .NET 4 - que le permite especificar un IComparer<T> en lugar de un IEqualityComparer<T>. Esto utilizará IComparer<T>.Compare - que delegará en IComparable<T>.CompareTo o IComparable.CompareTo si está usando Comparer<T>.Default.

Answer 2

HashSet utiliza Equals y GetHashCode().

CompareTo es para conjuntos ordenados.

Si desea objetos únicos, pero no le importa su orden de iteración, HashSet<T> es generalmente la mejor opción.

Answer 3

Aquí es aclaraciones sobre una parte de la respuesta que se ha dejado sin decir: El tipo de objeto de su HashSet<T> no tiene que poner en práctica IEqualityComparer<T> sino que simplemente tiene que anular Object.GetHashCode() y Object.Equals(Object obj).

lugar de esto:

public class a : IEqualityComparer<a> 
{ 
    public int GetHashCode(a obj) { /* Implementation */ } 
    public bool Equals(a obj1, a obj2) { /* Implementation */ } 
} 

Para ello:

public class a 
{ 
    public override int GetHashCode() { /* Implementation */ } 
    public override bool Equals(object obj) { /* Implementation */ } 
} 

Es sutil, pero esto me hizo tropezar durante la mayor parte del día tratando de conseguir HashSet funcione el camino es intencionado Y como han dicho otros, HashSet<a> terminará llamando al a.GetHashCode() y a.Equals(obj) según sea necesario cuando se trabaja con el conjunto.

Answer 4

constructor HashSet recibe el objeto que implementa IEqualityComparer para agregar un nuevo objeto. si utilice el método whant en HashSet que overrride Nead iguales, GetHashCode

namespace HashSet 
{ 
    public class Employe 
    { 
     public Employe() { 
     } 

     public string Name { get; set; } 

     public override string ToString() { 
      return Name; 
     } 

     public override bool Equals(object obj) { 
      return this.Name.Equals(((Employe)obj).Name); 
     } 

     public override int GetHashCode() { 
      return this.Name.GetHashCode(); 
     } 
    } 

    class EmployeComparer : IEqualityComparer<Employe> 
    { 
     public bool Equals(Employe x, Employe y) 
     { 
      return x.Name.Trim().ToLower().Equals(y.Name.Trim().ToLower()); 
     } 

     public int GetHashCode(Employe obj) 
     { 
      return obj.Name.GetHashCode(); 
     } 
    } 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      HashSet<Employe> hashSet = new HashSet<Employe>(new EmployeComparer()); 
      hashSet.Add(new Employe() { Name = "Nik" }); 
      hashSet.Add(new Employe() { Name = "Rob" }); 
      hashSet.Add(new Employe() { Name = "Joe" }); 
      Display(hashSet); 
      hashSet.Add(new Employe() { Name = "Rob" }); 
      Display(hashSet); 

      HashSet<Employe> hashSetB = new HashSet<Employe>(new EmployeComparer()); 
      hashSetB.Add(new Employe() { Name = "Max" }); 
      hashSetB.Add(new Employe() { Name = "Solomon" }); 
      hashSetB.Add(new Employe() { Name = "Werter" }); 
      hashSetB.Add(new Employe() { Name = "Rob" }); 
      Display(hashSetB); 

      var union = hashSet.Union<Employe>(hashSetB).ToList(); 
      Display(union); 
      var inter = hashSet.Intersect<Employe>(hashSetB).ToList(); 
      Display(inter); 
      var except = hashSet.Except<Employe>(hashSetB).ToList(); 
      Display(except); 

      Console.ReadKey(); 
     } 

     static void Display(HashSet<Employe> hashSet) 
     { 
      if (hashSet.Count == 0) 
      { 
       Console.Write("Collection is Empty"); 
       return; 
      } 
      foreach (var item in hashSet) 
      { 
       Console.Write("{0}, ", item); 
      } 
      Console.Write("\n"); 
     } 

     static void Display(List<Employe> list) 
     { 
      if (list.Count == 0) 
      { 
       Console.WriteLine("Collection is Empty"); 
       return; 
      } 
      foreach (var item in list) 
      { 
       Console.Write("{0}, ", item); 
      } 
      Console.Write("\n"); 
     } 
    } 
}