Liste distincte d'objets basée sur une clé arbitraire dans LINQ

J'ai quelques objets:

class Foo {
    public Guid id;
    public string description;
}

var list = new List<Foo>();
list.Add(new Foo() { id = Guid.Empty, description = "empty" });
list.Add(new Foo() { id = Guid.Empty, description = "empty" });
list.Add(new Foo() { id = Guid.NewGuid(), description = "notempty" });
list.Add(new Foo() { id = Guid.NewGuid(), description = "notempty2" });

Je voudrais processus de cette liste de telle manière que la id domaine est unique, et jetez le non-objets uniques (basée sur l'id).

Du mieux que je pouvais venir avec est:

list = list.GroupBy(i => i.id).Select(g=>g.First()).ToList();

Est-il une plus belle/mieux/le plus rapide pour obtenir le même résultat.

source d'informationauteur Sam Saffron

  1. 21

    Un très élégant et l'intention de révéler option est de définir une nouvelle méthode d'extension sur IEnumerable

    De façon à avoir: 

    list = list.Distinct(foo => foo.id).ToList();

    Et ... 

        public static IEnumerable<T> Distinct<T,TKey>(this IEnumerable<T> list, Func<T,TKey> lookup) where TKey : struct {
        return list.Distinct(new StructEqualityComparer<T, TKey>(lookup));
    }


    class StructEqualityComparer<T,TKey> : IEqualityComparer<T> where TKey : struct {

        Func<T, TKey> lookup;

        public StructEqualityComparer(Func<T, TKey> lookup) {
            this.lookup = lookup;
        }

        public bool Equals(T x, T y) {
            return lookup(x).Equals(lookup(y));
        }

        public int GetHashCode(T obj) {
            return lookup(obj).GetHashCode();
        }
    }

    Un analogue de la classe helper peut être construit pour comparer des objets. (Il faudra faire mieux la gestion des valeurs null)

  2. 14

    À l'aide de la Distinct() méthode est d'environ 4x plus rapide que l'utilisation GroupBy() dans mes tests informels. Pour 1 million de Foo mon test a Distinct() à propos de 0.89 secondes pour faire une gamme unique de sortir d'un tableau où GroupBy() prend environ 3,4 secondes.

    Mon Distinct() appel ressemble,

    var unique = list.Distinct(FooComparer.Instance).ToArray();

    et FooComparer ressemble,

    class FooComparer : IEqualityComparer<Foo> {
    public static readonly FooComparer Instance = new FooComparer();

    public bool Equals(Foo x, Foo y) {
        return x.id.Equals(y.id);
    }

    public int GetHashCode(Foo obj) {
        return obj.id.GetHashCode();
    }
}

    et mon GroupBy() version ressemble,

    var unique = (from l in list group l by l.id into g select g.First()).ToArray();
  3. 1

    Créer un IEqualityComparer<Foo> qui renvoie true si l'id des champs sont les mêmes, et le passer à l'Distinctes() de l'opérateur.

  4. 1
    using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            var list = new List<Foo>();
            list.Add(new Foo() { id = Guid.Empty, description = "empty" });
            list.Add(new Foo() { id = Guid.Empty, description = "empty" });
            list.Add(new Foo() { id = Guid.NewGuid(), description = "notempty" });
            list.Add(new Foo() { id = Guid.NewGuid(), description = "notempty2" });

            var unique = from l in list
                         group l by new { l.id, l.description } into g
                         select g.Key;
            foreach (var f in unique)
                Console.WriteLine("ID={0} Description={1}", f.id,f.description);
            Console.ReadKey(); 
        }
    }

    class Foo
    {
        public Guid id;
        public string description;
    }
}
  5. 1

    Remplacer Equals(object obj) et GetHashCode() méthodes:

    class Foo
{
    public readonly Guid id;
    public string description;

    public override bool Equals(object obj)
    {
        return ((Foo)obj).id == id;
    }
    public override int GetHashCode()
    {
        return id.GetHashCode();
    }
}

    et puis il suffit d'appeler Distinct():

    list = list.Distinct().ToList();