c# 在字节数组上应用 64 位 XOR

Question

I want to Apply 64 XOR operation of two byte array. Is this right approach to do with using unsafe

I have tried below approach without using unsafe . but i want little faster than this

for (int i=0; i< oldBlock.Length;i++)
{
{
 oldblock[i] ^= (newblock[i]);
}

Below XOR operation miss last bytes as below code XOR 8 bytes each time.

How to accomplish this.

static void Main(string[] args)
        {


            byte[] a = new byte[10];
            byte[] b = new byte[10];
            Random r = new Random();
            r.NextBytes(a);
            a.CopyTo(b, 0);
            XOr64(a, b);
            foreach (byte c in a)
            {
                Console.WriteLine(c);
            }


            Console.ReadKey();



        }    

public static unsafe void XOr64(byte[] oldBlock, byte[] newblock)
                {
                    try
                    {
                        fixed (byte* byteA = oldBlock)
                        fixed (byte* byteB = newblock)
                        {
                            long* ppA = (long*)byteA;
                            long* ppB = (long*)byteB;

                            for (int p = 0; p < oldBlock.Length/8; p++)
                            {
                                *ppA ^= *ppB;

                                ppA++;
                                ppB++;
                            }
                        }
                    }
                    catch
                    {

                    }



                }

Answer 1

If the 8-byte-at-a-time aspect is working well for you and you're sure you need the extra performance, you can just extend that method to cover the remaining bytes individually - which will be at most 7 bytes:

public static unsafe void XOr64(byte[] oldBlock, byte[] newBlock)
{
    // First XOR as many 64-bit blocks as possible, for the sake of speed
    fixed (byte* byteA = oldBlock)
    fixed (byte* byteB = newBlock)
    {
        long* ppA = (long*) byteA;
        long* ppB = (long*) byteB;

        int chunks = oldBlock.Length / 8;
        for (int p = 0; p < chunks; p++)
        {
            *ppA ^= *ppB;

            ppA++;
            ppB++;
        }
    }

    // Now cover any remaining bytes one byte at a time. We've
    // already handled chunks * 8 bytes, so start there.
    for (int index = chunks * 8; index < oldBlock.Length; index++)
    {
        oldBlock[index] ^= newBlock[index];
    }
}

Answer 2

Here is @Jon Skeet algorithm implemented using Span<> instead of unsafe code:

public static void Xor64(Span<byte> bytes, ReadOnlySpan<byte> mask) {
    int chunks = mask.Length / 8;
    int chunksBounds = chunks * 8;
    Xor64(MemoryMarshal.Cast<byte, long>(bytes[..chunksBounds]), MemoryMarshal.Cast<byte, long>(mask[..chunksBounds]));
    for (int i = chunksBounds;i < mask.Length;i++) {
        bytes[i] ^= mask[i];
    }
}
public static void Xor64(Span<long> longs, ReadOnlySpan<long> mask) {
    for (int i = 0;i < longs.Length;i++) {
        longs[i] ^= mask[i];
    }
}