LINQ's Distinct () sur une propriété particulière

Je joue avec LINQ pour en savoir plus, mais je ne sais pas comment l'utiliser Distinctquand je n'ai pas de liste simple (une simple liste d'entiers est assez facile à faire, ce n'est pas la question). Que dois-je faire si je veux utiliser Distinct sur une liste d'objets sur une ou plusieurs propriétés de l'objet?

Exemple: Si un objet l'est Person, avec Propriété Id. Comment puis-je obtenir toutes les personnes et les utiliser Distinctavec la propriété Idde l'objet?

Person1: Id=1, Name="Test1"
Person2: Id=1, Name="Test1"
Person3: Id=2, Name="Test2"

Comment puis-je obtenir juste Person1et Person3? Est-ce possible?

Si ce n'est pas possible avec LINQ, quelle serait la meilleure façon d'avoir une liste en Personfonction de certaines de ses propriétés dans .NET 3.5?

EDIT : Cela fait maintenant partie de MoreLINQ .

Ce dont vous avez besoin, c'est d'un "distinct par" efficace. Je ne pense pas que cela fasse partie de LINQ tel quel, bien qu'il soit assez facile d'écrire:

public static IEnumerable<TSource> DistinctBy<TSource, TKey>
    (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
{
    HashSet<TKey> seenKeys = new HashSet<TKey>();
    foreach (TSource element in source)
    {
        if (seenKeys.Add(keySelector(element)))
        {
            yield return element;
        }
    }
}

Donc, pour trouver les valeurs distinctes en utilisant uniquement la Idpropriété, vous pouvez utiliser:

var query = people.DistinctBy(p => p.Id);

Et pour utiliser plusieurs propriétés, vous pouvez utiliser des types anonymes, qui implémentent correctement l'égalité:

var query = people.DistinctBy(p => new { p.Id, p.Name });

Non testé, mais cela devrait fonctionner (et maintenant il compile au moins).

Il suppose que le comparateur par défaut pour les clés - si vous voulez passer dans un comparateur d'égalité, il suffit de le transmettre au HashSetconstructeur.

Que faire si je souhaite obtenir une liste distincte basée sur une ou plusieurs propriétés?

Facile! Vous voulez les regrouper et choisir un gagnant dans le groupe.

List<Person> distinctPeople = allPeople
  .GroupBy(p => p.PersonId)
  .Select(g => g.First())
  .ToList();

Si vous souhaitez définir des groupes sur plusieurs propriétés, voici comment:

List<Person> distinctPeople = allPeople
  .GroupBy(p => new {p.PersonId, p.FavoriteColor} )
  .Select(g => g.First())
  .ToList();

Utilisation:

List<Person> pList = new List<Person>();
/* Fill list */

var result = pList.Where(p => p.Name != null).GroupBy(p => p.Id).Select(grp => grp.FirstOrDefault());

Le wherevous aide à filtrer les entrées (pourrait être plus complexe) groupbyet à selecteffectuer la fonction distincte.

Vous pouvez également utiliser la syntaxe de requête si vous souhaitez qu'elle ressemble à LINQ:

var uniquePeople = from p in people
                   group p by new {p.ID} //or group by new {p.ID, p.Name, p.Whatever}
                   into mygroup
                   select mygroup.FirstOrDefault();

Je pense que cela suffit:

list.Select(s => s.MyField).Distinct();

Solution, regroupez d'abord vos champs, puis sélectionnez le premier élément par défaut.

    List<Person> distinctPeople = allPeople
   .GroupBy(p => p.PersonId)
   .Select(g => g.FirstOrDefault())
   .ToList();

Vous pouvez le faire avec la norme Linq.ToLookup(). Cela créera une collection de valeurs pour chaque clé unique. Sélectionnez simplement le premier article de la collection

Persons.ToLookup(p => p.Id).Select(coll => coll.First());

Le code suivant est fonctionnellement équivalent à la réponse de Jon Skeet .

Testé sur .NET 4.5, devrait fonctionner sur n'importe quelle version antérieure de LINQ.

public static IEnumerable<TSource> DistinctBy<TSource, TKey>(
  this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
{
  HashSet<TKey> seenKeys = new HashSet<TKey>();
  return source.Where(element => seenKeys.Add(keySelector(element)));
}

Soit dit en passant, consultez la dernière version de Jon Skeet de DistinctBy.cs sur Google Code .

J'ai écrit un article qui explique comment étendre la fonction Distinct afin que vous puissiez faire comme suit:

var people = new List<Person>();

people.Add(new Person(1, "a", "b"));
people.Add(new Person(2, "c", "d"));
people.Add(new Person(1, "a", "b"));

foreach (var person in people.Distinct(p => p.ID))
    // Do stuff with unique list here.

Voici l'article: Extension de LINQ - Spécification d'une propriété dans la fonction distincte

Personnellement, j'utilise la classe suivante:

public class LambdaEqualityComparer<TSource, TDest> : 
    IEqualityComparer<TSource>
{
    private Func<TSource, TDest> _selector;

    public LambdaEqualityComparer(Func<TSource, TDest> selector)
    {
        _selector = selector;
    }

    public bool Equals(TSource obj, TSource other)
    {
        return _selector(obj).Equals(_selector(other));
    }

    public int GetHashCode(TSource obj)
    {
        return _selector(obj).GetHashCode();
    }
}

Ensuite, une méthode d'extension:

public static IEnumerable<TSource> Distinct<TSource, TCompare>(
    this IEnumerable<TSource> source, Func<TSource, TCompare> selector)
{
    return source.Distinct(new LambdaEqualityComparer<TSource, TCompare>(selector));
}

Enfin, l'usage prévu:

var dates = new List<DateTime>() { /* ... */ }
var distinctYears = dates.Distinct(date => date.Year);

L'avantage que j'ai trouvé en utilisant cette approche est la réutilisation de la LambdaEqualityComparerclasse pour d'autres méthodes qui acceptent un IEqualityComparer. (Oh, et je laisse le yieldtruc à l'implémentation LINQ originale ...)

Si vous avez besoin d'une méthode Distinct sur plusieurs propriétés, vous pouvez consulter mes PowerfulExtensions bibliothèque . Actuellement, c'est à un stade très jeune, mais vous pouvez déjà utiliser des méthodes telles que Distinct, Union, Intersect, Except sur un certain nombre de propriétés;

Voici comment vous l'utilisez:

using PowerfulExtensions.Linq;
...
var distinct = myArray.Distinct(x => x.A, x => x.B);

Lorsque nous avons été confrontés à une telle tâche dans notre projet, nous avons défini une petite API pour composer des comparateurs.

Donc, le cas d'utilisation était comme ceci:

var wordComparer = KeyEqualityComparer.Null<Word>().
    ThenBy(item => item.Text).
    ThenBy(item => item.LangID);
...
source.Select(...).Distinct(wordComparer);

Et l'API elle-même ressemble à ceci:

using System;
using System.Collections;
using System.Collections.Generic;

public static class KeyEqualityComparer
{
    public static IEqualityComparer<T> Null<T>()
    {
        return null;
    }

    public static IEqualityComparer<T> EqualityComparerBy<T, K>(
        this IEnumerable<T> source,
        Func<T, K> keyFunc)
    {
        return new KeyEqualityComparer<T, K>(keyFunc);
    }

    public static KeyEqualityComparer<T, K> ThenBy<T, K>(
        this IEqualityComparer<T> equalityComparer,
        Func<T, K> keyFunc)
    {
        return new KeyEqualityComparer<T, K>(keyFunc, equalityComparer);
    }
}

public struct KeyEqualityComparer<T, K>: IEqualityComparer<T>
{
    public KeyEqualityComparer(
        Func<T, K> keyFunc,
        IEqualityComparer<T> equalityComparer = null)
    {
        KeyFunc = keyFunc;
        EqualityComparer = equalityComparer;
    }

    public bool Equals(T x, T y)
    {
        return ((EqualityComparer == null) || EqualityComparer.Equals(x, y)) &&
                EqualityComparer<K>.Default.Equals(KeyFunc(x), KeyFunc(y));
    }

    public int GetHashCode(T obj)
    {
        var hash = EqualityComparer<K>.Default.GetHashCode(KeyFunc(obj));

        if (EqualityComparer != null)
        {
            var hash2 = EqualityComparer.GetHashCode(obj);

            hash ^= (hash2 << 5) + hash2;
        }

        return hash;
    }

    public readonly Func<T, K> KeyFunc;
    public readonly IEqualityComparer<T> EqualityComparer;
}

Plus de détails sont sur notre site: IEqualityComparer dans LINQ .

Vous pouvez utiliser DistinctBy () pour obtenir des enregistrements Distinct par une propriété d'objet. Ajoutez simplement la déclaration suivante avant de l'utiliser:

en utilisant Microsoft.Ajax.Utilities;

puis l'utiliser comme suit:

var listToReturn = responseList.DistinctBy(x => x.Index).ToList();

où 'Index' est la propriété sur laquelle je veux que les données soient distinctes.

Vous pouvez le faire (mais pas très vite) comme ceci:

people.Where(p => !people.Any(q => (p != q && p.Id == q.Id)));

Autrement dit, "sélectionnez toutes les personnes où il n'y a pas une autre personne différente dans la liste avec le même ID."

Remarquez, dans votre exemple, que cela ne ferait que sélectionner la personne 3. Je ne sais pas comment dire ce que vous voulez, parmi les deux précédents.

Si vous ne voulez pas ajouter la bibliothèque MoreLinq à votre projet juste pour obtenir la DistinctByfonctionnalité, vous pouvez obtenir le même résultat final en utilisant la surcharge de la Distinctméthode de Linq qui prend un IEqualityComparerargument.

Vous commencez par créer une classe de comparaison d'égalité personnalisée générique qui utilise la syntaxe lambda pour effectuer une comparaison personnalisée de deux instances d'une classe générique:

public class CustomEqualityComparer<T> : IEqualityComparer<T>
{
    Func<T, T, bool> _comparison;
    Func<T, int> _hashCodeFactory;

    public CustomEqualityComparer(Func<T, T, bool> comparison, Func<T, int> hashCodeFactory)
    {
        _comparison = comparison;
        _hashCodeFactory = hashCodeFactory;
    }

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

    public int GetHashCode(T obj)
    {
        return _hashCodeFactory(obj);
    }
}

Ensuite, dans votre code principal, vous l'utilisez comme suit:

Func<Person, Person, bool> areEqual = (p1, p2) => int.Equals(p1.Id, p2.Id);

Func<Person, int> getHashCode = (p) => p.Id.GetHashCode();

var query = people.Distinct(new CustomEqualityComparer<Person>(areEqual, getHashCode));

Voila! :)

Ce qui précède suppose ce qui suit:

• La propriété Person.Idest de typeint
• La peoplecollection ne contient aucun élément nul

Si la collection peut contenir des valeurs nulles, réécrivez simplement les lambdas pour vérifier la valeur null, par exemple:

Func<Person, Person, bool> areEqual = (p1, p2) => 
{
    return (p1 != null && p2 != null) ? int.Equals(p1.Id, p2.Id) : false;
};

ÉDITER

Cette approche est similaire à celle de la réponse de Vladimir Nesterovsky mais plus simple.

Il est également similaire à celui de la réponse de Joel mais permet une logique de comparaison complexe impliquant plusieurs propriétés.

Cependant, si vos objets ne peuvent différer que par Idun autre utilisateur, la réponse correcte est que tout ce que vous devez faire est de remplacer les implémentations par défaut de GetHashCode()et Equals()dans votre Personclasse, puis d'utiliser simplement la Distinct()méthode prête à l'emploi de Linq pour filtrer tous les doublons.

La meilleure façon de le faire qui sera compatible avec d'autres versions de .NET est de remplacer Equals et GetHash pour gérer cela (voir la question Stack Overflow Ce code renvoie des valeurs distinctes. Cependant, ce que je veux, c'est renvoyer une collection fortement typée par opposition à un type anonyme ), mais si vous avez besoin de quelque chose de générique dans votre code, les solutions de cet article sont excellentes.

List<Person>lst=new List<Person>
        var result1 = lst.OrderByDescending(a => a.ID).Select(a =>new Player {ID=a.ID,Name=a.Name} ).Distinct();

Substituez les méthodes Equals (object obj) et GetHashCode () :

class Person
{
    public int Id { get; set; }
    public int Name { get; set; }

    public override bool Equals(object obj)
    {
        return ((Person)obj).Id == Id;
        // or: 
        // var o = (Person)obj;
        // return o.Id == Id && o.Name == Name;
    }
    public override int GetHashCode()
    {
        return Id.GetHashCode();
    }
}

puis appelez simplement:

List<Person> distinctList = new[] { person1, person2, person3 }.Distinct().ToList();

Vous devriez pouvoir remplacer Equals on person pour réellement faire Equals on Person.id. Cela devrait entraîner le comportement que vous recherchez.

Veuillez essayer avec le code ci-dessous.

var Item = GetAll().GroupBy(x => x .Id).ToList();