Welches problem wird IStructuralEquatable und IStructuralComparable lösen?

Ich hatte die gleiche Frage. Bei mir lief LBushkin Beispiel war ich überrascht zu sehen, dass ich mir eine andere Antwort! Obwohl, die Antwort hat 8 upvotes, ist es falsch. Nachdem eine Menge von 'Reflektor' Ing, hier ist mein nehmen auf Dinge.

Bestimmte Container (arrays, Tupel, anonyme Typen) support IStructuralComparable und IStructuralEquatable.

IStructuralComparable unterstützt deep, Standard-Sortierung.

IStructuralEquatable unterstützt deep, Standard-hashing.

{Beachten Sie, dass EqualityComparer<T> unterstützt sowohl flache (nur 1 container-Niveau), Standard-hashing.}

Soweit ich sehe, dies ist nur ausgesetzt, durch die StructuralComparisons Klasse. Nur so kann ich herausfinden, zu machen, das nützlich ist, um eine StructuralEqualityComparer<T> helper-Klasse wie folgt:

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

Nun können wir ein HashSet mit Elementen, die Container innerhalb von Containern innerhalb von Containern.

        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

Können wir auch unsere eigenen container gut spielen mit diesen und anderen Behältern durch die Implementierung dieser Schnittstellen.

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

Nun können wir ein HashSet mit Elementen, die Container innerhalb des custom Container innerhalb von Containern.

        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

Die Beschreibung der IStructuralEquatable Interface sagt (im Abschnitt "Hinweise"):

Den IStructuralEquatable - Schnittstelle ermöglicht die Implementierung angepasst-Vergleiche zu prüfen, für die strukturelle Gleichheit von collection-Objekte.

Dies wird auch deutlich gemacht durch die Tatsache, dass diese Schnittstelle befindet sich in der System.Collections namespace.

C# in a nutshell Buch:

Weil Array ist eine Klasse, die arrays sind immer (selbst) reference types unabhängig
der array-element-Typ. Dies bedeutet, dass die Aussage arrayB = arrayA Ergebnisse
in zwei Variablen verweisen auf das gleiche array. Ebenso werden zwei verschiedene arrays
schlägt immer fehl, eine Gleichheit zu testen—es sei denn, Sie verwenden eine benutzerdefinierte Gleichheit comparer. Rahmen
4.0 eingeführt, eine für die Zwecke von vergleichen von Elementen in arrays, was Sie können
der Zugang über die StructuralComparisons geben.

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