Hafthor - 2 months ago 21

C# Question

How can I do this fast?

Sure I can do this:

`static bool ByteArrayCompare(byte[] a1, byte[] a2)`

{

if (a1.Length != a2.Length)

return false;

for (int i=0; i<a1.Length; i++)

if (a1[i]!=a2[i])

return false;

return true;

}

But I'm looking for either a BCL function or some highly optimized proven way to do this.

`java.util.Arrays.equals((sbyte[])(Array)a1, (sbyte[])(Array)a2);`

works nicely, but it doesn't look like that would work for x64.

Note my super-fast answer here.

Answer

User *gil* suggested unsafe code which spawned this solution:

```
// Copyright (c) 2008-2013 Hafthor Stefansson
// Distributed under the MIT/X11 software license
// Ref: http://www.opensource.org/licenses/mit-license.php.
static unsafe bool UnsafeCompare(byte[] a1, byte[] a2) {
if(a1==null || a2==null || a1.Length!=a2.Length)
return false;
fixed (byte* p1=a1, p2=a2) {
byte* x1=p1, x2=p2;
int l = a1.Length;
for (int i=0; i < l/8; i++, x1+=8, x2+=8)
if (*((long*)x1) != *((long*)x2)) return false;
if ((l & 4)!=0) { if (*((int*)x1)!=*((int*)x2)) return false; x1+=4; x2+=4; }
if ((l & 2)!=0) { if (*((short*)x1)!=*((short*)x2)) return false; x1+=2; x2+=2; }
if ((l & 1)!=0) if (*((byte*)x1) != *((byte*)x2)) return false;
return true;
}
}
```

which does 64-bit based comparison for as much of the array as possible. This kind of counts on the fact that the arrays start qword aligned. It'll work if not qword aligned, just not as fast as if it were.

It performs about seven timers faster than the simple `for`

loop. Using the J# library performed equivalently to the original `for`

loop. Using .SequenceEqual runs around seven times slower; I think just because it is using IEnumerator.MoveNext. I imagine LINQ-based solutions being at least that slow or worse.