람다와 구별 되는가?

그렇습니다. 나는 열거 할 수 있고 명확한 가치를 얻고 싶습니다.

를 사용하면 System.Linq물론이라는 확장 방법이 Distinct있습니다. 간단한 경우 다음과 같이 매개 변수없이 사용할 수 있습니다.

var distinctValues = myStringList.Distinct();

좋고 훌륭하지만 동등성을 지정 해야하는 열거 가능한 객체가있는 경우 사용 가능한 유일한 과부하는 다음과 같습니다.

var distinctValues = myCustomerList.Distinct(someEqualityComparer);

항등 비교 자 인수는의 인스턴스 여야합니다 IEqualityComparer<T>. 물론이 작업을 수행 할 수는 있지만 다소 장황하고 음탕합니다.

내가 기대했던 것은 람다가 걸리는 과부하입니다 .Func <T, T, bool> :

var distinctValues
    = myCustomerList.Distinct((c1, c2) => c1.CustomerId == c2.CustomerId);

그러한 확장이 있는지 또는 동등한 해결 방법이 있는지 아는 사람이 있습니까? 아니면 뭔가 빠졌습니까?

또는 IEqualityComparer 인라인을 지정하는 방법이 있습니까?

최신 정보

Anders Hejlsberg 가이 주제에 대한 MSDN 포럼 의 게시물 에 대한 답변을 찾았습니다 . 그는 말한다 :

두 객체가 동일하게 비교 될 때 동일한 GetHashCode 반환 값을 가져야합니다. 그렇지 않으면 Distinct에서 내부적으로 사용되는 해시 테이블이 올바르게 작동하지 않습니다. IEqualityComparer는 Equals 및 GetHashCode의 호환 가능한 구현을 단일 인터페이스로 패키지하기 때문에 IEqualityComparer를 사용합니다.

나는 그것이 의미가 있다고 생각합니다 ..

IEnumerable<Customer> filteredList = originalList
  .GroupBy(customer => customer.CustomerId)
  .Select(group => group.First());

MoreLINQDistinctBy 에서 원하는 것처럼 보입니다 . 그런 다음 쓸 수 있습니다 :

var distinctValues = myCustomerList.DistinctBy(c => c.CustomerId);

다음은 컷 다운 버전입니다 DistinctBy(무효 검사 및 자체 키 비교기를 지정할 수있는 옵션 없음).

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

물건을 마무리합니다 . 나는 여기에 온 대부분의 사람들이 라이브러리를 사용하지 않고 가능한 최고의 성능으로 가능한 가장 간단한 솔루션을 원한다고 생각합니다 .

(나를 위해 방법으로 허용 된 그룹은 성능 측면에서 과잉이라고 생각합니다.)

다음은 null 값에도 작동 하는 IEqualityComparer 인터페이스를 사용하는 간단한 확장 방법 입니다.

용법:

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

확장 방법 코드

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

이와 같은 확장 방법 과부하는 없습니다. 나는 과거에 이것이 좌절감을 느꼈고 일반적 으로이 문제를 다루는 도우미 클래스를 작성합니다. 목표는를로 변환하는 Func<T,T,bool>것 IEqualityComparer<T,T>입니다.

예

public class EqualityFactory {
  private sealed class Impl<T> : IEqualityComparer<T,T> {
    private Func<T,T,bool> m_del;
    private IEqualityComparer<T> m_comp;
    public Impl(Func<T,T,bool> del) { 
      m_del = del;
      m_comp = EqualityComparer<T>.Default;
    }
    public bool Equals(T left, T right) {
      return m_del(left, right);
    } 
    public int GetHashCode(T value) {
      return m_comp.GetHashCode(value);
    }
  }
  public static IEqualityComparer<T,T> Create<T>(Func<T,T,bool> del) {
    return new Impl<T>(del);
  }
}

이것은 당신이 다음을 쓸 수 있습니다

var distinctValues = myCustomerList
  .Distinct(EqualityFactory.Create((c1, c2) => c1.CustomerId == c2.CustomerId));

속기 솔루션

myCustomerList.GroupBy(c => c.CustomerId, (key, c) => c.FirstOrDefault());

이것은 당신이 원하는 것을 할 것이지만 성능에 대해서는 모르겠습니다.

var distinctValues =
    from cust in myCustomerList
    group cust by cust.CustomerId
    into gcust
    select gcust.First();

적어도 장황하지 않습니다.

다음은 필요한 것을 수행하는 간단한 확장 방법입니다.

public static class EnumerableExtensions
{
    public static IEnumerable<TKey> Distinct<T, TKey>(this IEnumerable<T> source, Func<T, TKey> selector)
    {
        return source.GroupBy(selector).Select(x => x.Key);
    }
}

그들이 이와 같은 독특한 방법을 프레임 워크에 굽지 않은 것은 부끄러운 일입니다.

내가 잘 사용했던 것이 나를 위해 잘되었습니다.

/// <summary>
/// A class to wrap the IEqualityComparer interface into matching functions for simple implementation
/// </summary>
/// <typeparam name="T">The type of object to be compared</typeparam>
public class MyIEqualityComparer<T> : IEqualityComparer<T>
{
    /// <summary>
    /// Create a new comparer based on the given Equals and GetHashCode methods
    /// </summary>
    /// <param name="equals">The method to compute equals of two T instances</param>
    /// <param name="getHashCode">The method to compute a hashcode for a T instance</param>
    public MyIEqualityComparer(Func<T, T, bool> equals, Func<T, int> getHashCode)
    {
        if (equals == null)
            throw new ArgumentNullException("equals", "Equals parameter is required for all MyIEqualityComparer instances");
        EqualsMethod = equals;
        GetHashCodeMethod = getHashCode;
    }
    /// <summary>
    /// Gets the method used to compute equals
    /// </summary>
    public Func<T, T, bool> EqualsMethod { get; private set; }
    /// <summary>
    /// Gets the method used to compute a hash code
    /// </summary>
    public Func<T, int> GetHashCodeMethod { get; private set; }

    bool IEqualityComparer<T>.Equals(T x, T y)
    {
        return EqualsMethod(x, y);
    }

    int IEqualityComparer<T>.GetHashCode(T obj)
    {
        if (GetHashCodeMethod == null)
            return obj.GetHashCode();
        return GetHashCodeMethod(obj);
    }
}

여기서 본 모든 솔루션은 이미 필적 할만한 필드를 선택하는 데 의존합니다. 그러나 다른 방식으로 비교 해야하는 경우이 솔루션 은 다음과 같은 경우 일반적으로 작동하는 것 같습니다.

somedoubles.Distinct(new LambdaComparer<double>((x, y) => Math.Abs(x - y) < double.Epsilon)).Count()

다른 방법으로 :

var distinctValues = myCustomerList.
Select(x => x._myCaustomerProperty).Distinct();

시퀀스 리턴 고유 요소는 '_myCaustomerProperty'특성으로 비교합니다.

InlineComparer 를 사용할 수 있습니다

public class InlineComparer<T> : IEqualityComparer<T>
{
    //private readonly Func<T, T, bool> equalsMethod;
    //private readonly Func<T, int> getHashCodeMethod;
    public Func<T, T, bool> EqualsMethod { get; private set; }
    public Func<T, int> GetHashCodeMethod { get; private set; }

    public InlineComparer(Func<T, T, bool> equals, Func<T, int> hashCode)
    {
        if (equals == null) throw new ArgumentNullException("equals", "Equals parameter is required for all InlineComparer instances");
        EqualsMethod = equals;
        GetHashCodeMethod = hashCode;
    }

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

    public int GetHashCode(T obj)
    {
        if (GetHashCodeMethod == null) return obj.GetHashCode();
        return GetHashCodeMethod(obj);
    }
}

사용 샘플 :

  var comparer = new InlineComparer<DetalleLog>((i1, i2) => i1.PeticionEV == i2.PeticionEV && i1.Etiqueta == i2.Etiqueta, i => i.PeticionEV.GetHashCode() + i.Etiqueta.GetHashCode());
  var peticionesEV = listaLogs.Distinct(comparer).ToList();
  Assert.IsNotNull(peticionesEV);
  Assert.AreNotEqual(0, peticionesEV.Count);

출처 : https://stackoverflow.com/a/5969691/206730
Union에 IEqualityComparer 사용
명시 적 형식 비교기를 인라인으로 지정할 수 있습니까?

LambdaEqualityComparer를 사용할 수 있습니다.

var distinctValues
    = myCustomerList.Distinct(new LambdaEqualityComparer<OurType>((c1, c2) => c1.CustomerId == c2.CustomerId));


public class LambdaEqualityComparer<T> : IEqualityComparer<T>
    {
        public LambdaEqualityComparer(Func<T, T, bool> equalsFunction)
        {
            _equalsFunction = equalsFunction;
        }

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

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

        private readonly Func<T, T, bool> _equalsFunction;
    }

이를 수행하는 까다로운 방법 Aggregate()은 키 속성 값을 키로 사용하여 사전을 누산기로 사용하여 확장을 사용하는 것입니다 .

var customers = new List<Customer>();

var distincts = customers.Aggregate(new Dictionary<int, Customer>(), 
                                    (d, e) => { d[e.CustomerId] = e; return d; },
                                    d => d.Values);

그리고 GroupBy 스타일 솔루션은 다음을 사용합니다 ToLookup().

var distincts = customers.ToLookup(c => c.CustomerId).Select(g => g.First());

IEnumerable이 있다고 가정하고 예제 델리게이트에서 c1과 c2 가이 목록의 두 가지 요소를 참조하고 싶습니까?

나는 당신이 자기 조인으로 이것을 달성 할 수 있다고 생각합니다 var distinctResults = from c1 in myList join c2 on myList

경우 Distinct()고유의 결과를 생성하지 않습니다,이 시도 :

var filteredWC = tblWorkCenter.GroupBy(cc => cc.WCID_I).Select(grp => grp.First()).Select(cc => new Model.WorkCenter { WCID = cc.WCID_I }).OrderBy(cc => cc.WCID); 

ObservableCollection<Model.WorkCenter> WorkCenter = new ObservableCollection<Model.WorkCenter>(filteredWC);

마이크로 소프트 System.Interactive 패키지는 중요한 선택 람다 소요 고유의 버전이 있습니다. 이것은 Jon Skeet의 솔루션과 사실상 동일하지만 사람들이 알고 나머지 라이브러리를 확인하는 것이 도움이 될 수 있습니다.

이를 수행하는 방법은 다음과 같습니다.

public static class Extensions
{
    public static IEnumerable<T> MyDistinct<T, V>(this IEnumerable<T> query,
                                                    Func<T, V> f, 
                                                    Func<IGrouping<V,T>,T> h=null)
    {
        if (h==null) h=(x => x.First());
        return query.GroupBy(f).Select(h);
    }
}

이 방법을 사용하면처럼 하나의 매개 변수를 지정하여 사용할 수 .MyDistinct(d => d.Name)있지만 다음과 같이 두 번째 매개 변수로 갖는 조건을 지정할 수도 있습니다.

var myQuery = (from x in _myObject select x).MyDistinct(d => d.Name,
        x => x.FirstOrDefault(y=>y.Name.Contains("1") || y.Name.Contains("2"))
        );

NB 예를 들어 다른 기능도 지정할 수 있습니다 .LastOrDefault(...).

조건 만 노출하려면 다음과 같이 구현하여 훨씬 간단하게 만들 수 있습니다.

public static IEnumerable<T> MyDistinct2<T, V>(this IEnumerable<T> query,
                                                Func<T, V> f,
                                                Func<T,bool> h=null
                                                )
{
    if (h == null) h = (y => true);
    return query.GroupBy(f).Select(x=>x.FirstOrDefault(h));
}

이 경우 쿼리는 다음과 같습니다.

var myQuery2 = (from x in _myObject select x).MyDistinct2(d => d.Name,
                    y => y.Name.Contains("1") || y.Name.Contains("2")
                    );

NB 여기서는 표현이 더 간단하지만 참고 .MyDistinct2는 .FirstOrDefault(...)암시 적으로 사용합니다 .

참고 : 위 예제는 다음 데모 클래스를 사용합니다.

class MyObject
{
    public string Name;
    public string Code;
}

private MyObject[] _myObject = {
    new MyObject() { Name = "Test1", Code = "T"},
    new MyObject() { Name = "Test2", Code = "Q"},
    new MyObject() { Name = "Test2", Code = "T"},
    new MyObject() { Name = "Test5", Code = "Q"}
};

IEnumerable 람다 확장 :

public static class ListExtensions
{        
    public static IEnumerable<T> Distinct<T>(this IEnumerable<T> list, Func<T, int> hashCode)
    {
        Dictionary<int, T> hashCodeDic = new Dictionary<int, T>();

        list.ToList().ForEach(t => 
            {   
                var key = hashCode(t);
                if (!hashCodeDic.ContainsKey(key))
                    hashCodeDic.Add(key, t);
            });

        return hashCodeDic.Select(kvp => kvp.Value);
    }
}

용법:

class Employee
{
    public string Name { get; set; }
    public int EmployeeID { get; set; }
}

//Add 5 employees to List
List<Employee> lst = new List<Employee>();

Employee e = new Employee { Name = "Shantanu", EmployeeID = 123456 };
lst.Add(e);
lst.Add(e);

Employee e1 = new Employee { Name = "Adam Warren", EmployeeID = 823456 };
lst.Add(e1);
//Add a space in the Name
Employee e2 = new Employee { Name = "Adam  Warren", EmployeeID = 823456 };
lst.Add(e2);
//Name is different case
Employee e3 = new Employee { Name = "adam warren", EmployeeID = 823456 };
lst.Add(e3);            

//Distinct (without IEqalityComparer<T>) - Returns 4 employees
var lstDistinct1 = lst.Distinct();

//Lambda Extension - Return 2 employees
var lstDistinct = lst.Distinct(employee => employee.EmployeeID.GetHashCode() ^ employee.Name.ToUpper().Replace(" ", "").GetHashCode());