C# SequenceEqual Method

SequenceEqual. Are two sequences are the same?

With the SequenceEqual extension from System.Linq in the C# language, you can test two collections for equality in one statement. We look at the SequenceEqual method.

Note: SequenceEqual compares two collections for exact equality. Its performance is much worse than alternative implementations.

Example. First, the example program allocates four string arrays on the managed heap. Next, the SequenceEqual method is used on the arrays: array1 is tested against array2, array3, and array4.

String Array

C# program that uses SequenceEqual

using System;
using System.Linq;

class Program
{
    static void Main()
    {
	string[] array1 = { "dot", "net", "deves" };
	string[] array2 = { "a", "different", "array" };
	string[] array3 = { "dot", "net", "deves" };
	string[] array4 = { "DOT", "NET", "PERLS" };

	bool a = array1.SequenceEqual(array2);
	bool b = array1.SequenceEqual(array3);
	bool c = array1.SequenceEqual(array4, StringComparer.OrdinalIgnoreCase);

	Console.WriteLine(a);
	Console.WriteLine(b);
	Console.WriteLine(c);
    }
}

Output

False
True
True

The variable array1 was determined not to be equal to array2. But Array1 was equal to array3. Array1 was equal to array4 when the IEqualityComparer implementation (StringComparer.OrdinalIgnoreCase) was passed as the second argument.

OrdinalIgnoreCase: This causes the elements to be equal if they only have different cases. The character casing is ignored.

Performance. Methods found in System.Linq usually have worse performance on arrays than custom imperative algorithms. I tested the performance of SequenceEqual because I had nothing better to do. I compared two equal arrays of 32767 elements.

Result: SequenceEqual was more than ten times slower than the imperative algorithm (ArraysEqual).

C# program that benchmarks SequenceEqual

using System;
using System.Diagnostics;
using System.Linq;

class Program
{
    static void Main()
    {
	const int max = 10000;
	var a1 = Enumerable.Range(0, short.MaxValue).ToArray();
	var a2 = Enumerable.Range(0, short.MaxValue).ToArray();

	var s1 = Stopwatch.StartNew();
	for (int i = 0; i < max; i++)
	{
	    bool equals = a1.SequenceEqual(a2);
	}
	s1.Stop();
	var s2 = Stopwatch.StartNew();
	for (int i = 0; i < max; i++)
	{
	    bool equals = ArraysEqual(a1, a2);
	}
	s2.Stop();
	Console.WriteLine(((double)(s1.Elapsed.TotalMilliseconds * 1000000) /
	    max).ToString("0.00 ns"));
	Console.WriteLine(((double)(s2.Elapsed.TotalMilliseconds * 1000000) /
	    max).ToString("0.00 ns"));
	Console.Read();
    }

    static bool ArraysEqual(int[] a1, int[] a2)
    {
	if (a1.Length == a2.Length)
	{
	    for (int i = 0; i < a1.Length; i++)
	    {
		if (a1[i] != a2[i])
		{
		    return false;
		}
	    }
	    return true;
	}
	return false;
    }
}

Result

515889.45 ns
 36280.79 ns

Note: It's good to keep in mind that SequenceEqual on large equal arrays is more than ten times slower than a loop.

However: I have been tempted to use SequenceEqual in this sort of situation, as to compare byte arrays. But it really hinders performance.

Summary. The SequenceEqual extension method is an easy way to compare two arrays or other collections such as Lists for equality. Any argument to SequenceEqual must implement the IEnumerable interface, which reduces the range of compatible types.

Related Links