Vérification d'une liste avec des valeurs NULL pour les doublons en C #

Question

En C #, je peux utiliser quelque chose comme:

 List<string> myList = new List<string>();

if (myList.Count != myList.Distinct().Count())
{
    // there are duplicates
}
 

pour vérifier les éléments en double dans une liste. Cependant, quand il y a null articles dans la liste, cela produit un faux positif. Je peux le faire en utilisant du code lent, mais existe-t-il un moyen de vérifier les doublons dans une liste tout en ignorant les valeurs nulles de manière concise?

Answer 1

Si vous êtes inquiet au sujet de la performance, le code suivant va s'arrêter dès qu'il trouve le premier article en double - toutes les autres solutions jusqu'à présent exiger de l'ensemble d'entrée d'être répétées au moins une fois.

var hashset = new HashSet<string>();
if (myList.Where(s => s != null).Any(s => !hashset.Add(s)))
{
    // there are duplicates
}

hashset.Add retours false si l'élément existe déjà dans le jeu, et Any retours true dès la première true de la valeur se produit, ce sera seulement à la recherche de l'entrée jusqu'au premier en double.

Answer 2

Je le ferais différemment:

Compte tenu de Linq déclarations seront évalués paresseusement, l' .Any court-circuit ce qui signifie que vous n'avez pas à effectuer une itération & recenser l'ensemble de la liste, si il y a des doublons et en tant que tel, devrait être plus efficace.

var dupes = myList
    .Where(item => item != null)
    .GroupBy(item => item)
    .Any(g => g.Count() > 1);

if(dupes)
{
    //there are duplicates
}

EDIT: http://pastebin.com/b9reVaJu Certains Linqpad de l'analyse comparative qui semble pour conclure GroupBy avec Count() est plus rapide

EDIT 2: Rawling la réponse ci-dessous semble au moins 5x plus rapide que cette approche!

Answer 3

var nonNulls = myList.Where(x => x != null)
if (nonNulls.Count() != nonNulls.Distinct().Count())
{
    // there are duplicates
}

Answer 4

Eh bien, deux Nuls sont des doublons, n'est-ce pas?

Quoi qu'il en soit, comparez la liste sans les nulls:

 var denullified = myList.Where(l => l != null);
if(denullified.Count() != denullified.Distinct().Count()) ...
 

Answer 5

Editer ma première tentative est nul parce que ce n'est pas différé.

au lieu,

 var duplicates = myList
    .Where(item => item != null)
    .GroupBy(item => item)
    .Any(g => g.Skip(1).Any());
 

---

une mise en œuvre moins bonne supprimée