평등을위한 두 개의 목록 <string> 비교

Question

내가 (.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); 

Answer 1

많은 테스트 프레임 워크는 CollectionAssert 클래스를 제공 참조 :

CollectionAssert.AreEqual(expected, actual); 

예를 MS Test

Answer 2

다음

var equal = expected.SequenceEqual(actual); 

테스트 버전

Assert.IsTrue(actual.SequenceEqual(expected)); 

시도

SequenceEqual 확장 메서드는 컬렉션의 요소를 비교하여 동일한 지 확인합니다.

는 http://msdn.microsoft.com/en-us/library/bb348567(v=vs.100).aspx

Answer 3

당신은 항상 필요한 기능을 직접 작성할 수 있습니다

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)); 

Answer 4

원래 코드가 작동하지 않는 이유는 아무도 알려지지 않았습니다. 이는 == 연산자가 일반적으로 연산자가 overloaded이 아닌 한 reference equality (즉, 두 인스턴스가 메모리의 같은 객체를 가리키는 경우)을 테스트하기 때문입니다. List<T>은 == 연산자를 정의하지 않으므로 기본 참조 같음 구현이 사용됩니다.

다른 포스터에서 설명한 것처럼 일반적으로 "컬렉션 평등성"을 테스트하기 위해 요소를 단계별로 따라야합니다. 물론, 사용자 DreamWalker이 제안한 최적화를 사용하여 먼저 수집 횟수를 테스트 한 후이를 수행해야합니다.

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; 
     } 
    } 

을 그래서 같이 호출 :

Answer 5

당신과 같이 확장 방법을 쓸 수

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); 

Answer 6

내가 만든이 확장 메서드는 두 목록의 순서가 동일 할 필요가 없으며 Equals 메서드가 재정의되어있는 한 복잡한 형식에서도 작동합니다.

다음 두 목록은 사실 반환 :

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(); 
} 

Answer 7

는 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(); 
} 

Answer 8

주문 사항의 경우 :

는 순서는 중요하지 않는 경우

bool equal = a.Count == b.Count && new HashSet<string>(a).SetEquals(b); 

의