Unterschieden nach Eigenschaft der Klasse mit LINQ

Habe ich eine Sammlung:

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

Autos sind eindeutig durch die Eigenschaft CarCode.

Habe ich drei Autos in der Sammlung, und zwei mit identischen CarCodes.

Wie kann ich LINQ verwenden, um zu konvertieren, diese Sammlung von Autos mit einzigartigen CarCodes?

InformationsquelleAutor der Frage user278618 | 2010-03-29

c#distinct linq

212

Können Sie die Gruppierung verwenden, und bekommen das erste Auto aus jeder Gruppe:
```
List<Car> distinct =
  cars
  .GroupBy(car => car.CarCode)
  .Select(g => g.First())
  .ToList();
```
InformationsquelleAutor der Antwort Guffa
99

Verwenden MoreLINQdie eine DistinctBy Methode 🙂
```
IEnumerable<Car> distinctCars = cars.DistinctBy(car => car.CarCode);
```
(Dies ist nur für LINQ to Objects, wohlgemerkt.)

InformationsquelleAutor der Antwort Jon Skeet

Gleichen Ansatz wie Guffa sondern als eine Erweiterung-Methode:

public static IEnumerable<T> DistinctBy<T, TKey>(this IEnumerable<T> items, Func<T, TKey> property)
{
    return items.GroupBy(property).Select(x => x.First());
}

Als:

var uniqueCars = cars.DistinctBy(x => x.CarCode);

InformationsquelleAutor der Antwort Sheldor the conqueror

Implementieren Sie können einen IEqualityComparer und verwenden Sie, dass in Ihr Deutliche Erweiterung.

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
}

Dann

var uniqueCars = cars.Distinct(new CarEqualityComparer());

InformationsquelleAutor der Antwort Anthony Pegram

Andere Erweiterung Methode, die für Linq-to-Objekte, ohne mit 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 der Antwort Luke Puplett

Ich denke, die beste option in Bezug auf Leistung (oder in jeder Hinsicht) ist, um Unterschiedliche der Die IEqualityComparer - Schnittstelle.

Obwohl die Umsetzung jeder Zeit ein neues Programm für jede Klasse ist umständlich und erzeugt boilerplate-code.

So, hier ist eine extension-Methode erzeugt einen neuen IEqualityComparer on-the-fly für jede Klasse mit der spiegelung.

Verwendung:

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

Erweiterung Methode 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();
    }
}

InformationsquelleAutor der Antwort Anestis Kivranoglou

2

Können Sie nicht effektiv nutzen Distinct auf eine Sammlung von Objekten (ohne zusätzliche Arbeit). Ich werde erklären, warum.

Die Dokumentation sagt:

Es verwendet die Standard-Gleichheit comparer, Defaultum Werte zu vergleichen.

Für Objekte, das heißt, es nutzt die Standard-Gleichung Methode zum vergleichen von Objekten (Quelle). Das ist auf deren hash-code. Und da Ihre Objekte nicht implementieren die GetHashCode() und Equals Methoden, überprüfen Sie auf der Referenz des Objekts, die nicht unterscheidbar sind.

InformationsquelleAutor der Antwort Patrick Hofman
1

Einem anderen Weg das gleiche erreichen...
```
List<Car> distinticBy = cars
    .Select(car => car.CarCode)
    .Distinct()
    .Select(code => cars.First(car => car.CarCode == code))
    .ToList();
```
Es ist möglich, erstellen Sie ein extension-Methode, dies zu tun in einer allgemeineren Weise. Es wäre interessant, wenn jemand könnte evalute Leistung dieses 'DistinctBy' gegen die GroupBy-Ansatz.

InformationsquelleAutor der Antwort JwJosefy
1

Können Sie check out my PowerfulExtensions Bibliothek. Momentan ist er in einem sehr Jungen Stadium, aber bereits können Sie Methoden wie Distinct, Union, Intersect, Außer auf eine beliebige Anzahl von Eigenschaften;

Dies ist, wie Sie es verwenden:
```
using PowerfulExtensions.Linq;
...
var distinct = myArray.Distinct(x => x.A, x => x.B);
```
InformationsquelleAutor der Antwort gisek

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.