L'utilisation d'un délégué pour l'égalité comparer pour LINQ Distinct()

J'ai une LINQ Distinct() instruction qui utilise mon propre comparer, comme ceci:

class MyComparer<T> : IEqualityComparer<T> where T : MyType
{
    public bool Equals(T x, T y)
    {
        return x.Id.Equals(y.Id);
    }

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

...

var distincts = bundle.GetAllThings.Distinct(new MyComparer<MySubType>());

C'est toute fine et dandy et fonctionne comme je veux. Par curiosité, j'ai besoin de définir ma propre Comparer, ou puis-je le remplacer par un délégué? J'ai pensé que je devrais être en mesure de faire quelque chose comme ceci:

var distincts = bundle.GetAllThings.Distinct((a,b) => a.Id == b.Id);

Mais cela ne veut pas compiler. Est-il une astuce?

  • Vous devriez avoir un ReferenceEquals les contrôles contre le nul sur x et y dans votre Equals mise en œuvre.
InformationsquelleAutor Aidan | 2011-01-05
  1. 103

    Distinctes prend un IEqualityComparer comme deuxième argument, de sorte que vous aurez besoin d'un IEqualityComparer. Il n'est pas trop dur de faire un générique qui va prendre un délégué, si. Bien sûr, cela a probablement déjà été mis en œuvre dans certains endroits, tels que MoreLINQ suggéré dans l'une des autres réponses.

    Vous pourriez mettre en œuvre quelque chose comme ceci:

    public static class Compare
{
    public static IEnumerable<T> DistinctBy<T, TIdentity>(this IEnumerable<T> source, Func<T, TIdentity> identitySelector)
    {
        return source.Distinct(Compare.By(identitySelector));
    }

    public static IEqualityComparer<TSource> By<TSource, TIdentity>(Func<TSource, TIdentity> identitySelector)
    {
        return new DelegateComparer<TSource, TIdentity>(identitySelector);
    }

    private class DelegateComparer<T, TIdentity> : IEqualityComparer<T>
    {
        private readonly Func<T, TIdentity> identitySelector;

        public DelegateComparer(Func<T, TIdentity> identitySelector)
        {
            this.identitySelector = identitySelector;
        }

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

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

    Qui vous donne la syntaxe:

    source.DistinctBy(a => a.Id);

    Ou, si vous vous sentez qu'il est plus clair de cette façon:

    source.Distinct(Compare.By(a => a.Id));
    • L'ayant fait, vous pouvez également écrire votre propre méthode d'extension qui prend un délégué.
    • exactement 🙂
    • Génial. J'ai été absent cette fonctionnalité depuis le début de LINQ.
    • Merci c'est un grand.
    • Cool! Si quelqu'un l'a manquée, vous pouvez le faire: source.DistinctBy(x => new { x.Un "x".B });
    • TIdentity devrait avoir un IEquatable<TIdentity> contrainte, et par conséquent, utiliser le identitySelector(x).Equals(identitySelector(y)) à la place. C'est dans le but de prévenir une référence de comparaison en raison de génériques pas de déduire le type construit les surcharges.

    InformationsquelleAutor driis
  2. 11

    Il est malheureux que les Distinct ne vient pas avec une telle surcharge, donc ce que vous avez est une bonne option.

    Avec MoreLinq, vous pouvez utiliser le DistinctBy opérateur.

    var distincts = bundle.GetAllThings.DistinctBy(a => a.Id);

    Vous pourriez également envisager d'écrire un générique ProjectionEqualityComparer qui peut tourner à la appropriée délégué dans un IEqualityComparer<T> mise en œuvre, comme l'un de ceux énumérés ici.

    InformationsquelleAutor Ani
  3. 2

    Ce lien montre comment créer une extension de la méthode pour être en mesure d'utiliser Distinct de la manière que vous avez donné. Vous aurez besoin d'écrire deux Distinct les méthodes d'extension, et un IEqualityComparer.

    Voici le code à partir du site:

    public static class Extensions
{
public static IEnumerable<T> Distinct<T>(this IEnumerable<T> source, Func<T, T, bool> comparer)
{           
return source.Distinct(new DelegateComparer<T>(comparer));
}
public static IEnumerable<T> Distinct<T>(this IEnumerable<T> source, Func<T, T, bool> comparer, Func<T,int> hashMethod)
{
return source.Distinct(new DelegateComparer<T>(comparer,hashMethod));
}
}
public class DelegateComparer<T> : IEqualityComparer<T>
{
private Func<T, T, bool> _equals;
private Func<T,int> _getHashCode;
public DelegateComparer(Func<T, T, bool> equals)
{
this._equals = equals;
}
public DelegateComparer(Func<T, T, bool> equals, Func<T,int> getHashCode)
{
this._equals = equals;
this._getHashCode = getHashCode;
}
public bool Equals(T a, T b)
{
return _equals(a, b);
}
public int GetHashCode(T a)
{
if (_getHashCode != null)       
return _getHashCode(a);       
else
return a.GetHashCode();
}
}
    • Le problème avec ce code, c'est qu'il ne suit pas les règles pour GetHashCode et Equals (voir msdn.microsoft.com/en-us/library/system.object.gethashcode.aspx). Tout moment vous utilisez la première surcharge sur une classe personnalisée, vous êtes très susceptibles d'obtenir des résultats incorrects. GetHashCode doit retourner la même valeur pour les deux objets lorsque Equals vrai.
    InformationsquelleAutor Ahmed Subhani
  4. -1

    Voici mon pervers, sale peu de vanille en C# astuce:

    entities
.GroupBy(e => e.Id)
.Select(g => g.First())
    InformationsquelleAutor Eric