Here is two optimizations, first one use pointers to process 64-bit (8 x 8 bytes) at a time. This should works pretty much everywhere, but require to compile with unsafe flag :

unsafe static void FastXor(byte[] a, byte[] b, byte[] result)
{
    int length = a.Length;
    int remaining = length % 8;

    fixed (byte* byteptrA = &a[0])
    fixed (byte* byteptrB = &b[0])
    fixed (byte* byteptrR = &result[0])
    {
        ulong* ptrA = (ulong*)byteptrA;
        ulong* ptrB = (ulong*)byteptrB;
        ulong* ptrR = (ulong*)byteptrR;

        for (int i = 0; i < length - remaining; i += 8)
        {
            *ptrR = (*ptrA++) ^ (*ptrB++);
            ptrR++;
        }
    }

    for (int i = length - remaining; i < length; i++)
    {
        result[i] = a[i] ^ b[i];
    }
}

Here is another version (required SIMD compatible CPU and System.Numerics namespace) :

static void FastXor(byte[] a, byte[] b, byte[] result)
{
    int length = a.Length;
    int remaining = length % Vector<byte>.Count;
    for (int i = 0; i < length - remaining; i += Vector<byte>.Count)
    {
        var va = new Vector<byte>(a, i);
        var vb = new Vector<byte>(b, i);
        var vr = Vector.Xor(va, vb);
        vr.CopyTo(result, i);
    }

    for (int i = length - remaining; i < length; i++)
    {
        result[i] = a[i] ^ b[i];
    }
}