Déterminer si un IEnumerable<T> qui contient un objet d'un autre IEnumberable<T>

Il serait plus rapide d'utiliser le méthode au lieu de la Count méthode:

return x.Intersect<int>(y).Any();

Cela suppose que le IEnumerable<int> mise en œuvre n'est pas aussi mettre en œuvre ICollection<int>. Dans ce cas, Count (dans le cas où IEnumerable<T> implémente ICollection<T>) est un O(N) opérations, alors Any est toujours un O(1). (il vérifie uniquement pour une unique élément). Toutefois, le comportement de Count est un détail d'implémentation, et vous ne devriez pas compter sur cela.

J'ai écrit à ce sujet plus en profondeur dans un billet de blog qui va dans le détail sur l'utilisation de Count() vs Any(). En résumé:

• NE utilisation Enumerable.Any extension de la méthode de vérification de l'existence d'éléments dans la séquence.
• NE PAS utilisation Enumerable.Count méthode d'extension dans les comparaisons par rapport à zéro, comme les suivantes sont sémantiquement équivalentes:
  • sequence.Count() == 0
  • !sequence.Any()
• NE PAS utiliser le Enumerable.Count méthode d'extension dans les comparaisons avec les “pas de zéro” de l'état, comme le sont sémantiquement équivalentes:
  • sequence.Count != 0
  • sequence.Any()

OriginalL'auteur casperOne

Intersect est d'accord, mais comme d'autres l'ont dit, je ne dirais pas .Count() sur le résultat.

La raison en est qui se Croisent ne pas créer l'intersection des deux listes. Il crée un IEnumerable qui est capable de l'énumération cette intersection, mais il ne fait pas d'énumérer ces résultats encore. La plupart des travaux est différée jusqu'au moment où vous avez enfin parcourir cette énumération.

Le problème avec Count est qu'il ne itérer sur l'ensemble de l'énumération. Ainsi, non seulement faut-il toujours compter tous les résultats, mais il cause tout le travail impliqué dans le calcul de ces résultats à terme.

Appel Any au contraire sera très rapide par comparaison, parce que vous permettra de calculer au plus une intersection résultat avant de retourner. Bien sûr, dans le cas où il n'y a pas de matches, il sera toujours nécessaire de réitérer la totalité de la liste. Cependant, ce n'est pas pire qu'avant. En fait, c'est encore plus rapide parce que Jon Skeet mentionné, la Intersect fonction utilise un HashSet pour calculer les résultats, plutôt que de parcourir tout. Votre meilleure et la moyenne des cas sont considérablement améliorées.

C'est comme la différence entre ces deux extraits:

int count = 0;
foreach (int i in x)
{
   foreach (int j in y)
   {
      if (i==j) count++;
   }
}
return (count > 0);

.

//this one should look familiar
foreach (int i in x)
{
    foreach (int j in y)
    {
       if (i==j) return true;
    }
}
return false;

Évidemment le 2ème est beaucoup plus rapide que la moyenne. La performance de Any() serait analogue (pas le même que, grâce à la HashSet) le 2ème extrait de code, tandis que Count() serait analogue à la première.

OriginalL'auteur Joel Coehoorn

Cette question et la dernière réponse sont plus de 1 an de ma réponse; cependant, mes conclusions diffèrent de la accepté de répondre. Je trouve que la boucle est significativement plus rapide que l'utilisation se Croisent.(). Peut-être ma référence en matière de code n'est pas bon?

Voici le code que j'ai utilisé pour trouver le nombre d'itérations par seconde entre se Croisent, les boucles imbriquées, et une boucle avec IndexOf. S'il vous plaît excusez le VB. 😉

Dim ArrayLength As Integer = 50
Dim doesContain As Boolean = False
Dim counter As Integer = 0
Dim sw As New System.Diagnostics.Stopwatch()
Dim BigArray1 As String() = New String(ArrayLength) {}
Dim BigArray2 As String() = New String(ArrayLength) {}
Dim rand As New Random(DateTime.Now.Millisecond)
For i As Integer = 0 To ArrayLength
BigArray1(i) = Convert.ToChar(rand.Next(0, 255)).ToString()
BigArray2(i) = Convert.ToChar(rand.Next(0, 255)).ToString()
Next
Dim AnEnumerable1 As IEnumerable(Of String) = BigArray1
Dim AnEnumerable2 As IEnumerable(Of String) = BigArray2
counter = 0
sw.Restart()
Do
doesContain = False
For Each x As String In AnEnumerable1
For Each y As String In AnEnumerable2
If x.Equals(y) Then
doesContain = True
Exit For
End If
Next
If doesContain Then Exit For
Next
counter += 1
Loop While sw.ElapsedMilliseconds < 1000
Console.WriteLine("InnerLoop iterated:  " & counter.ToString() & " times in " & sw.ElapsedMilliseconds.ToString() & "ms.")
counter = 0
sw.Restart()
Do
doesContain = AnEnumerable1.Intersect(AnEnumerable2).Any()
counter += 1
Loop While sw.ElapsedMilliseconds < 1000
Console.WriteLine("Intersect iterated:  " & counter.ToString() & " times in " & sw.ElapsedMilliseconds.ToString() & "ms.")
counter = 0
sw.Restart()
Do
For Each x As String In AnEnumerable1
If Array.IndexOf(Of String)(BigArray2, x) <> -1 Then
Exit For
End If
Next
counter += 1
Loop While sw.ElapsedMilliseconds < 1000
Console.WriteLine("IndexOf iterated:    " & counter.ToString() & " times in " & sw.ElapsedMilliseconds.ToString() & "ms.")

Mes résultats sur deux de 5 000 000 de point de tableaux. Plus d'itérations est mieux:

• InnerLoop réitéré: 2974553 fois dans 1000ms.
• Se croisent réitéré: 4 fois dans 1168ms.
• IndexOf réitéré: 4194423 fois dans 1000ms.

Mes résultats sur deux 50 tableaux. Plus d'itérations est mieux:

• InnerLoop réitéré: 375712 fois dans 1000ms.
• Se croisent réitéré: 203721 fois dans 1000ms.
• IndexOf réitéré: 668421 fois dans 1000ms.

OriginalL'auteur Nick VanderPyle