带字节数组的c#排序列表不'；行不通

我创建如下列表：

private List<byte[]> shaList = new List<byte[]>();

shaList.Sort();

List<byte[]> shaList = new List<byte[]>();
shaList.Sort(new ByteArrayComparer());

但它抛出了一个例外：

Unbehandelte Ausnahme: System.InvalidOperationException: Fehler beim Vergleichen
von zwei Elementen im Array. ---> System.ArgumentException: Mindestens ein 
Objekt muss IComparable implementieren.
bei System.Collections.Comparer.Compare(Object a, Object b)
bei System.Collections.Generic.ObjectComparer`1.Compare(T x, T y)
bei System.Collections.Generic.ArraySortHelper`1.SwapIfGreaterWithItems(T[] 
keys, IComparer`1 comparer, Int32 a, Int32 b)
bei System.Collections.Generic.ArraySortHelper`1.QuickSort(T[] keys, Int32 
left, Int32 right, IComparer`1 comparer)
bei System.Collections.Generic.ArraySortHelper`1.Sort(T[] keys, Int32 index,
Int32 length, IComparer`1 comparer)
--- Ende der internen Ausnahmestapelüberwachung ---
bei System.Collections.Generic.ArraySortHelper`1.Sort(T[] keys, Int32 index,
Int32 length, IComparer`1 comparer)
bei System.Array.Sort[T](T[] array, Int32 index, Int32 length, IComparer`1 
comparer)
bei System.Collections.Generic.List`1.Sort(Int32 index, Int32 count, I
Comparer`1 comparer)
bei System.Collections.Generic.List`1.Sort()

我自己一点也不知道如何分类。我在学校只有冒泡排序和插入排序，但是用冒泡排序对数百万个哈希进行排序。。。xD

---

//3vilc00kie

由于您试图使用字节数组对列表进行排序，因此出现异常。由于byte[]未实现

IComparable

，因此无法执行此操作

，因为您试图使用字节数组对列表进行排序，因此会出现异常。由于字节[]不实现

IComparable

您不能这样做

您可以实现自定义比较器：

list.OrderBy(b => BitConverter.ToInt64(b, 0))

class ByteArrayComparer : IComparer<byte[]> {
    public int Compare(byte[] x, byte[] y) {
        // implement your comparison criteria here
    }
}

class ByteArrayComparer:IComparer{
公共整数比较（字节[]x，字节[]y）{
//在这里实现您的比较标准
}
}

然后对列表进行如下排序：

private List<byte[]> shaList = new List<byte[]>();

shaList.Sort();

List<byte[]> shaList = new List<byte[]>();
shaList.Sort(new ByteArrayComparer());

List shaList=new List（）；
shaList.Sort（新的ByteArrayComparer（））；

此处定义了比较函数应返回的内容：

基本上，您必须返回：

• 如果x
• 如果x==y，则为0
• >如果x>y，则为0

---

您可以实现自定义比较器：

class ByteArrayComparer : IComparer<byte[]> {
    public int Compare(byte[] x, byte[] y) {
        // implement your comparison criteria here
    }
}

class ByteArrayComparer:IComparer{
公共整数比较（字节[]x，字节[]y）{
//在这里实现您的比较标准
}
}

然后对列表进行如下排序：

private List<byte[]> shaList = new List<byte[]>();

shaList.Sort();

List<byte[]> shaList = new List<byte[]>();
shaList.Sort(new ByteArrayComparer());

List shaList=new List（）；
shaList.Sort（新的ByteArrayComparer（））；

此处定义了比较函数应返回的内容：

基本上，您必须返回：

• 如果x
• 如果x==y，则为0
• >如果x>y，则为0

---

您可以对

字节[]进行排序

，但如何对

列表进行排序？哪个阵列在前，哪个阵列在后？Y

下面是一个使用重载的示例，它进行
比较
。它比较所有字节的总和

shaList.Sort((b1, b2) => b1.Sum(b => b).CompareTo(b2.Sum(b => b)));

您可以对
字节[]
进行排序，但您希望如何对
列表进行排序？哪个阵列在前，哪个阵列在后？Y

下面是一个使用重载的示例，它进行
比较
。它比较所有字节的总和

shaList.Sort((b1, b2) => b1.Sum(b => b).CompareTo(b2.Sum(b => b)));

不清楚你想要什么，但可能是：

shaList.Sort(System.Collections.StructuralComparisons.StructuralComparer.Compare);

是.NET 4.0版（2010）中引入的
静态类。它的属性
structuriccomparer
给出了一个对象，该对象“按结构”进行比较，这类似于在数组（或元组）中的每个条目之后按字典顺序进行比较。它通过方法
比较
；上面，
Compare
通过方法组转换转换为委托

重要补充：这似乎只适用于列表中所有字节数组长度相同的情况

测试代码：

static void Main()
{
    var shaList = new List<byte[]>
    {
        new byte[] { 20, 29, },
        new byte[] { 22, 29, },
        new byte[] { 2, 255, },
        new byte[] { 22, 0, },
    };

    shaList.Sort(System.Collections.StructuralComparisons.StructuralComparer.Compare);
}

static void Main（）
{
var shaList=新列表
{
新字节[]{20，29，}，
新字节[]{22,29，}，
新字节[]{2255，}，
新字节[]{22，0，}，
};
shaList.Sort（系统.集合.结构比较.结构比较.比较）；
}
不清楚您想要什么，但可能是：

shaList.Sort(System.Collections.StructuralComparisons.StructuralComparer.Compare);

是.NET 4.0版（2010）中引入的
静态类。它的属性
structuriccomparer
给出了一个对象，该对象“按结构”进行比较，这类似于在数组（或元组）中的每个条目之后按字典顺序进行比较。它通过方法
比较
；上面，
Compare
通过方法组转换转换为委托

重要补充：这似乎只适用于列表中所有字节数组长度相同的情况

测试代码：

static void Main()
{
    var shaList = new List<byte[]>
    {
        new byte[] { 20, 29, },
        new byte[] { 22, 29, },
        new byte[] { 2, 255, },
        new byte[] { 22, 0, },
    };

    shaList.Sort(System.Collections.StructuralComparisons.StructuralComparer.Compare);
}

static void Main（）
{
var shaList=新列表
{
新字节[]{20，29，}，
新字节[]{22,29，}，
新字节[]{2255，}，
新字节[]{22，0，}，
};
shaList.Sort（系统.集合.结构比较.结构比较.比较）；
}
Array.Sort（）
接受
IComparer
接口实现或
比较
委托。在这两种情况下，如所述，您必须编写一个接受两字节数组并返回数值比较结果的函数

下面是一个简洁的实现，可以有效地实现这一点：

int CompareByteArrays(byte[] a, byte[] b)
{
    var length = Math.Min(a.Length, b.Length);
    for (var i = 0; i < length; i++)
    {
        var diff = a[i] - b[i];
        if (diff != 0)
            return diff;
    }
    return a.Length - b.Length;
}

int比较字节数组（字节[]a，字节[]b）
{
变量长度=数学最小值（a.长度，b.长度）；
对于（变量i=0；i
Array.Sort（）
接受
IComparer
接口实现或
比较
委托。在这两种情况下，如所述，您必须编写一个接受两字节数组并返回数值比较结果的函数

下面是一个简洁的实现，可以有效地实现这一点：

int CompareByteArrays(byte[] a, byte[] b)
{
    var length = Math.Min(a.Length, b.Length);
    for (var i = 0; i < length; i++)
    {
        var diff = a[i] - b[i];
        if (diff != 0)
            return diff;
    }
    return a.Length - b.Length;
}

int比较字节数组（字节[]a，字节[]b）
{
变量长度=数学最小值（a.长度，b.长度）；
对于（变量i=0；i
我偶然发现了这个问题，这个问题很老了，但非常接近我现在要做的事情，这就是为什么我想为这篇文章做贡献。我正在尝试对一个
列表进行排序，它的值基本上是散列值，这就是我想到的：

[SuppressUnmanagedCodeSecurity]
internal static class NativeMethods
{
    [DllImport("MSVCRT.dll", CallingConvention=CallingConvention.Cdecl, ExactSpelling=true)]
    private static extern Int32 memcmp([In] IntPtr pointer1, [In] IntPtr pointer2, [In] UIntPtr count);

    internal static Int32 CompareSequences(Byte[] array1, Byte[] array2)
    {
        if (ReferenceEquals(array1, array2))
            return 0;

        if (array1 == null)
            return 1;

        if (array2 == null)
            return -1;

        if (array1.Length != array2.Length)
            return -Math.Min(Math.Max(array1.Length - array2.Length, -1), 1);

        unsafe
        {
            fixed (Byte* pointer1 = array1, pointer2 = array2)
                return -Math.Min(Math.Max(memcmp((IntPtr)pointer1, (IntPtr)pointer2, (UIntPtr)array1.Length), -1), 1);
        }
    }
}

用法：

List<Byte[]> hashes = ComputeHashes();
hashes.Sort(NativeMethods.CompareSequences);

我偶然发现了这个问题，这个问题很古老，但非常接近我现在试图做的事情，这就是为什么我想为这篇文章做贡献。我正在尝试对一个
列表进行排序，它的值基本上是散列值，这就是我想到的：

[SuppressUnmanagedCodeSecurity]
internal static class NativeMethods
{
    [DllImport("MSVCRT.dll", CallingConvention=CallingConvention.Cdecl, ExactSpelling=true)]
    private static extern Int32 memcmp([In] IntPtr pointer1, [In] IntPtr pointer2, [In] UIntPtr count);

    internal static Int32 CompareSequences(Byte[] array1, Byte[] array2)
    {
        if (ReferenceEquals(array1, array2))
            return 0;

        if (array1 == null)
            return 1;

        if (array2 == null)
            return -1;

        if (array1.Length != array2.Length)
            return -Math.Min(Math.Max(array1.Length - array2.Length, -1), 1);

        unsafe
        {
            fixed (Byte* pointer1 = array1, pointer2 = array2)
                return -Math.Min(Math.Max(memcmp((IntPtr)pointer1, (IntPtr)pointer2, (UIntPtr)array1.Length), -1), 1);
        }
    }
}

用法：

List<Byte[]> hashes = ComputeHashes();
hashes.Sort(NativeMethods.CompareSequences);

您可以对
字节[]
进行排序，但如何对
字节[]
列表进行排序？哪个数组在前面，哪个数组在最后？您可以对
字节[]
进行排序，但如何对
字节[]
的列表进行排序？哪一个数组先出现，哪一个最后出现？所有SHA的长度肯定相同。。。我会试试这个，因为这是最简单的解决办法。希望是h