Optimize ImmutableSortedSet<T>.SetEquals to avoid unnecessary allocations

Author: Ahmed

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

@@ -370,29 +370,38 @@ public bool SetEquals(IEnumerable<T> other)
         {
             Requires.NotNull(other, nameof(other));
 
-            if (object.ReferenceEquals(this, other))
+            if (object.ReferenceEquals(this, other)) return true;
+
+            if (other is ImmutableSortedSet<T> immutableSortedSet && immutableSortedSet.KeyComparer == this.KeyComparer)
             {
+                if (immutableSortedSet.Count != this.Count) return false;
+                foreach (T item in immutableSortedSet)
+                {
+                    if (!this.Contains(item)) return false;
+                }
+
                 return true;
             }
 
-            var otherSet = new SortedSet<T>(other, this.KeyComparer);
-            if (this.Count != otherSet.Count)
+            else if (other is SortedSet<T> sortedSet && sortedSet.Comparer == this.KeyComparer)
             {
-                return false;
+                if (sortedSet.Count != this.Count) return false;
+                foreach (T item in sortedSet)
+                {
+                    if (!this.Contains(item)) return false;
+                }
+
+                return true;
             }
 
-            int matches = 0;
+            var otherSet = new SortedSet<T>(other, this.KeyComparer);
+            if (otherSet.Count != this.Count) return false;
             foreach (T item in otherSet)
             {
-                if (!this.Contains(item))
-                {
-                    return false;
-                }
-
-                matches++;
+                if (!this.Contains(item)) return false;
             }
 
-            return matches == this.Count;
+            return true;
         }
 
         /// <summary>