Farklı () lambda ile?

Doğru, bu yüzden bir numaralandırılabilirim ve ondan farklı değerler almak istiyorum.

Kullanarak System.Linq, elbette denilen bir uzantı yöntemi var Distinct. Basit durumda, aşağıdaki gibi hiçbir parametre olmadan kullanılabilir:

var distinctValues = myStringList.Distinct();

İyi ve iyi, ama eşitliğini belirtmem gereken sayısız nesne varsa, mevcut tek aşırı yük:

var distinctValues = myCustomerList.Distinct(someEqualityComparer);

Eşitlik karşılaştırma argümanı bir örnek olmalıdır IEqualityComparer<T>. Bunu elbette yapabilirim, ama biraz ayrıntılı ve cludgy.

Beklediğim bir lambda alacak bir aşırı yük olduğunu, bir Func <T, T, bool> deyin:

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

Herkes böyle bir uzantı var mı, ya da eşdeğer bir geçici çözüm var mı? Yoksa bir şey mi kaçırıyorum?

Alternatif olarak, bir IEqualityComparer satır içi belirtmenin bir yolu var mı (beni uyandır)?

Güncelleme

Bir Anders Hejlsberg tarafından bir cevap buldum yazı bu konuda bir MSDN forumu. Diyor:

Karşılaşacağınız sorun, iki nesne eşit olduğunda, aynı GetHashCode dönüş değerine sahip olmalarıdır (veya başka bir deyişle, Distinct tarafından dahili olarak kullanılan karma tablosu düzgün çalışmaz). IEqualityComparer kullanıyoruz, çünkü Equals ve GetHashCode uyumlu uygulamaları tek bir arayüzde paketliyor.

Sanırım bu mantıklı ..

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

İstediğiniz gibi bana bakıyor DistinctBydan MoreLINQ . Daha sonra şunları yazabilirsiniz:

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

İşte bir kısaltılmış sürümü DistinctBy(iptal kontrolü yok ve kendi anahtar karşılaştırıcınızı belirtme seçeneği yok):

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

Bir şeyleri sarmak için . Buraya benim gibi gelen insanların çoğunun, herhangi bir kütüphane kullanmadan ve mümkün olan en iyi performansla mümkün olan en basit çözümü istediğini düşünüyorum .

(Benim için yöntemle kabul edilen grup, performans açısından aşırıya kaçma olduğunu düşünüyorum.)

İşte null değerleri için de çalışan IEqualityComparer arabirimini kullanan basit bir uzantı yöntemi .

Kullanımı:

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

Uzantı Yöntemi Kodu

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

Hayır bunun için böyle bir uzatma yöntemi aşırı yüklemesi yoktur. Geçmişte kendimi bu sinir bozucu buldum ve bu nedenle genellikle bu sorunla başa çıkmak için yardımcı bir sınıf yazıyorum. Hedefi dönüştürmek olduğunu Func<T,T,bool>için IEqualityComparer<T,T>.

Misal

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

Bu, aşağıdakileri yazmanıza olanak tanır

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

Steno çözümü

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

Bu ne istersen yapacak ama performans hakkında bilmiyorum:

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

En azından ayrıntılı değil.

İşte ihtiyacım olan basit bir uzantı yöntemi ...

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

Bu şekilde farklı bir yöntem yapmadıkları utanç verici, ama hey ho.

Kullandığım ve benim için iyi işleyen bir şey.

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

Burada gördüğüm tüm çözümler zaten karşılaştırılabilir bir alan seçmeye dayanıyor. Bununla birlikte, farklı bir şekilde karşılaştırmak gerekirse, buradaki çözüm genel olarak işe yarar gibi görünüyor:

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

Başka bir yol alın:

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

Dizi dönüşü ayrı öğeleri bunları '_myCaustomerProperty' özelliğiyle karşılaştırır.

InlineComparer'ı kullanabilirsiniz

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

Kullanım örneği :

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

Kaynak: https://stackoverflow.com/a/5969691/206730
IEqualityComparer for Union kullanma
Açık tip karşılaştırıcımı satır içi olarak belirleyebilir miyim?

LambdaEqualityComparer'ı kullanabilirsiniz:

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

Bunu yapmanın zor bir yolu Aggregate(), anahtar özellik değerlerini anahtar olarak akümülatör olarak bir sözlük kullanarak uzantı kullanmaktır :

var customers = new List<Customer>();

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

Ve bir GroupBy tarzı çözüm kullanıyor ToLookup():

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

Ben bir IEnumerable var varsayalım ve örnek temsilcinizde, c1 ve c2 bu listedeki iki öğeye başvurmak istiyor musunuz?

Bunu kendi kendine katılma ile başarabileceğinize inanıyorum var differenttResults = myList'teki c1'den myList'teki c2'ye

Eğer Distinct()benzersiz sonuçlar üretmez, bu bir deneyin:

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

Microsoft System.Interactive paket anahtar seçicisi lambda alır Farklı bir sürümü var. Bu etkili bir şekilde Jon Skeet'in çözümü ile aynıdır, ancak insanların bilmesi ve kütüphanenin geri kalanını kontrol etmesi yararlı olabilir.

Bunu nasıl yapabileceğiniz aşağıda açıklanmıştır:

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

Bu yöntem, böyle bir parametre belirterek kullanmanıza izin verir .MyDistinct(d => d.Name), ancak aynı şekilde ikinci bir parametre olarak sahip olma koşulunu belirtmenize izin verir:

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

Not Bu, örneğin .LastOrDefault(...)gibi diğer işlevleri de belirtmenize olanak tanır .

Sadece koşulu ortaya çıkarmak istiyorsanız, aşağıdaki gibi uygulayarak daha da basitleştirebilirsiniz:

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

Bu durumda, sorgu sadece şöyle görünecektir:

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

NB Buradaki tanım daha basit olmakla birlikte not .MyDistinct2kullanır .FirstOrDefault(...)örtük.

Not: Yukarıdaki örnekler aşağıdaki demo sınıfını kullanmaktadır

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 lambda uzantısı:

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

Kullanımı:

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