Distinctes par la propriété de la classe avec LINQ

J'ai une collection:

List<Car> cars = new List<Car>();

Voitures sont identifiés de manière unique par leur propriété CarCode.

J'ai trois voitures dans la collection, et deux à l'identique CarCodes.

Comment puis-je utiliser LINQ to convertir cette collection de Voitures uniques CarCodes?

Connexes / double possible de: LINQ Distinct() sur une propriété donnée
Double Possible de LINQ Distinct() sur une propriété donnée

InformationsquelleAutor user278618 | 2010-03-29

c#distinct linq

256

Vous pouvez utiliser le groupement, et d'obtenir la première voiture de chaque groupe:
```
List<Car> distinct =
  cars
  .GroupBy(car => car.CarCode)
  .Select(g => g.First())
  .ToList();
```
- Je parlais de la personne qui downvoted il y a deux jours.
- Je pense qu'aucun frais n'existe!
- Il y a un peu de surcharge, que les groupes sont créés, puis un seul élément de chaque groupe est utilisé.
- pour plus de touches écrire: .GroupBy(voiture =>new{ voiture.CarCode,voiture.PID,voiture.CID})
- au lieu de la Première (), nous devons utiliser FirstOrDefault() dans ce cas, puisque le Premier() ne peut être utilisé comme un final de l'opération de requête
- de manière générale, vous avez raison, mais comme un groupe sera créé si il y a un élément correspondant dans la collection, il y aura au moins un élément de chaque groupe. --> First() est totalement d'accord, dans ce cas d'utilisation.
InformationsquelleAutor Guffa
113

Utilisation MoreLINQ, qui a un DistinctBy méthode 🙂
```
IEnumerable<Car> distinctCars = cars.DistinctBy(car => car.CarCode);
```
(Ce n'est que pour LINQ to Objects, vous l'esprit.)
- simplement de donner le lien!!!code.google.com/p/morelinq/source/browse/MoreLinq/...
- Salut Jon, deux questions si je peut. 1) Pourquoi ne pas ajouter à la bibliothèque de Nuget? 2) qu'est Ce que LINQ to SQL\EF\NH? comment peut-on la mettre? Faut-il utiliser le Guffa version(qui est votre version si NO_HASHSET est vrai...)? Merci beaucoup!
- 1) C'est en NuGet déjà: nuget.org/packages/morelinq 2) je doute que LINQ to SQL etc sont suffisamment souples pour permettre cela.
- Ohh, c'est de la version bêta... c'est pourquoi je ne pouvais pas le trouver. 2) j'ai peur que l'ajout de la Lib de mon projet, j'ai peur que quelqu'un va l'utiliser avec IQueryable<T> et essayer de DistinctBy et ainsi interroger l'ensemble de god damn table... N'est-il pas de commettre des erreurs? Merci encore de votre extrêmement rapide réponse!
- Non, 2.0 bêta - 1.0 n'est pas. Quant à savoir si c'est sujette à erreur... eh bien, c'est vrai de LINQ, en général, que vous pouvez toujours passer un IQueryable<T> pour quelque chose dans l'attente IEnumerable<T>.
- J'ai essayé d'utiliser MoreLinq pour la même tâche, en particulier DistinctBy. Il n'était pas très efficace à tous. Le MoreLinq/DistinctBy requête fait de la méthode de prendre les 2,5 minutes pour s'exécuter que par Chrome de l'onglet réseau, où, comme le GroupBy approche a pris 1,5 secondes. J'ai dû les convertir à Interrogeable à l'aide de la AsQueryable méthode, peut-être que certains avaient de l'influence.
- Pensez-vous qu'il a la mauvaise habitude d'inclure le MoreLinq fonctions en vertu de la System.Linq espace de noms, donc pas besoin d'en ajouter d'autres de l'usage de chaque fichier qui souhaite accéder à ces fonctionnalités?
- Je serais personnellement se sentir nerveux à propos de l'écriture de code en vertu de l' System que qui donne une fausse impression d'être "officiel". Mais vos goûts peuvent varier, bien sûr 🙂
- Oui, il est. Je vais modifier le LINQ.
InformationsquelleAutor Jon Skeet
43

Même approche que Guffa mais comme une extension de la méthode:
```
public static IEnumerable<T> DistinctBy<T, TKey>(this IEnumerable<T> items, Func<T, TKey> property)
{
    return items.GroupBy(property).Select(x => x.First());
}
```
Utilisé comme:
```
var uniqueCars = cars.DistinctBy(x => x.CarCode);
```
- Parfait. Cette même méthode est également disponible sur le Microsoft.Ajax.Utilitaires de la bibliothèque.
InformationsquelleAutor Sheldor the conqueror
28

Vous pouvez mettre en œuvre un IEqualityComparer et utilisez-la dans votre Distinct de l'extension.
```
class CarEqualityComparer : IEqualityComparer<Car>
{
    #region IEqualityComparer<Car> Members

    public bool Equals(Car x, Car y)
    {
        return x.CarCode.Equals(y.CarCode);
    }

    public int GetHashCode(Car obj)
    {
        return obj.CarCode.GetHashCode();
    }

    #endregion
}
```
Et puis
```
var uniqueCars = cars.Distinct(new CarEqualityComparer());
```
- Comment peut-on l'utiliser sans écriture : la nouvelle CarEqualityComparer() ?
- Vous pouvez créer un IEqualitiyComparer wrapper type qui accepte les lambdas. Ce serait généralisée: cars.Distinct(new GenericEqualityComparer<Car>((a,b) => a.CarCode == b.CarCode, x => x.CarCode.GetHashCode())). J'ai utilisé, par exemple, dans le passé, comme c'est parfois le ajoute de la valeur lors de l'exécution d'un arrêt Distinct.
InformationsquelleAutor Anthony Pegram

Une autre méthode d'extension pour Linq-to-Objets, sans l'aide de GroupBy:

    ///<summary>
    ///Returns the set of items, made distinct by the selected value.
    ///</summary>
    ///<typeparam name="TSource">The type of the source.</typeparam>
    ///<typeparam name="TResult">The type of the result.</typeparam>
    ///<param name="source">The source collection.</param>
    ///<param name="selector">A function that selects a value to determine unique results.</param>
    ///<returns>IEnumerable&lt;TSource&gt;.</returns>
    public static IEnumerable<TSource> Distinct<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector)
    {
        HashSet<TResult> set = new HashSet<TResult>();

        foreach(var item in source)
        {
            var selectedValue = selector(item);

            if (set.Add(selectedValue))
                yield return item;
        }
    }

InformationsquelleAutor Luke Puplett

Je pense que la meilleure option en Termes de performances (ou en des termes) est défini à l'aide de la IEqualityComparer interface.

Bien que la mise en œuvre chaque fois qu'un nouveau programme pour chaque classe, c'est encombrant et produit du code réutilisable.

Voici donc une méthode d'extension qui produit une nouvelle IEqualityComparer à la volée pour toutes les classes à l'aide de la réflexion.

Utilisation:

var filtered = taskList.DistinctBy(t => t.TaskExternalId).ToArray();

Méthode D'Extension De Code

public static class LinqExtensions
{
    public static IEnumerable<T> DistinctBy<T, TKey>(this IEnumerable<T> items, Func<T, TKey> property)
    {
        GeneralPropertyComparer<T, TKey> comparer = new GeneralPropertyComparer<T,TKey>(property);
        return items.Distinct(comparer);
    }   
}
public class GeneralPropertyComparer<T,TKey> : IEqualityComparer<T>
{
    private Func<T, TKey> expr { get; set; }
    public GeneralPropertyComparer (Func<T, TKey> expr)
    {
        this.expr = expr;
    }
    public bool Equals(T left, T right)
    {
        var leftProp = expr.Invoke(left);
        var rightProp = expr.Invoke(right);
        if (leftProp == null && rightProp == null)
            return true;
        else if (leftProp == null ^ rightProp == null)
            return false;
        else
            return leftProp.Equals(rightProp);
    }
    public int GetHashCode(T obj)
    {
        var prop = expr.Invoke(obj);
        return (prop==null)? 0:prop.GetHashCode();
    }
}

où est la réflexion ici?

InformationsquelleAutor Anestis Kivranoglou

2

Vous ne pouvez pas utiliser efficacement Distinct sur une collection d'objets (sans travail supplémentaire). Je vais vous expliquer pourquoi.

La documentation dit:

Il utilise le comparateur d'égalité par défaut, Default, pour comparer les valeurs.

Pour les objets qui signifie qu'il utilise la valeur par défaut de l'équation de la méthode pour comparer des objets (source). C'est sur leur code de hachage. Et puisque les objets ne pas mettre en œuvre la GetHashCode() et Equals méthodes, il vérifiera la référence de l'objet, qui ne sont pas distincts.

InformationsquelleAutor Patrick Hofman
1

Une autre façon de faire la même chose...
```
List<Car> distinticBy = cars
    .Select(car => car.CarCode)
    .Distinct()
    .Select(code => cars.First(car => car.CarCode == code))
    .ToList();
```
Il est possible de créer une méthode d'extension pour ce faire, en plus de façon générique. Il serait intéressant si quelqu'un pouvait evalute les performances de cette "DistinctBy" contre le GroupBy approche.
- La deuxième Select serait un O(n*m) de l'opération, pour que ne soient pas à l'échelle. Il pourrait mieux fonctionner si il y a beaucoup de doublons, c'est à dire si le résultat de la première Select est une très petite partie de la collection d'origine.
InformationsquelleAutor JwJosefy
1

Vous pouvez consulter ma PowerfulExtensions de la bibliothèque. Actuellement il est dans un stade très jeune, mais déjà, vous pouvez utiliser des méthodes comme Distinctes, Union, Intersection, Sauf sur un certain nombre de propriétés;

C'est la façon dont vous l'utiliser:
```
using PowerfulExtensions.Linq;
...
var distinct = myArray.Distinct(x => x.A, x => x.B);
```
- Si j'ai une liste d'objets où je veux supprimer tous les objets avec le même ID, il sera myList.Distinct(x => x.ID) ?
InformationsquelleAutor Andrzej Gis

Vous devez vous connecter pour publier un commentaire.