Optimize ImmutableSortedSet<T>.SetEquals to avoid unnecessary allocations

src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableSortedSet_1.cs

@@ -375,24 +375,55 @@ public bool SetEquals(IEnumerable<T> other)
                 return true;
             }
 
-            var otherSet = new SortedSet<T>(other, this.KeyComparer);
-            if (this.Count != otherSet.Count)
+            switch (other)
             {
-                return false;
+                case ImmutableSortedSet<T> otherAsImmutableSortedSet:
+                    if (otherAsImmutableSortedSet.Count != this.Count)
+                    {
+                        return false;
+                    }
+
+                    if (EqualityComparer<IComparer<T>>.Default.Equals(this.KeyComparer, otherAsImmutableSortedSet.KeyComparer))
+                    {
+                        return SetEqualsWithImmutableSortedSet(otherAsImmutableSortedSet, this);
+                    }
+                    break;
+
+                case SortedSet<T> otherAsSortedSet:
+                    if (otherAsSortedSet.Count != this.Count)
+                    {
+                        return false;
+                    }
+
+                    if (EqualityComparer<IComparer<T>>.Default.Equals(this.KeyComparer, otherAsSortedSet.Comparer))
+                    {
+                        return SetEqualsWithSortedSet(otherAsSortedSet, this);
+                    }
+                    break;
+
+                case ICollection<T> otherAsICollectionGeneric:
+                    // We check for < instead of != because other is not guaranteed to be a set; it could be a collection with duplicates.
+                    if (otherAsICollectionGeneric.Count < this.Count)
+                    {
+                        return false;
+                    }
+                    break;
+
+                case ICollection otherAsICollection:
+                    if (otherAsICollection.Count < this.Count)
+                    {
+                        return false;
+                    }
+                    break;
             }
 
-            int matches = 0;
-            foreach (T item in otherSet)
+            var otherSet = new SortedSet<T>(other, this.KeyComparer);
+            if (otherSet.Count != this.Count)
             {
-                if (!this.Contains(item))
-                {
-                    return false;
-                }
-
-                matches++;
+                return false;
             }
 
-            return matches == this.Count;
+            return SetEqualsWithSortedSet(otherSet, this);
         }
 
         /// <summary>
@@ -1016,6 +1047,62 @@ private static bool TryCastToImmutableSortedSet(IEnumerable<T> sequence, [NotNul
             return false;
         }
 
+        /// <summary>
+        /// Checks whether a given sequence of items entirely describe the contents of this set.
+        /// Note:
+        /// 1. Count equality must be verified by the caller before calling this method,
+        ///    as it is invoked by multiple callers with different validation logic.
+        /// </summary>
+        /// <param name="other">The sequence of items to check against this set.</param>
+        /// <param name="source">The sequence of items in this.</param>
+        /// <returns>A value indicating whether the sets are equal.</returns>
+        private static bool SetEqualsWithImmutableSortedSet(ImmutableSortedSet<T> other, ImmutableSortedSet<T> source)
+        {
+            using var e1 = other.GetEnumerator();
+            using var e2 = source.GetEnumerator();
+
+            while (e1.MoveNext())
+            {
+                bool e2HasMore = e2.MoveNext();
+                Debug.Assert(e2HasMore);
+
+                if (source.KeyComparer.Compare(e1.Current, e2.Current) != 0)
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Checks whether a given sequence of items entirely describe the contents of this set.
+        /// Note:
+        /// 1. Count equality must be verified by the caller before calling this method,
+        ///    as it is invoked by multiple callers with different validation logic.
+        /// </summary>
+        /// <param name="other">The sequence of items to check against this set.</param>
+        /// <param name="source">The sequence of items in this.</param>
+        /// <returns>A value indicating whether the sets are equal.</returns>
+        private static bool SetEqualsWithSortedSet(SortedSet<T> other, ImmutableSortedSet<T> source)
+        {
+            using var e1 = other.GetEnumerator();
+            using var e2 = source.GetEnumerator();
+
+            while (e1.MoveNext())
+            {
+                bool e2HasMore = e2.MoveNext();
+                Debug.Assert(e2HasMore);
+
+                if (source.KeyComparer.Compare(e1.Current, e2.Current) != 0)
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
         /// <summary>
         /// Creates a new sorted set wrapper for a node tree.
         /// </summary>