如何最有效地测试两个数组是否包含C#中的等效项

Question

我有两个数组,我想知道它们是否包含相同的项目. Equals(object obj)不起作用,因为数组是引用类型.我在下面发布了我的尝试,但是因为我确定这是一项常见任务,我想知道是否有更好的测试.

    public bool ContainsEquivalentSequence<T>(T[] array1, T[] array2)
    {
        bool a1IsNullOrEmpty = ReferenceEquals(array1, null) || array1.Length == 0;
        bool a2IsNullOrEmpty = ReferenceEquals(array2, null) || array2.Length == 0;
        if (a1IsNullOrEmpty) return a2IsNullOrEmpty;
        if (a2IsNullOrEmpty || array1.Length != array2.Length) return false;
        for (int i = 0; i < array1.Length; i++)
            if (!Equals(array1[i], array2[i]))
                return false;
        return true;
    }

更新 - System.Linq.Enumerable.SequenceEqual并不是更好

我反映了源,并没有比较执行循环之前的长度.这是有道理的,因为该方法通常是IEnumerable<T>为a而不是为a 而设计的T[].

    public static bool SequenceEqual<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
    {
        if (comparer == null)
        {
            comparer = EqualityComparer<TSource>.Default;
        }
        if (first == null)
        {
            throw Error.ArgumentNull("first");
        }
        if (second == null)
        {
            throw Error.ArgumentNull("second");
        }
        using (IEnumerator<TSource> enumerator = first.GetEnumerator())
        {
            using (IEnumerator<TSource> enumerator2 = second.GetEnumerator())
            {
                while (enumerator.MoveNext())
                {
                    if (!enumerator2.MoveNext() || !comparer.Equals(enumerator.Current, enumerator2.Current))
                    {
                        return false;
                    }
                }
                if (enumerator2.MoveNext())
                {
                    return false;
                }
            }
        }
        return true;
    }

Answer 1

我做了使用一些测试Any,Contains,All和SequenceEqual后来我选择了最好的3.

不同的输入有不同的结果......

两个大小为100的相同数组:SequenceEqual更快

[     SequenceEqual: 00:00:00.027   ]*
[     ContainsEqSeq: 00:00:00.046   ]
[          Parallel: 00:00:00.281   ]

两个大小为1000的相同数组:SequenceEqual更快

[     SequenceEqual: 00:00:00.240   ]*
[     ContainsEqSeq: 00:00:00.361   ]
[          Parallel: 00:00:00.491   ]

两个大小为10000的相同数组:Parallel更快

[     SequenceEqual: 00:00:02.357   ]
[     ContainsEqSeq: 00:00:03.341   ]
[          Parallel: 00:00:01.688   ]*

两个大小相同的阵列50000:Parallel踢屁股

[     SequenceEqual: 00:00:11.824   ]
[     ContainsEqSeq: 00:00:17.206   ]
[          Parallel: 00:00:06.811   ]*

两个阵列在位置200处有一个差异:SequenceEqual更快

[     SequenceEqual: 00:00:00.050   ]*
[     ContainsEqSeq: 00:00:00.075   ]
[          Parallel: 00:00:00.332   ]

两个阵列在位置0处有一个差异:ContainsEqSeq并且SequenceEqual更快

[     SequenceEqual: 00:00:00.002   ]*
[     ContainsEqSeq: 00:00:00.001   ]*
[          Parallel: 00:00:00.211   ]

两个阵列在位置999处有一个差异:SequenceEqual更快

[     SequenceEqual: 00:00:00.237   ]*
[     ContainsEqSeq: 00:00:00.330   ]
[          Parallel: 00:00:00.691   ]

两个阵列在位置9999处有一个差异:Parallel踢屁股

[     SequenceEqual: 00:00:02.386   ]
[     ContainsEqSeq: 00:00:03.417   ]
[          Parallel: 00:00:01.614   ]*

代码SequenceEqual是

a1.SequenceEqual(a2)

代码ContainsEqSeq是你的方法.

代码Parallel是

bool a1IsNullOrEmpty = ReferenceEquals(a1, null) || a1.Length == 0;
bool a2IsNullOrEmpty = ReferenceEquals(a2, null) || a2.Length == 0;
if (a1IsNullOrEmpty) return a2IsNullOrEmpty;
if (a2IsNullOrEmpty || a1.Length != a2.Length) return false;

var areEqual = true;
Parallel.ForEach(a1,
    (i, s, x) =>
    {
        if (a1[x] != a2[x])
        {
            areEqual = false;
            s.Stop();
        }
    });

return areEqual;

我会说最好的一个取决于你的输入.

如果你将使用巨大的数组(如10000+)我会说Parallel是最好的选择,它只会在开始时有差异时失败.

对于其他情况SequenceEqual可能是最好的,我只测试过int[],但我相信它也可以快速复杂类型.

但请记住,结果会因输入而异.