Какую проблему решает IStructuralEquatable и IStructuralComparable?

Все типы в .NET поддерживают метод Object.Equals(), который по умолчанию сравнивает два типа на предмет ссылочного равенства. Однако иногда также желательно иметь возможность сравнить два типа на предмет структурного равенства.

Лучшим примером этого являются массивы, которые в .NET 4 теперь реализуют интерфейс IStructuralEquatable. Это позволяет различать, сравниваете ли вы два массива на предмет ссылочного равенства или «структурного равенства» - имеют ли они одинаковое количество элементов с одинаковыми значениями в каждой позиции. Вот пример:

int[] array1 = new int[] { 1, 5, 9 };
int[] array2 = new int[] { 1, 5, 9 };

// using reference comparison...
Console.WriteLine( array1.Equals( array2 ) ); // outputs false

// now using the System.Array implementation of IStructuralEquatable
Console.WriteLine(
    StructuralComparisons.StructuralEqualityComparer.Equals( array1, array2 )
); // outputs true

Другие типы, которые реализуют структурное равенство / сопоставимость, включают кортежи и анонимные типы, которые явно выигрывают от возможности выполнять сравнение на основе их структуры и содержимого.

Вы не задавали вопрос:

Почему у нас есть IStructuralComparable и IStructuralEquatable, когда уже существуют интерфейсы IComparable и IEquatable?

Ответ, который я предлагаю, заключается в том, что в целом желательно различать эталонные сравнения и структурные сравнения. Обычно ожидается, что если вы реализуете IEquatable<T>.Equals, вы также переопределите Object.Equals для обеспечения согласованности. В этом случае, как бы вы поддержали ссылочное и структурное равенство?

У меня такой же вопрос. Когда я запустил пример Л.Бушкина, то с удивлением увидел, что получил другой ответ! Несмотря на то, что у этого ответа 8 голосов, это неверно. После долгих размышлений, вот мой взгляд на вещи.

Некоторые контейнеры (массивы, кортежи, анонимные типы) поддерживают IStructuralComparable и IStructuralEquatable.

• IStructuralComparable поддерживает глубокую сортировку по умолчанию.
• IStructuralEquatable поддерживает глубокое хеширование по умолчанию.

{Обратите внимание, что EqualityComparer<T> поддерживает мелкое (только 1 уровень контейнера) хеширование по умолчанию.}

Насколько я понимаю, это доступно только через класс StructuralComparisons. Единственный способ сделать это полезным - создать вспомогательный класс StructuralEqualityComparer<T> следующим образом:

    public class StructuralEqualityComparer<T> : IEqualityComparer<T>
    {
        public bool Equals(T x, T y)
        {
            return StructuralComparisons.StructuralEqualityComparer.Equals(x,y);
        }

        public int GetHashCode(T obj)
        {
            return StructuralComparisons.StructuralEqualityComparer.GetHashCode(obj);
        }

        private static StructuralEqualityComparer<T> defaultComparer;
        public static StructuralEqualityComparer<T> Default
        {
            get
            {
                StructuralEqualityComparer<T> comparer = defaultComparer;
                if (comparer == null)
                {
                    comparer = new StructuralEqualityComparer<T>();
                    defaultComparer = comparer;
                }
                return comparer;
            }
        }
    }

Теперь мы можем создать HashSet с элементами, имеющими контейнеры внутри контейнеров внутри контейнеров.

        var item1 = Tuple.Create(1, new int[][] { new int[] { 1, 2 }, new int[] { 3 } });
        var item1Clone = Tuple.Create(1, new int[][] { new int[] { 1, 2 }, new int[] { 3 } });
        var item2 = Tuple.Create(1, new int[][] { new int[] { 1, 3 }, new int[] { 3 } });

        var set = new HashSet<Tuple<int, int[][]>>(StructuralEqualityComparer<Tuple<int, int[][]>>.Default);
        Console.WriteLine(set.Add(item1));      //true
        Console.WriteLine(set.Add(item1Clone)); //false
        Console.WriteLine(set.Add(item2));      //true

Мы также можем заставить наш собственный контейнер хорошо взаимодействовать с этими другими контейнерами, реализовав эти интерфейсы.

public class StructuralLinkedList<T> : LinkedList<T>, IStructuralEquatable
    {
        public bool Equals(object other, IEqualityComparer comparer)
        {
            if (other == null)
                return false;

            StructuralLinkedList<T> otherList = other as StructuralLinkedList<T>;
            if (otherList == null)
                return false;

            using( var thisItem = this.GetEnumerator() )
            using (var otherItem = otherList.GetEnumerator())
            {
                while (true)
                {
                    bool thisDone = !thisItem.MoveNext();
                    bool otherDone = !otherItem.MoveNext();

                    if (thisDone && otherDone)
                        break;

                    if (thisDone || otherDone)
                        return false;

                    if (!comparer.Equals(thisItem.Current, otherItem.Current))
                        return false;
                }
            }

            return true;
        }

        public int GetHashCode(IEqualityComparer comparer)
        {
            var result = 0;
            foreach (var item in this)
                result = result * 31 + comparer.GetHashCode(item);

            return result;
        }

        public void Add(T item)
        {
            this.AddLast(item);
        }
    }

Теперь мы можем создать HashSet с элементами, имеющими контейнеры внутри пользовательских контейнеров внутри контейнеров.

        var item1 = Tuple.Create(1, new StructuralLinkedList<int[]> { new int[] { 1, 2 }, new int[] { 3 } });
        var item1Clone = Tuple.Create(1, new StructuralLinkedList<int[]> { new int[] { 1, 2 }, new int[] { 3 } });
        var item2 = Tuple.Create(1, new StructuralLinkedList<int[]> { new int[] { 1, 3 }, new int[] { 3 } });

        var set = new HashSet<Tuple<int, StructuralLinkedList<int[]>>>(StructuralEqualityComparer<Tuple<int, StructuralLinkedList<int[]>>>.Default);
        Console.WriteLine(set.Add(item1));      //true
        Console.WriteLine(set.Add(item1Clone)); //false
        Console.WriteLine(set.Add(item2));      //true

Описание интерфейса IStructuralEquatable говорит (в разделе «Примечания»):

Интерфейс IStructuralEquatable позволяет реализовать индивидуальные сравнения для проверки структурного равенства объектов коллекции.

Об этом также свидетельствует тот факт, что этот интерфейс находится в пространстве имен System.Collections.

Вот еще один пример, иллюстрирующий возможное использование двух интерфейсов:

var a1 = new[] { 1, 33, 376, 4};
var a2 = new[] { 1, 33, 376, 4 };
var a3 = new[] { 2, 366, 12, 12};

Debug.WriteLine(a1.Equals(a2)); // False
Debug.WriteLine(StructuralComparisons.StructuralEqualityComparer.Equals(a1, a2)); // True

Debug.WriteLine(StructuralComparisons.StructuralComparer.Compare(a1, a2)); // 0
Debug.WriteLine(StructuralComparisons.StructuralComparer.Compare(a1, a3)); // -1

Книга в двух словах о C #:

Поскольку Array является классом, массивы всегда (сами по себе) reference types, независимо от типа элемента массива. Это означает, что оператор arrayB = arrayA приводит к двум переменным, которые ссылаются на один и тот же массив. Точно так же два различных массива всегда не пройдут проверку на равенство, если вы не используете настраиваемый компаратор на равенство. Framework 4.0 представил один для сравнения элементов в массивах, к которым вы можете получить доступ через тип StructuralComparisons.

object[] a1 = { "string", 123, true};
object[] a2 = { "string", 123, true};

Console.WriteLine(a1 == a2);               // False
Console.WriteLine(a1.Equals(a2));          // False

IStructuralEquatable se1 = a1;
Console.WriteLine(se1.Equals(a2, StructuralComparisons.StructuralEqualityComparer));    // True
Console.WriteLine(StructuralComparisons.StructuralEqualityComparer.Equals(a1, a2));     // True

object[] a3 = {"string", 123, true};
object[] a4 = {"string", 123, true};
object[] a5 = {"string", 124, true};

IStructuralComparable se2 = a3;
Console.WriteLine(se2.CompareTo(a4, StructuralComparisons.StructuralComparer));    // 0
Console.WriteLine(StructuralComparisons.StructuralComparer.Compare(a3, a4));       // 0
Console.WriteLine(StructuralComparisons.StructuralComparer.Compare(a4, a5));       // -1
Console.WriteLine(StructuralComparisons.StructuralComparer.Compare(a5, a4));       // 1

F # начал использовать их с .net 4. (.net 2 здесь)

Эти интерфейсы имеют решающее значение для F #.

let list1 = [1;5;9] 
let list2 = List.append [1;5] [9]

printfn "are they equal? %b" (list1 = list2)

list1.GetType().GetInterfaces().Dump()