Distinct durch Eigenschaft der Klasse mit LINQ

Question

Ich habe eine Sammlung:

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

Autos CarCode durch ihre Eigenschaft eindeutig identifiziert werden.

Ich habe drei Autos in der Sammlung, und zwei mit identischen CarCodes.

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

Answer 1

Sie Gruppierung verwenden können, und bekommen das erste Auto von jedem Gruppe:

List<Car> distinct = 
    cars 
    .GroupBy(car => car.CarCode) 
    .Select(g => g.First()) 
    .ToList(); 

Answer 2

Verwendung MoreLINQ, die eine DistinctBy Methode hat :)

IEnumerable<Car> distinctCars = cars.DistinctBy(car => car.CarCode); 

(Dies ist nur für LINQ to Objects, wohlgemerkt.)

Answer 3

Sie können einen IEqualityComparer implementieren und diesen in Ihrer Distinct-Erweiterung verwenden.

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 
} 

Und dann

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

Answer 4

Ein anderer Weg, um das Gleiche zu erreichen ...

List<Car> distinticBy = cars 
    .Select(car => car.CarCode) 
    .Distinct() 
    .Select(code => cars.First(car => car.CarCode == code)) 
    .ToList(); 

Es ist möglich, eine Verlängerung Methode, dies zu tun in einer allgemeinere Art und Weise zu erstellen. Es wäre interessant, wenn jemand die Leistung dieses "DistinctBy" gegen den GroupBy-Ansatz evaluieren könnte.

Answer 5

gleichen Ansatz wie Guffa sondern als 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); 

Answer 6

Sie können meine PowerfulExtensions Bibliothek auszuchecken. Derzeit ist es in einem sehr jungen Stadium, aber Sie können bereits Methoden wie Distinct, Union, Intersect, außer einer beliebigen Anzahl von Eigenschaften verwenden;

Dies ist, wie Sie es verwenden:

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

Answer 7

Eine andere Erweiterung Methode für Linq-to-Objekte, ohne GroupBy mit:

/// <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; 
     } 
    } 

Answer 8

Ich denke, die beste Möglichkeit, die Leistung in Bedingungen (oder In jeder Hinsicht) ist zu unterscheiden mit der IEqualityComparer Schnittstelle.

Obwohl jedesmal ein neuer Vergleich für jede Klasse implementiert wird, ist dies umständlich und führt zu Codebausteinen.

Also hier ist eine Erweiterung Methode, die eine neue IEqualityComparer im laufenden Betrieb für jede Klasse mit Reflexion erzeugt.

Verbrauch:

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

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

Answer 9

Sie können effektiv nicht Distinct auf einer Sammlung von Objekten (ohne zusätzliche Arbeit) verwenden. Ich werde erklären warum.

The documentation says:

Es nutzt den Standardgleichheitsvergleich, Default, Werte zu vergleichen.

Bei Objekten bedeutet dies, dass zum Vergleich der Objekte die Standardmethode equation verwendet wird (source). Das ist auf ihrem Hash-Code. Und da Ihre Objekte die GetHashCode() und Equals Methoden nicht implementieren, wird es auf die Referenz des Objekts überprüfen, die nicht eindeutig sind.