LINQ Seleziona Distinto con tipi anonimi

Quindi ho una collezione di oggetti. Il tipo esatto non è importante. Da esso voglio estrarre tutte le coppie uniche di una coppia di proprietà particolari, quindi:

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

Quindi la mia domanda è: Will Distinct in questo caso usa l'oggetto uguale a uguale (che sarà inutile per me, poiché ogni oggetto è nuovo) o può essere detto di fare un uguale diverso (in questo caso, valori uguali di Alpha e Bravo => istanze uguali)? C'è un modo per ottenere quel risultato, se ciò non lo fa?

Leggi qui l'eccellente post di K. Scott Allen:

E uguaglianza per tutti ... tipi anonimi

La risposta breve (e cito):

Si scopre che il compilatore C # sostituisce Equals e GetHashCode per tipi anonimi. L'implementazione dei due metodi sostituiti utilizza tutte le proprietà pubbliche sul tipo per calcolare il codice hash di un oggetto e verificare l'uguaglianza. Se due oggetti dello stesso tipo anonimo hanno tutti gli stessi valori per le loro proprietà, gli oggetti sono uguali.

Quindi è assolutamente sicuro usare il metodo Distinct () su una query che restituisce tipi anonimi.

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

Ci scusiamo per la formattazione incasinata in precedenza

Interessante che funzioni in C # ma non in VB

Restituisce le 26 lettere:

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

Restituisce 52 ...

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

Ho eseguito un piccolo test e ho scoperto che se le proprietà sono tipi di valore, sembra funzionare bene. Se non sono tipi di valore, il tipo deve fornire le proprie implementazioni Equals e GetHashCode affinché funzioni. Le stringhe, penso, funzionerebbero.

È possibile creare il proprio metodo di estensione distinta che accetta l'espressione lambda. Ecco un esempio

Creare una classe che deriva dall'interfaccia IEqualityComparer

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

Quindi crea il tuo metodo di estensione distinta

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

e puoi usare questo metodo per trovare elementi distinti

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

Se Alpha ed Bravoentrambi ereditano da una classe comune, sarai in grado di dettare il controllo dell'uguaglianza nella classe genitrice implementandoIEquatable<T> .

Per esempio:

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

Ehi, ho lo stesso problema e ho trovato una soluzione. Devi implementare l'interfaccia IEquatable o semplicemente sovrascrivere i metodi (Equals & GetHashCode). Ma questo non è il trucco, il trucco proveniente dal metodo GetHashCode. Non dovresti restituire il codice hash dell'oggetto della tua classe ma dovresti restituire l'hash della proprietà che vuoi confrontare in questo modo.

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

Come vedi ho una classe chiamata persona ho 3 proprietà (Nome, Età, IsEgyptian "Perché sono") Nel GetHashCode ho restituito l'hash della proprietà Name non l'oggetto Person.

Provalo e funzionerà ISA. Grazie Modather Sadik

Affinché funzioni in VB.NET, è necessario specificare la Keyparola chiave prima di ogni proprietà nel tipo anonimo, proprio come questo:

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

Ero alle prese con questo, pensavo che VB.NET non supportasse questo tipo di funzionalità, ma in realtà lo fa.