除了逐个遍历元素之外，我如何比较两个字符串列表是否相等（在 .NET 3.0 中）：
这失败了：
// Expected result.
List<string> expected = new List<string>();
expected.Add( "a" );
expected.Add( "b" );
expected.Add( "c" );
// Actual result
actual = new List<string>();
actual.Add( "a" );
actual.Add( "b" );
actual.Add( "c" );
// Verdict
Assert.IsTrue( actual == expected );
尝试以下
var equal = expected.SequenceEqual(actual);
测试版
Assert.IsTrue( actual.SequenceEqual(expected) );
SequenceEqual 扩展方法将比较集合的元素以求相等。
请参阅http://msdn.microsoft.com/en-us/library/bb348567(v=vs.100).aspx
您始终可以自己编写所需的函数：
public static bool ListEquals<T>(IList<T> list1, IList<T> list2) {
if (list1.Count != list2.Count)
return false;
for (int i = 0; i < list1.Count; i++)
if (!list1[i].Equals(list2[i]))
return false;
return true;
}
并使用它：
// Expected result.
List<string> expected = new List<string>();
expected.Add( "a" );
expected.Add( "b" );
expected.Add( "c" );
// Actual result
actual = new List<string>();
actual.Add( "a" );
actual.Add( "b" );
actual.Add( "c" );
// Verdict
Assert.IsTrue( ListEquals(actual, expected) );
我注意到没有人真正告诉你为什么你的原始代码不起作用。这是因为==运算符通常测试引用相等性（即，如果两个实例指向内存中的同一个对象），除非运算符已被重载。 List<T>未定义==运算符，因此使用基本引用等于实现。
正如其他海报所展示的那样，您通常必须逐步检查元素来测试“集合平等”。当然，您应该使用用户DreamWalker建议的优化，该优化首先测试集合的计数，然后再单步执行。
如果订单很重要：
bool equal = a.SequenceEquals(b);
如果顺序无关紧要：
bool equal = a.Count == b.Count && new HashSet<string>(a).SetEquals(b);
您可以像这样编写扩展方法：
public static class ListExtensions
{
public static bool IsEqual<T>(this IList<T> list,IList<T> target, IComparer<T> comparer) where T:IComparable<T>
{
if (list.Count != target.Count)
{
return false;
}
int index = 0;
while (index < list.Count &&
comparer.Compare(list[index],target[index]) == 0)
{
index++;
}
if (index != list.Count)
{
return false;
}
return true;
}
}
并这样称呼它：
List<int> intList = new List<int> { 1, 234, 2, 324, 324, 2 };
List<int> targetList = new List<int> { 1, 234, 2, 324, 324 };
bool isEqual = intList.IsEqual(targetList, Comparer<int>.Default);
编辑：更新代码以使用静态方法，因为 OP 使用的是 .NET 3.0
public static bool IsEqual<T>(IList<T> sourceList, IList<T> targetList, IComparer<T> comparer) where T : IComparable<T>
{
if (sourceList.Count != targetList.Count)
{
return false;
}
int index = 0;
while (index < sourceList.Count &&
comparer.Compare(sourceList[index], targetList[index]) == 0)
{
index++;
}
if (index != sourceList.Count)
{
return false;
}
return true;
}
客户：
bool isEqual = IsEqual(intList,targetList, Comparer<int>.Default);
使用 Linq 并将代码编写为扩展方法：
public static bool EqualsOtherList<T>(this List<T> thisList, List<T> theOtherList)
{
if (thisList == null || theOtherList == null ||
thisList.Count != theOtherList.Count) return false;
return !thisList.Where((t, i) => !t.Equals(theOtherList[i])).Any();
}
虽然它确实迭代了集合，但我创建的这个扩展方法不需要两个列表的顺序相同，并且它也适用于复杂类型，只要重写 Equals 方法。
以下两个列表将返回 true：
List<string> list1 = new List<string>
{
{ "bob" },
{ "sally" },
{ "john" }
};
List<string> list2 = new List<string>
{
{ "sally" },
{ "john" },
{ "bob" }
};
方法：
public static bool IsEqualTo<T>(this IList<T> list1, IList<T> list2)
{
if (list1.Count != list2.Count)
{
return false;
}
List<T> list3 = new List<T>();
foreach (var item in list2)
{
list3.Add(item);
}
foreach (var item in list1)
{
int index = -1;
for (int x = 0; x < list3.Count; x++)
{
if (list3[x].Equals(item))
{
index = x;
}
}
if (index > -1)
{
list3.RemoveAt(index);
}
else
{
return false;
}
}
return !list3.Any();
}
它可能以非常规方式使用，但没有实现自定义类型的 IEquatable
JsonConvert.SerializeObject( myList1) == JsonConvert.SerializeObject( myList2)
但在一般情况下，您可以使用评论中提到的 SequenceEqual https://docs.microsoft.com/en-us/dotnet/api/system.linq.enumerable.sequenceequal?view=netframework-4.8
也不要忘记为自定义类型实现 IEquatable 接口（对于字符串类型或其他结构不是必需的）