LINQ İsimsiz Türlerle Farklı Seçin

Bir nesne koleksiyonum var. Kesin türü önemli değil. Ondan bir çift belirli özelliklerin tüm benzersiz çiftlerini çıkarmak istiyorum, böylece:

myObjectCollection.Select(item=>new
                                {
                                     Alpha = item.propOne,
                                     Bravo = item.propTwo
                                }
                 ).Distinct();

Yani sorum şu: Farklı bu durumda varsayılan nesne eşitlerini kullanacak mı (her nesne yeni olduğu için benim için işe yaramaz) ya da farklı bir eşitlik (bu durumda Alpha ve Bravo'nun eşit değerleri) söylenebilir mi? => eşit örnekler)? Bu sonuca ulaşmanın bir yolu var mı, eğer bunu yapmazsa?

K. Scott Allen'ın mükemmel gönderisini buradan okuyabilirsiniz:

Herkes İçin Eşitlik ... Anonim Türler

Kısa cevap (ve ben alıntı):

Anonim türler için C # derleyicisi Eşittir ve GetHashCode'u geçersiz kılar. Geçersiz kılınan iki yöntemin uygulanması, bir nesnenin karma kodunu hesaplamak ve eşitliği test etmek için türdeki tüm genel özellikleri kullanır. Aynı anonim türdeki iki nesne, özellikleri için aynı değerlere sahipse - nesneler eşittir.

Bu nedenle, anonim türleri döndüren bir sorguda Distinct () yöntemini kullanmak tamamen güvenlidir.

public class DelegateComparer<T> : IEqualityComparer<T>
{
    private Func<T, T, bool> _equals;
    private Func<T, int> _hashCode;
    public DelegateComparer(Func<T, T, bool> equals, Func<T, int> hashCode)
    {
        _equals= equals;
        _hashCode = hashCode;
    }
    public bool Equals(T x, T y)
    {
        return _equals(x, y);
    }

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

public static class Extensions
{
    public static IEnumerable<T> Distinct<T>(this IEnumerable<T> items, 
        Func<T, T, bool> equals, Func<T,int> hashCode)
    {
        return items.Distinct(new DelegateComparer<T>(equals, hashCode));    
    }
    public static IEnumerable<T> Distinct<T>(this IEnumerable<T> items,
        Func<T, T, bool> equals)
    {
        return items.Distinct(new DelegateComparer<T>(equals,null));
    }
}

var uniqueItems=students.Select(s=> new {FirstName=s.FirstName, LastName=s.LastName})
            .Distinct((a,b) => a.FirstName==b.FirstName, c => c.FirstName.GetHashCode()).ToList();

Daha önce biçimlendirilmiş biçimlendirme için üzgünüm

İlginçtir ki C # ile çalışıyor ama VB'de değil

26 harfi döndürür:

var MyBet = "aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ";
MyBet.ToCharArray()
.Select(x => new {lower = x.ToString().ToLower(), upper = x.ToString().ToUpper()})
.Distinct()
.Dump();

52 döndürür ...

Dim MyBet = "aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ"
MyBet.ToCharArray() _
.Select(Function(x) New With {.lower = x.ToString.ToLower(), .upper = x.ToString.ToUpper()}) _
.Distinct() _
.Dump()

Biraz test yaptım ve özellikleri değer türleri ise, Tamam çalışıyor gibi bulundu. Değer türleri değilse, türün çalışması için kendi Equals ve GetHashCode uygulamaları gerekir. Sanırım dizeler işe yarardı.

Lambda ifadesini alan kendi Farklı Uzantı yönteminizi oluşturabilirsiniz. İşte bir örnek

IEqualityComparer arabiriminden türeyen bir sınıf oluşturma

public class DelegateComparer<T> : IEqualityComparer<T>
{
    private Func<T, T, bool> _equals;
    private Func<T, int> _hashCode;
    public DelegateComparer(Func<T, T, bool> equals, Func<T, int> hashCode)
    {
        _equals= equals;
        _hashCode = hashCode;
    }
    public bool Equals(T x, T y)
    {
        return _equals(x, y);
    }

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

Ardından Farklı Uzantı yönteminizi oluşturun

public static class Extensions
{
    public static IEnumerable<T> Distinct<T>(this IEnumerable<T> items, 
        Func<T, T, bool> equals, Func<T,int> hashCode)
    {
        return items.Distinct(new DelegateComparer<T>(equals, hashCode));    
    }
    public static IEnumerable<T> Distinct<T>(this IEnumerable<T> items,
        Func<T, T, bool> equals)
    {
        return items.Distinct(new DelegateComparer<T>(equals,null));
    }
}

ve farklı öğeleri bulmak için bu yöntemi kullanabilirsiniz

var uniqueItems=students.Select(s=> new {FirstName=s.FirstName, LastName=s.LastName})
            .Distinct((a,b) => a.FirstName==b.FirstName, c => c.FirstName.GetHashCode()).ToList();

Eğer Alphave Bravoortak bir sınıftan hem devralır, sen uygulayarak üst sınıfında eşitliği denetimini dikte mümkün olacak IEquatable<T>.

Örneğin:

public class CommonClass : IEquatable<CommonClass>
{
    // needed for Distinct()
    public override int GetHashCode() 
    {
        return base.GetHashCode();
    }

    public bool Equals(CommonClass other)
    {
        if (other == null) return false;
        return [equality test];
    }
}

Hey, aynı problemi yaşadım ve bir çözüm buldum. IEquatable arabirimini uygulamanız veya (Equals & GetHashCode) Yöntemlerini geçersiz kılmanız gerekir. Ama bu hile değil, hile GetHashCode yönteminde geliyor. Sınıfınızın nesnesinin karma kodunu döndürmemelisiniz, ancak böyle karşılaştırmak istediğiniz özelliğin karma değerini döndürmelisiniz.

public override bool Equals(object obj)
    {
        Person p = obj as Person;
        if ( obj == null )
            return false;
        if ( object.ReferenceEquals( p , this ) )
            return true;
        if ( p.Age == this.Age && p.Name == this.Name && p.IsEgyptian == this.IsEgyptian )
            return true;
        return false;
        //return base.Equals( obj );
    }
    public override int GetHashCode()
    {
        return Name.GetHashCode();
    }

Gördüğünüz gibi kişi 3 özellik (Ad, Yaş, IsEgyptian "Çünkü ben") var denilen bir sınıf var GetHashCode içinde ben Kişi nesnesi değil Name özelliği hash döndü.

Deneyin ve ISA çalışacaktır. Teşekkürler Modather Sadik

VB.NET'te çalışabilmesi için Key, anonim türdeki her özellikten önce anahtar kelimeyi aşağıdaki gibi belirtmeniz gerekir :

myObjectCollection.Select(Function(item) New With
{
    Key .Alpha = item.propOne,
    Key .Bravo = item.propTwo
}).Distinct()

Bununla mücadele ediyordum, VB.NET'in bu tür özellikleri desteklemediğini düşündüm, ama aslında öyle.