Tester si toutes les valeurs d'une liste sont uniques

J'ai une petite liste d'octets et je veux tester que ce sont toutes des valeurs différentes. Par exemple, j'ai ceci:

List<byte> theList = new List<byte> { 1,4,3,6,1 };

Quelle est la meilleure façon de vérifier si toutes les valeurs sont distinctes ou non?

bool isUnique = theList.Distinct().Count() == theList.Count();

Voici une autre approche plus efficace que Enumerable.Distinct+ Enumerable.Count(d'autant plus si la séquence n'est pas de type collection). Il utilise un HashSet<T>qui élimine les doublons, est très efficace dans les recherches et possède une propriété count:

var distinctBytes = new HashSet<byte>(theList);
bool allDifferent = distinctBytes.Count == theList.Count;

ou une autre approche - plus subtile et efficace -:

var diffChecker = new HashSet<byte>();
bool allDifferent = theList.All(diffChecker.Add);

HashSet<T>.Addrenvoie falsesi l'élément n'a pas pu être ajouté car il était déjà dans le HashSet. Enumerable.Alls'arrête sur le premier "faux".

D'accord, voici la méthode la plus efficace à laquelle je puisse penser en utilisant .Net standard

using System;
using System.Collections.Generic;

public static class Extension
{
    public static bool HasDuplicate<T>(
        this IEnumerable<T> source,
        out T firstDuplicate)
    {
        if (source == null)
        {
            throw new ArgumentNullException(nameof(source));
        }

        var checkBuffer = new HashSet<T>();
        foreach (var t in source)
        {
            if (checkBuffer.Add(t))
            {
                continue;
            }

            firstDuplicate = t;
            return true;
        }

        firstDuplicate = default(T);
        return false;
    }
}

essentiellement, quel est l'intérêt d'énumérer la séquence entière deux fois si tout ce que vous voulez faire est de trouver le premier doublon.

Je pourrais optimiser cela davantage en enveloppant spécialement une séquence d'élément vide et unique, mais cela déprécierait de la lisibilité / maintenabilité avec un gain minimal.

La logique similaire à l' Distinctutilisation GroupBy:

var isUnique = theList.GroupBy(i => i).Count() == theList.Count;

On peut aussi faire: Utiliser Hashset

var uniqueIds = new HashSet<long>(originalList.Select(item => item.Id));

            if (uniqueIds.Count != originalList.Count)
            {
            }

Il existe de nombreuses solutions.

Et sans doute de plus beaux avec l'utilisation de LINQ comme "juergen d" et "Tim Schmelter" mentionnés.

Mais, si vous mettez à nu la «complexité» et la vitesse, la meilleure solution sera de l'implémenter par vous-même. Une des solutions sera de créer un tableau de taille N (pour l'octet, c'est 256). Et bouclez le tableau, et à chaque itération, testera l'index numérique correspondant si la valeur est 1 si c'est le cas, cela signifie que j'incrémente déjà l'index du tableau et que le tableau n'est donc pas distinct, sinon je vais incrémenter la cellule du tableau et continuer à vérifier .

Et une autre solution, si vous voulez trouver des valeurs dupliquées.

var values = new [] { 9, 7, 2, 6, 7, 3, 8, 2 };

var sorted = values.ToList();
sorted.Sort();
for (var index = 1; index < sorted.Count; index++)
{
    var previous = sorted[index - 1];
    var current = sorted[index];
    if (current == previous)
        Console.WriteLine(string.Format("duplicated value: {0}", current));
}

Production:

duplicated value: 2
duplicated value: 7

http://rextester.com/SIDG48202

Je vérifie si un IEnumerable (aray, liste, etc.) est unique comme ceci:

var isUnique = someObjectsEnum.GroupBy(o => o.SomeProperty).Max(g => g.Count()) == 1;