我在这里没有看到很多linq解决方案。

我不确定性能的影响，但我通常坚持linq作为经验法则，然后在必要时进行优化。

public bool CompareTwoArrays(byte[] array1, byte[] array2)
 {
   return !array1.Where((t, i) => t != array2[i]).Any();
 }

请注意，这只适用于它们是相同大小的数组。 一个扩展可能是这样的

public bool CompareTwoArrays(byte[] array1, byte[] array2)
 {
   if (array1.Length != array2.Length) return false;
   return !array1.Where((t, i) => t != array2[i]).Any();
 }

如果你不反对这样做，你可以导入j#程序集“vjslib.dll”并使用它的数组。= (byte[]， byte[])方法…

如果有人嘲笑你，不要怪我……

编辑:为了它的价值，我使用Reflector来反汇编代码，下面是它的样子:

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

看看。net是如何处理字符串的。Equals，你可以看到它使用了一个叫做EqualsHelper的私有方法，它有一个“不安全”的指针实现。net Reflector是你的朋友，可以看到内部是如何完成的。

这可以用作字节数组比较的模板，我在博客文章中用c#快速字节数组比较中做了一个实现。我还做了一些基本的基准测试，看看什么时候安全的实现比不安全的实现更快。

也就是说，除非你真的需要杀手级的性能，否则我会选择简单的fr循环比较。

你可以使用Enumerable。SequenceEqual方法。

using System;
using System.Linq;
...
var a1 = new int[] { 1, 2, 3};
var a2 = new int[] { 1, 2, 3};
var a3 = new int[] { 1, 2, 4};
var x = a1.SequenceEqual(a2); // true
var y = a1.SequenceEqual(a3); // false

如果你因为某些原因不能使用. net 3.5，你的方法是可以的。 编译器运行时环境会优化你的循环，所以你不需要担心性能。

我想到了许多显卡内置的块传输加速方法。但是这样你就必须按字节复制所有的数据，所以如果你不想在非托管和依赖硬件的代码中实现你的整个逻辑，这对你没有多大帮助……

Another way of optimization similar to the approach shown above would be to store as much of your data as possible in a long[] rather than a byte[] right from the start, for example if you are reading it sequentially from a binary file, or if you use a memory mapped file, read in data as long[] or single long values. Then, your comparison loop will only need 1/8th of the number of iterations it would have to do for a byte[] containing the same amount of data. It is a matter of when and how often you need to compare vs. when and how often you need to access the data in a byte-by-byte manner, e.g. to use it in an API call as a parameter in a method that expects a byte[]. In the end, you only can tell if you really know the use case...

 using System.Linq; //SequenceEqual

 byte[] ByteArray1 = null;
 byte[] ByteArray2 = null;

 ByteArray1 = MyFunct1();
 ByteArray2 = MyFunct2();

 if (ByteArray1.SequenceEqual<byte>(ByteArray2) == true)
 {
    MessageBox.Show("Match");
 }
 else
 {
   MessageBox.Show("Don't match");
 }