¿Cómo compara HashSet elementos para la igualdad?

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.countestá 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.countes 3.

1. ¿Por qué no HashSetrespeta ael CompareTométodo?
2. ¿Es HashSetla mejor manera de tener una lista de objetos únicos?

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

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

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

Eso significa que tienes dos opciones:

• Pase una costumbre IEqualityComparer<T>al constructor. Esta es la mejor opción si no puede modificarse a Tsí mismo o si desea una relación de igualdad no predeterminada (por ejemplo, "todos los usuarios con una ID de usuario negativa se consideran iguales"). Esto casi nunca se implementa en el tipo en sí (es decir, Foono se implementa IEqualityComparer<Foo>), sino en un tipo separado que solo se usa para comparaciones.
• Implemente la igualdad en el tipo mismo, anulando GetHashCodey Equals(object). Idealmente, implemente también IEquatable<T>en el tipo, particularmente si es un tipo de valor. El método de comparación de igualdad predeterminado llamará a estos métodos.

Tenga en cuenta que nada de esto es en términos de una comparación ordenada , lo que tiene sentido, ya que ciertamente hay situaciones en las que puede especificar fácilmente la igualdad, pero no una ordenación total. Todo esto es lo mismo que Dictionary<TKey, TValue>, básicamente.

Si desea un conjunto que use el ordenamiento en lugar de solo las comparaciones de igualdad, debe usarlo SortedSet<T>desde .NET 4, que le permite especificar un en IComparer<T>lugar de un IEqualityComparer<T>. Esto usará IComparer<T>.Compare, lo que delegará IComparable<T>.CompareToo IComparable.CompareTosi está usando Comparer<T>.Default.

Aquí hay una aclaración sobre una parte de la respuesta que no se ha dicho: el tipo de objeto de tu HashSet<T>no tiene que implementarse, IEqualityComparer<T>sino que solo debe anularse Object.GetHashCode()y Object.Equals(Object obj).

En lugar de esto:

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

Tu hiciste esto:

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

Es sutil, pero esto me hizo tropezar la mayor parte del día tratando de hacer que HashSet funcione de la manera prevista. Y como han dicho otros, HashSet<a>terminará llamando a.GetHashCode()y a.Equals(obj)según sea necesario cuando trabaje con el conjunto.

HashSetusos Equalsy GetHashCode().

CompareTo es para conjuntos ordenados.

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

El constructor HashSet recibe el objeto que implementa IEqualityComparer para agregar un nuevo objeto. si desea utilizar el método en HashSet, debe anular Equals, 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");
        }
    }
}