Como o HashSet compara elementos para igualdade?

Eu tenho uma classe que é 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);
    }
}

Quando adiciono uma lista de objetos desta classe a um 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);

Está tudo bem e ha.countestá 2, mas:

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));

Agora ha.counté 3.

1. Por que não HashSetrespeita ao CompareTométodo?
2. É HashSeta melhor maneira de ter uma lista de objetos exclusivos?

Ele usa um IEqualityComparer<T>(a EqualityComparer<T>.Defaultmenos que você especifique um diferente na construção).

Quando você adiciona um elemento ao conjunto, ele encontra o código hash usando IEqualityComparer<T>.GetHashCodee armazena o código hash e o elemento (depois de verificar se o elemento já está no conjunto, é claro).

Para procurar um elemento, ele primeiro usará o IEqualityComparer<T>.GetHashCodepara encontrar o código de hash e, em seguida, para todos os elementos com o mesmo código de hash, ele será usado IEqualityComparer<T>.Equalspara comparar a igualdade real.

Isso significa que você tem duas opções:

• Passe um costume IEqualityComparer<T>para o construtor. Essa é a melhor opção se você não puder modificar a Tsi mesmo ou se desejar uma relação de igualdade não padrão (por exemplo, "todos os usuários com um ID de usuário negativo são considerados iguais"). Isso quase nunca é implementado no próprio tipo (isto Fooé, não implementa IEqualityComparer<Foo>), mas em um tipo separado, que é usado apenas para comparações.
• Implemente a igualdade no próprio tipo, substituindo GetHashCodee Equals(object). Idealmente, implemente também IEquatable<T>no tipo, principalmente se for um tipo de valor. Esses métodos serão chamados pelo comparador de igualdade padrão.

Observe como nada disso é em termos de comparação ordenada - o que faz sentido, pois certamente existem situações em que você pode especificar facilmente a igualdade, mas não uma ordenação total. Isso é tudo igual Dictionary<TKey, TValue>, basicamente.

Se você deseja um conjunto que use ordenação em vez de apenas comparações de igualdade, use o SortedSet<T>.NET 4 - que permite especificar um em IComparer<T>vez de um IEqualityComparer<T>. Isso usará IComparer<T>.Compare- que delegará IComparable<T>.CompareToou IComparable.CompareTose você estiver usando Comparer<T>.Default.

Aqui estão os esclarecimentos sobre uma parte da resposta que não foi dita: O tipo de objeto seu HashSet<T>não precisa ser implementado, IEqualityComparer<T>mas apenas substituído Object.GetHashCode()e Object.Equals(Object obj).

Em vez disso:

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

Você faz isso:

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

É sutil, mas isso me levou a maior parte do dia tentando fazer com que o HashSet funcionasse da maneira que se destina. E, como outros já disseram, HashSet<a>acabará ligando a.GetHashCode()e a.Equals(obj)conforme necessário ao trabalhar com o aparelho.

HashSetusa Equalse GetHashCode().

CompareTo é para conjuntos encomendados.

Se você deseja objetos únicos, mas não se importa com a ordem de iteração deles, HashSet<T>geralmente é a melhor opção.

O construtor HashSet recebe o objeto que implementa IEqualityComparer para adicionar novo objeto. se você deseja usar o método no HashSet, anula a substituição de 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");
        }
    }
}