LINQ: select elements that only appear once in a list

I have a list of objects, can be of any type T.

How to select a list of objects that appear in that list only once using linq? For开发者_如何学Python example, if my list is {2,3,4,5,8,2,3,5,4,2,3,4,6}, then the output should be {6,8}.

You could try this:

int[] arr = { 2, 3, 4, 5, 8, 2, 3, 5, 4, 2, 3, 4, 6 };
var q =
    from g in arr.GroupBy(x => x)
    where g.Count() == 1
    select g.First();

Use the Count() function.

    int[] a = {2,3,4,5,8,2,3,5,4,2,3,4,6};

    var selection = from i in a
        where (a.Count(n => n == i) == 1)
        select i;

Note: this is not a new answer, only an elaboration on the other answers.

While the OP explicitly asks for an answer using Linq, I think it is worth mentioning that sometimes there are disadvantages to using Linq. It allows for succint and (mostly) very readable code, but it does not always generate the most efficient underlying code (e.g. in the other answers given, the Count method enumerates the complete array everytime it is called).

So sometimes classical procedural code is a better choice.

To illustrate this, I wrote two alternative implementations: one using a dictionary, another using two hashsets. Both methods enumerate the array only once.

The benchmark results:

From these results it is obvious that the 'classical' methods are more performant in terms of execution time and memory allocation (strain on the GC).

The code used to generate these benchmarks:

[MemoryDiagnoser]
public class UniqueSelector
{
    public IEnumerable<int[]> Data()
    {
        var rnd = new Random(1);
        yield return new int[] { 2, 3, 4, 5, 8, 2, 3, 5, 4, 2, 3, 4, 6 };
        yield return Enumerable.Range(0, 1000).Select(i => rnd.Next(1000)).ToArray();
        yield return Enumerable.Range(0, 10000).Select(i => rnd.Next(1000)).ToArray();
    }
         
    [Benchmark]
    [ArgumentsSource(nameof(Data))]
    public int[] GetUniquesByLinq(int[] array)
    {
        var q =
        from g in array.GroupBy(x => x)
        where g.Count() == 1
        select g.First();
        return q.ToArray();
    }

    [Benchmark]
    [ArgumentsSource(nameof(Data))]
    public int[] GetUniquesByDictionary(int[] array)
    {
        var counts = new Dictionary<int, int>();
        foreach (int item in array)
        {
            if (!counts.TryAdd(item, 1)) counts[item]++;
        }
        return counts.Where(kv => kv.Value == 1).Select(kv => kv.Key).ToArray();
    }

    [Benchmark]
    [ArgumentsSource(nameof(Data))]
    public int[] GetUniquesByHashSet(int[] array)
    {
        var uniques = new HashSet<int>();
        var duplicates = new HashSet<int>();
        foreach (int item in array)
        {
            if (duplicates.Contains(item)) continue;
            if (uniques.Contains(item))
            {
                duplicates.Add(item);
                uniques.Remove(item);
                continue;
            }
            uniques.Add(item);
        }
        return uniques.ToArray();
    }
}