IEqualityComparer pour le type anonyme

Question

J'ai cette

 var n = ItemList.Select(s => new { s.Vchr, s.Id, s.Ctr, s.Vendor, s.Description, s.Invoice }).ToList();
 n.AddRange(OtherList.Select(s => new { s.Vchr, s.Id, s.Ctr, s.Vendor, s.Description, s.Invoice }).ToList(););

Je voudrais le faire si elle lorsque cela est autorisé

n = n.Distinct((x, y) => x.Vchr == y.Vchr)).ToList();

J'ai essayé d'utiliser le LambdaComparer mais depuis im en utilisant des types anonymes il n'y a pas de type associer à.

"Aidez-moi Obi Wan Kenobi, vous êtes mon seul espoir"

Answer 1

L'astuce est de créer un comparateur qui ne fonctionne que sur les types inférées. Par exemple:

public class Comparer<T> : IComparer<T> {
  private Func<T,T,int> _func;
  public Comparer(Func<T,T,int> func) {
    _func = func;
  }
  public int Compare(T x,  T y ) {
    return _func(x,y);
  }
}

public static class Comparer {
  public static Comparer<T> Create<T>(Func<T,T,int> func){ 
    return new Comparer<T>(func);
  }
  public static Comparer<T> CreateComparerForElements<T>(this IEnumerable<T> enumerable, Func<T,T,int> func) {
    return new Comparer<T>(func);
  }
}

Maintenant, je peux faire ce qui suit ... solution aki:

var comp = n.CreateComparerForElements((x, y) => x.Vchr == y.Vchr);

Answer 2

La plupart du temps lorsque vous comparez (pour l'égalité ou tri) vous êtes intéressés à choisir les clés de comparer par, et non la méthode de l'égalité ou la comparaison elle-même (ce qui est l'idée derrière l'API de tri de la liste de Python).

Il y a un exemple clé comparateur égalité .

Answer 3

Je note que la réponse de JaredPar ne répond pas tout à fait la question puisque les méthodes définies comme Distinct et sauf besoin d'un pas IEqualityComparer<T> IComparer<T>. Ce qui suit suppose qu'un IEquatable aura un GetHashCode convenable, et il a certainement une méthode appropriée Egal.

public class GeneralComparer<T, TEquatable> : IEqualityComparer<T>
{
    private readonly Func<T, IEquatable<TEquatable>> equatableSelector;

    public GeneralComparer(Func<T, IEquatable<TEquatable>> equatableSelector)
    {
        this.equatableSelector = equatableSelector;
    }

    public bool Equals(T x, T y)
    {
        return equatableSelector.Invoke(x).Equals(equatableSelector.Invoke(y));
    }

    public int GetHashCode(T x)
    {
        return equatableSelector(x).GetHashCode();
    }
}

public static class GeneralComparer
{
    public static GeneralComparer<T, TEquatable> Create<T, TEquatable>(Func<T, TEquatable> equatableSelector)
    {
        return new GeneralComparer<T, TEquatable>(equatableSelector);
    }
}

Lorsque la même conclusion à partir d'une astuce de classe statique est utilisée comme dans la réponse de JaredPar.

Pour être plus général, vous pouvez fournir deux s: Func. Un Func<T, T, bool> pour vérifier l'égalité et pour sélectionner un Func<T, T, int> code de hachage