Add new MemoryExtensions.SequenceEqual overloads (#48677)

* Add new MemoryExtensions.SequenceEqual overloads * Use MemoryExtensions.SequenceEqual in Enumerable.SequenceEqual * Use MemoryExtensions.SequenceEqual in a few more places

Author: stephentoub

src/libraries/System.Data.Common/src/System/Data/DataKey.cs

@@ -168,20 +168,9 @@ internal bool Equals(DataKey value)
  {
  return false;
  }
- else if (column1.Length != column2.Length)
- {
- return false;
- }
  else
  {
- for (int i = 0; i < column1.Length; i++)
- {
- if (!column1[i].Equals(column2[i]))
- {
- return false;
- }
- }
- return true;
+ return column1.AsSpan().SequenceEqual(column2);
  }
  }
 

src/libraries/System.Data.Common/src/System/Data/RelatedView.cs

@@ -62,22 +62,7 @@ public bool Invoke(DataRow row, DataRowVersion version)
 
  object[] childValues = row.GetKeyValues(_childKey, version);
 
- bool allow = true;
- if (childValues.Length != parentValues.Length)
- {
- allow = false;
- }
- else
- {
- for (int i = 0; i < childValues.Length; i++)
- {
- if (!childValues[i].Equals(parentValues[i]))
- {
- allow = false;
- break;
- }
- }
- }
+ bool allow = childValues.AsSpan().SequenceEqual(parentValues);
 
  IFilter? baseFilter = base.GetFilter();
  if (baseFilter != null)

src/libraries/System.IO.UnmanagedMemoryStream/tests/ArrayHelpers.cs

@@ -53,21 +53,7 @@ private ArrayComparer() // use the static Instance singleton
  {
  }
 
- public bool Equals(T[] x, T[] y)
- {
- if (x.Length != y.Length)
- {
- return false;
- }
- for (int i = 0; i < x.Length; i++)
- {
- if (!EqualityComparer<T>.Default.Equals(x[i], y[i]))
- {
- return false;
- }
- }
- return true;
- }
+ public bool Equals(T[] x, T[] y) => x.AsSpan().SequenceEqual(y);
 
  public int GetHashCode(T[] obj)
  {

src/libraries/System.Linq/src/System/Linq/SequenceEqual.cs

@@ -22,33 +22,22 @@ public static bool SequenceEqual<TSource>(this IEnumerable<TSource> first, IEnum
  ThrowHelper.ThrowArgumentNullException(ExceptionArgument.second);
  }
 
- if (comparer == null)
+ if (first is ICollection<TSource> firstCol && second is ICollection<TSource> secondCol)
  {
- // It's relatively common to see code (especially in tests and testing frameworks) that ends up
- // using Enumerable.SequenceEqual to compare two byte arrays. Using ReadOnlySpan.SequenceEqual
- // is significantly faster than accessing each byte via the array's IList<byte> interface
- // implementation. So, we special-case byte[] here. It would be nice to be able to delegate
- // to ReadOnlySpan.SequenceEqual for all TSource[] arrays where TSource is a value type and
- // implements IEquatable<TSource>, but there's no good way without reflection to convince
- // the C# compiler to let us delegate, as ReadOnlySpan.SequenceEqual requires an IEquatable<T>
- // constraint on its type parameter, and Enumerable.SequenceEqual lacks one on its type parameter.
- if (typeof(TSource) == typeof(byte) && first is byte[] firstArr && second is byte[] secondArr)
+ if (first is TSource[] firstArray && second is TSource[] secondArray)
  {
- return ((ReadOnlySpan<byte>)firstArr).SequenceEqual(secondArr);
+ return ((ReadOnlySpan<TSource>)firstArray).SequenceEqual(secondArray, comparer);
  }
 
- comparer = EqualityComparer<TSource>.Default;
- }
-
- if (first is ICollection<TSource> firstCol && second is ICollection<TSource> secondCol)
- {
  if (firstCol.Count != secondCol.Count)
  {
  return false;
  }
 
  if (firstCol is IList<TSource> firstList && secondCol is IList<TSource> secondList)
  {
+ comparer ??= EqualityComparer<TSource>.Default;
+
  int count = firstCol.Count;
  for (int i = 0; i < count; i++)
  {
@@ -65,6 +54,8 @@ public static bool SequenceEqual<TSource>(this IEnumerable<TSource> first, IEnum
  using (IEnumerator<TSource> e1 = first.GetEnumerator())
  using (IEnumerator<TSource> e2 = second.GetEnumerator())
  {
+ comparer ??= EqualityComparer<TSource>.Default;
+
  while (e1.MoveNext())
  {
  if (!(e2.MoveNext() && comparer.Equals(e1.Current, e2.Current)))

src/libraries/System.Memory/ref/System.Memory.cs

@@ -84,6 +84,8 @@ public static void Reverse<T>(this System.Span<T> span) { }
  public static int SequenceCompareTo<T>(this System.Span<T> span, System.ReadOnlySpan<T> other) where T : System.IComparable<T> { throw null; }
  public static bool SequenceEqual<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> other) where T : System.IEquatable<T> { throw null; }
  public static bool SequenceEqual<T>(this System.Span<T> span, System.ReadOnlySpan<T> other) where T : System.IEquatable<T> { throw null; }
+ public static bool SequenceEqual<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> other, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { throw null; }
+ public static bool SequenceEqual<T>(this System.Span<T> span, System.ReadOnlySpan<T> other, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { throw null; }
  public static void Sort<T>(this System.Span<T> span) { }
  public static void Sort<T>(this System.Span<T> span, System.Comparison<T> comparison) { }
  public static void Sort<TKey, TValue>(this System.Span<TKey> keys, System.Span<TValue> items) { }

src/libraries/System.Memory/tests/ReadOnlySpan/SequenceEqual.T.cs

@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using Xunit;
 
 namespace System.SpanTests
@@ -14,17 +16,21 @@ public static void ZeroLengthSequenceEqual()
 
  ReadOnlySpan<int> first = new ReadOnlySpan<int>(a, 1, 0);
  ReadOnlySpan<int> second = new ReadOnlySpan<int>(a, 2, 0);
- bool b = first.SequenceEqual(second);
- Assert.True(b);
+
+ Assert.True(first.SequenceEqual(second));
+ Assert.True(first.SequenceEqual(second, null));
+ Assert.True(first.SequenceEqual(second, EqualityComparer<int>.Default));
  }
 
  [Fact]
  public static void SameSpanSequenceEqual()
  {
  int[] a = { 4, 5, 6 };
  ReadOnlySpan<int> span = new ReadOnlySpan<int>(a);
- bool b = span.SequenceEqual(span);
- Assert.True(b);
+
+ Assert.True(span.SequenceEqual(span));
+ Assert.True(span.SequenceEqual(span, null));
+ Assert.True(span.SequenceEqual(span, EqualityComparer<int>.Default));
  }
 
  [Fact]
@@ -33,12 +39,17 @@ public static void LengthMismatchSequenceEqual()
  int[] a = { 4, 5, 6 };
  ReadOnlySpan<int> first = new ReadOnlySpan<int>(a, 0, 3);
  ReadOnlySpan<int> second = new ReadOnlySpan<int>(a, 0, 2);
- bool b = first.SequenceEqual(second);
- Assert.False(b);
+
+ Assert.False(first.SequenceEqual(second));
+ Assert.False(first.SequenceEqual(second, null));
+ Assert.False(first.SequenceEqual(second, EqualityComparer<int>.Default));
  }
 
- [Fact]
- public static void OnSequenceEqualOfEqualSpansMakeSureEveryElementIsCompared()
+ [Theory]
+ [InlineData(0)]
+ [InlineData(1)]
+ [InlineData(2)]
+ public static void OnSequenceEqualOfEqualSpansMakeSureEveryElementIsCompared(int mode)
  {
  for (int length = 0; length < 100; length++)
  {
@@ -53,8 +64,13 @@ public static void OnSequenceEqualOfEqualSpansMakeSureEveryElementIsCompared()
 
  ReadOnlySpan<TInt> firstSpan = new ReadOnlySpan<TInt>(first);
  ReadOnlySpan<TInt> secondSpan = new ReadOnlySpan<TInt>(second);
- bool b = firstSpan.SequenceEqual(secondSpan);
- Assert.True(b);
+
+ Assert.True(mode switch
+ {
+ 0 => firstSpan.SequenceEqual(secondSpan),
+ 1 => firstSpan.SequenceEqual(secondSpan, null),
+ _ => firstSpan.SequenceEqual(secondSpan, EqualityComparer<TInt>.Default)
+ });
 
  // Make sure each element of the array was compared once. (Strictly speaking, it would not be illegal for
  // SequenceEqual to compare an element more than once but that would be a non-optimal implementation and
@@ -68,8 +84,11 @@ public static void OnSequenceEqualOfEqualSpansMakeSureEveryElementIsCompared()
  }
  }
 
- [Fact]
- public static void SequenceEqualNoMatch()
+ [Theory]
+ [InlineData(0)]
+ [InlineData(1)]
+ [InlineData(2)]
+ public static void SequenceEqualNoMatch(int mode)
  {
  for (int length = 1; length < 32; length++)
  {
@@ -88,8 +107,13 @@ public static void SequenceEqualNoMatch()
 
  ReadOnlySpan<TInt> firstSpan = new ReadOnlySpan<TInt>(first);
  ReadOnlySpan<TInt> secondSpan = new ReadOnlySpan<TInt>(second);
- bool b = firstSpan.SequenceEqual(secondSpan);
- Assert.False(b);
+
+ Assert.False(mode switch
+ {
+ 0 => firstSpan.SequenceEqual(secondSpan),
+ 1 => firstSpan.SequenceEqual(secondSpan, null),
+ _ => firstSpan.SequenceEqual(secondSpan, EqualityComparer<TInt>.Default)
+ });
 
  Assert.Equal(1, log.CountCompares(first[mismatchIndex].Value, second[mismatchIndex].Value));
  }
@@ -125,8 +149,10 @@ public static void MakeSureNoSequenceEqualChecksGoOutOfRange()
 
  ReadOnlySpan<TInt> firstSpan = new ReadOnlySpan<TInt>(first, GuardLength, length);
  ReadOnlySpan<TInt> secondSpan = new ReadOnlySpan<TInt>(second, GuardLength, length);
- bool b = firstSpan.SequenceEqual(secondSpan);
- Assert.True(b);
+
+ Assert.True(firstSpan.SequenceEqual(secondSpan));
+ Assert.True(firstSpan.SequenceEqual(secondSpan, null));
+ Assert.True(firstSpan.SequenceEqual(secondSpan, EqualityComparer<TInt>.Default));
  }
  }
 
@@ -135,8 +161,53 @@ public static void MakeSureNoSequenceEqualChecksGoOutOfRange()
  public static void SequenceEqualsNullData_String(string[] firstInput, string[] secondInput, bool expected)
  {
  ReadOnlySpan<string> theStrings = firstInput;
+
  Assert.Equal(expected, theStrings.SequenceEqual(secondInput));
- Assert.Equal(expected, theStrings.SequenceEqual((ReadOnlySpan<string>)secondInput));
+ Assert.Equal(expected, theStrings.SequenceEqual(secondInput, null));
+ Assert.Equal(expected, theStrings.SequenceEqual(secondInput, EqualityComparer<string>.Default));
+ }
+
+ [Fact]
+ public static void SequenceEqual_AlwaysTrueComparer()
+ {
+ Assert.False(((ReadOnlySpan<int>)new int[1]).SequenceEqual(new int[2], new AlwaysComparer<int>(true)));
+ Assert.True(((ReadOnlySpan<int>)new int[2]).SequenceEqual(new int[2], new AlwaysComparer<int>(true)));
+ Assert.True(((ReadOnlySpan<int>)new int[2] { 1, 3 }).SequenceEqual(new int[2] { 2, 4 }, new AlwaysComparer<int>(true)));
+ }
+
+ [Fact]
+ public static void SequenceEqual_AlwaysFalseComparer()
+ {
+ Assert.False(((ReadOnlySpan<int>)new int[1]).SequenceEqual(new int[2], new AlwaysComparer<int>(false)));
+ Assert.False(((ReadOnlySpan<int>)new int[1]).SequenceEqual(new int[2], new AlwaysComparer<int>(false)));
+ Assert.False(((ReadOnlySpan<int>)new int[2] { 1, 3 }).SequenceEqual(new int[2] { 2, 4 }, new AlwaysComparer<int>(false)));
+ }
+
+ [Fact]
+ public static void SequenceEqual_IgnoreCaseComparer()
+ {
+ string[] lower = new[] { "hello", "world" };
+ string[] upper = new[] { "HELLO", "WORLD" };
+ string[] different = new[] { "hello", "wurld" };
+
+ Assert.True(((ReadOnlySpan<string>)lower).SequenceEqual(lower));
+ Assert.False(((ReadOnlySpan<string>)lower).SequenceEqual(upper));
+ Assert.True(((ReadOnlySpan<string>)upper).SequenceEqual(upper));
+
+ Assert.True(((ReadOnlySpan<string>)lower).SequenceEqual(lower, StringComparer.OrdinalIgnoreCase));
+ Assert.True(((ReadOnlySpan<string>)lower).SequenceEqual(upper, StringComparer.OrdinalIgnoreCase));
+ Assert.True(((ReadOnlySpan<string>)upper).SequenceEqual(upper, StringComparer.OrdinalIgnoreCase));
+
+ Assert.False(((ReadOnlySpan<string>)lower).SequenceEqual(different));
+ Assert.False(((ReadOnlySpan<string>)lower).SequenceEqual(different, StringComparer.OrdinalIgnoreCase));
+ }
+
+ private sealed class AlwaysComparer<T> : IEqualityComparer<T>
+ {
+ private readonly bool _result;
+ public AlwaysComparer(bool result) => _result = result;
+ public bool Equals(T? x, T? y) => _result;
+ public int GetHashCode([DisallowNull] T obj) => 0;
  }
  }
 }

src/libraries/System.Memory/tests/ReadOnlySpan/SequenceEqual.byte.cs

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Collections.Generic;
 using Xunit;
 
 namespace System.SpanTests
@@ -14,26 +15,32 @@ public static void ZeroLengthSequenceEqual_Byte()
 
  ReadOnlySpan<byte> first = new ReadOnlySpan<byte>(a, 1, 0);
  ReadOnlySpan<byte> second = new ReadOnlySpan<byte>(a, 2, 0);
- bool b = first.SequenceEqual<byte>(second);
- Assert.True(b);
+
+ Assert.True(first.SequenceEqual<byte>(second));
+ Assert.True(first.SequenceEqual<byte>(second, null));
+ Assert.True(first.SequenceEqual<byte>(second, EqualityComparer<byte>.Default));
  }
 
  [Fact]
  public static void SameSpanSequenceEqual_Byte()
  {
  byte[] a = { 4, 5, 6 };
  ReadOnlySpan<byte> span = new ReadOnlySpan<byte>(a);
- bool b = span.SequenceEqual<byte>(span);
- Assert.True(b);
+
+ Assert.True(span.SequenceEqual<byte>(span));
+ Assert.True(span.SequenceEqual<byte>(span, null));
+ Assert.True(span.SequenceEqual<byte>(span, EqualityComparer<byte>.Default));
  }
 
  [Fact]
  public static void SequenceEqualArrayImplicit_Byte()
  {
  byte[] a = { 4, 5, 6 };
  ReadOnlySpan<byte> first = new ReadOnlySpan<byte>(a, 0, 3);
- bool b = first.SequenceEqual<byte>(a);
- Assert.True(b);
+
+ Assert.True(first.SequenceEqual<byte>(a));
+ Assert.True(first.SequenceEqual<byte>(a, null));
+ Assert.True(first.SequenceEqual<byte>(a, EqualityComparer<byte>.Default));
  }
 
  [Fact]
@@ -44,8 +51,10 @@ public static void SequenceEqualArraySegmentImplicit_Byte()
  var segment = new ArraySegment<byte>(dst, 1, 3);
 
  ReadOnlySpan<byte> first = new ReadOnlySpan<byte>(src, 0, 3);
- bool b = first.SequenceEqual<byte>(segment);
- Assert.True(b);
+
+ Assert.True(first.SequenceEqual<byte>(segment));
+ Assert.True(first.SequenceEqual<byte>(segment, null));
+ Assert.True(first.SequenceEqual<byte>(segment, EqualityComparer<byte>.Default));
  }
 
  [Fact]
@@ -54,8 +63,10 @@ public static void LengthMismatchSequenceEqual_Byte()
  byte[] a = { 4, 5, 6 };
  ReadOnlySpan<byte> first = new ReadOnlySpan<byte>(a, 0, 3);
  ReadOnlySpan<byte> second = new ReadOnlySpan<byte>(a, 0, 2);
- bool b = first.SequenceEqual<byte>(second);
- Assert.False(b);
+
+ Assert.False(first.SequenceEqual<byte>(second));
+ Assert.False(first.SequenceEqual<byte>(second, null));
+ Assert.False(first.SequenceEqual<byte>(second, EqualityComparer<byte>.Default));
  }
 
  [Fact]
@@ -76,8 +87,10 @@ public static void SequenceEqualNoMatch_Byte()
 
  ReadOnlySpan<byte> firstSpan = new ReadOnlySpan<byte>(first);
  ReadOnlySpan<byte> secondSpan = new ReadOnlySpan<byte>(second);
- bool b = firstSpan.SequenceEqual<byte>(secondSpan);
- Assert.False(b);
+
+ Assert.False(firstSpan.SequenceEqual<byte>(secondSpan));
+ Assert.False(firstSpan.SequenceEqual<byte>(secondSpan, null));
+ Assert.False(firstSpan.SequenceEqual<byte>(secondSpan, EqualityComparer<byte>.Default));
  }
  }
  }
@@ -95,8 +108,10 @@ public static void MakeSureNoSequenceEqualChecksGoOutOfRange_Byte()
  second[length + 1] = 100;
  ReadOnlySpan<byte> span1 = new ReadOnlySpan<byte>(first, 1, length);
  ReadOnlySpan<byte> span2 = new ReadOnlySpan<byte>(second, 1, length);
- bool b = span1.SequenceEqual<byte>(span2);
- Assert.True(b);
+
+ Assert.True(span1.SequenceEqual<byte>(span2));
+ Assert.True(span1.SequenceEqual<byte>(span2, null));
+ Assert.True(span1.SequenceEqual<byte>(span2, EqualityComparer<byte>.Default));
  }
  }
  }