LINQ Select Distinct avec les types anonymes

Question

J'ai donc une collection d'objets. Le type exact n'est pas important. Je veux en extraire toutes les paires uniques d'une paire de propriétés particulières, de la manière suivante :

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

Ma question est donc la suivante : dans ce cas, Distinct utilisera-t-il les égalités d'objets par défaut (ce qui me sera inutile, puisque chaque objet est nouveau) ou peut-on lui demander d'effectuer des égalités différentes (dans ce cas, valeurs égales d'Alpha et de Bravo => instances égales) ? Existe-t-il un autre moyen d'obtenir ce résultat, si cela ne fonctionne pas ?

Answer 1

Lisez l'excellent article de K. Scott Allen ici :

Et l'égalité pour tous... Types d'anonymes

La réponse courte (et je cite) :

Il s'avère que le compilateur C# remplace Equals et GetHashCode pour les types anonymes. anonymes. L'implémentation des deux méthodes surchargées utilise toutes les propriétés publiques du type pour calculer un code de hachage d'un objet et tester l'égalité l'égalité. Si deux objets du même type anonyme ont toutes les mêmes valeurs pour leurs propriétés - les objets sont égaux.

Il est donc tout à fait possible d'utiliser la méthode Distinct() sur une requête qui renvoie des types anonymes.

Answer 2

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

Désolé pour le formatage raté de tout à l'heure

Answer 3

Il est intéressant que cela fonctionne en C# mais pas en VB.

Donne les 26 lettres :

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

Retourne 52...

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

Answer 4

J'ai effectué un petit test et j'ai constaté que si les propriétés sont de type valeur, cela semble fonctionner correctement. Si ce ne sont pas des types de valeurs, alors le type doit fournir ses propres implémentations Equals et GetHashCode pour que cela fonctionne. Les chaînes de caractères, je pense, fonctionneraient.

Answer 5

Vous pouvez créer votre propre méthode Distinct Extension qui prend une expression lambda. Voici un exemple

Créer une classe qui dérive de l'interface 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();
    }       
}

Créez ensuite votre méthode Distinct Extension

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

et vous pouvez utiliser cette méthode pour trouver des éléments distincts

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