Méthode d'extension d'intersection, la sensibilité à la casse ne fonctionne pas

Question

J'essaie de comparer le contenu de 2 collections dans un test unitaire en .NET en utilisant MSTEST. Pour rendre les choses simples, au lieu d'avoir à .Sort() et ensuite faire une boucle dans la collection et comparer les éléments un par un, j'ai trouvé la nouvelle et très cool méthode .Intersect Extension.

Il semble fonctionner à merveille en faisant:

  Assert.AreEqual(expected.Count, actual.Intersect(expected).Count) 

Cependant, maintenant que j'ai un test qui doit être sensible à la casse, il se casse. J'ai essayé d'envoyer le second paramètre d'Intersect, StringComparer.Ordinal, StringComparer.InvariantCulture, et StringComparer.CurrentCulture ... pas de chance ..

Quelqu'un l'a déjà ressenti?

merci!

EDIT: voici les données:

Actual: 
    (0) "FOO" String 
    (1) "foo" String 
    (2) "Foo" String 
    (3) "fOo" String 
    (4) "foO" String 
    (5) "BAR" String 
    (6) "BAR" String 
    (7) "BAZ" String 
    (8) "baz" String 
    (9) "foo" String 

Expected: 

    (0) "FOO" String 
    (1) "foo" String 
    (2) "Foo" String 
    (3) "fOo" String 
    (4) "foO" String 
    (5) "BAR" String 
    (6) "BAR" String 
    (7) "BAZ" String 
    (8) "baz" String 
    (9) "foo" String 

actual.Intersect(expected, StringComparer.CurrentCulture) 

    (0) "FOO" String 
    (1) "foo" String 
    (2) "Foo" String 
    (3) "fOo" String 
    (4) "foO" String 
    (5) "BAR" String 
    (6) "BAZ" String 
    (7) "baz" String 

Il semble enlever une correspondance en double 'foo', et un double correspondant 'baz'. Peut-être existe-t-il une meilleure façon d'affirmer que les collections correspondent?

_EDIT2: Je pense que Intersect() supprime les doublons, ce qui explique pourquoi cela se brise. J'ai trouvé la classe CollectionAssert. C'est exactement ce dont j'avais besoin! Merci! _

Answer 1

Pour des fins de test utilisent CollectionAssert.AreEqual(actual, expected)

Vous recherchez SequenceEqual, pas Intersect. Intersect renvoie l'intersection de deux séquences, ie. les éléments partagés entre eux. L'utilisation d'Intersect sur {1, 2, 3} et {3, 4, 5} renvoie 3. SequenceEqual renvoie false.

vous ne trouviez pas CollectionAssert vous auriez pu utiliser:

Assert.IsTrue(actual.SequenceEqual(expected)) 

Answer 2

Mettre en oeuvre un IEqualityComparer comme ceci:

Class StringCaseInsensitiveComparer
    Implements IEqualityComparer(Of String)
    Public Function Equals(ByVal s1 As String, ByVal s2 As String) As Boolean
        Return s1.ToLower() = s2.ToLower()
    End Function
    Public Function GetHashCode(ByVal s As String) As Integer
        Return s.GetHashCode()
    End Function
End Class

Ensuite, appelez cette surcharge de Intersection:

Dim first As IEnumerable(Of TSource)
Dim second As IEnumerable(Of TSource)
Dim comparer As IEqualityComparer(Of TSource)
Dim returnValue As IEnumerable(Of TSource)

faisant passer une instance du comparateur que vous venez de faire.