W odróżnieniu od własności klasie LINQ

Question

Mam kolekcję:

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

Samochody są jednoznacznie identyfikowane przez ich własności CarCode.

Mam trzy samochody w kolekcji i dwa z identycznymi CarCodes.

Jak mogę użyć LINQ, aby przekonwertować tę kolekcję na samochody z unikalnymi CarCodes?

Answer 1

Można użyć grupowania i zdobyć pierwszy samochód od siebie grupa:

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

Answer 2

Zastosowanie MoreLINQ, który ma DistinctBy metodę :)

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

(To jest tylko dla LINQ to Objects, pamiętajcie.)

Answer 3

Możesz zaimplementować IEqualityComparer i użyć go w swoim Rozwińnym rozszerzeniu.

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 
} 

A potem

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

Answer 4

Innym sposobem, aby osiągnąć to samo ...

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

Jest możliwe, aby utworzyć metodę rozszerzenia, aby to zrobić w sposób bardziej ogólny. Byłoby interesujące, gdyby ktoś mógł ocenić wydajność tego "DistinctBy" w stosunku do podejścia GroupBy.

Answer 5

samo podejście jak Guffa ale jako metodę rozszerzenia:

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

Używany jako:

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

Answer 6

Można sprawdzić moje PowerfulExtensions bibliotekę. Obecnie jest na bardzo młodym etapie, ale już możesz używać takich metod jak Distinct, Union, Intersect, Z wyjątkiem dowolnej liczby właściwości;

To jak go używać:

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

Answer 7

Inną metodę rozszerzenia dla LINQ do obiektów bez użycia 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; 
     } 
    } 

Answer 8

Myślę, że najlepszym rozwiązaniem pod względem wydajności (lub w dowolnych kategoriach) jest Distinct za pomocą interfejsu IEqualityComparer.

Mimo to za każdym razem, gdy nowy korektor dla każdej klasy jest uciążliwy i generuje standardowy kod.

Oto więc metoda rozszerzenia, która pozwala uzyskać nową klasę IEqualityComparer dla każdej klasy za pomocą odbicia.

Zastosowanie:

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

Extension Code Metoda

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

nie można skutecznie wykorzystać Distinct na zbiór obiektów (bez dodatkowej pracy). Wyjaśnię dlaczego.

The documentation says:

Używa domyślnej porównywarka równość, Default i porównać wartości.

Dla obiektów oznacza to, że do porównania obiektów używa domyślnej metody równania (source). To jest na ich kodzie haszującym. A ponieważ twoje obiekty nie implementują metod GetHashCode() i Equals, sprawdzą odwołanie do obiektu, który nie jest odrębny.