IEqualityComparer für anonymen Typ

Question

Ich habe diese

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

Ich möchte, dies tun, wenn es soweit dies zulässig

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

Ich habe versucht, die allgemeine LambdaComparer aber da es im mit anonymen Typen ist kein Typ assoziieren sie mit.

"Hilf mir Obi Wan Kenobi, du bist meine einzige Hoffnung"

Answer 1

Der Trick besteht darin, einen Vergleich zu erstellen, die nur auf abgeleitete Typen funktionieren. Zum Beispiel:

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

Jetzt kann ich die folgende ... hacky Lösung:

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

Answer 2

Die meiste Zeit, wenn Sie (für Gleichheit oder Sortierung) vergleichen Sie Interesse an die Schlüssel der Wahl von vergleichen, nicht die Gleichheit oder Vergleichsverfahren selbst (das ist die Idee hinter Python Liste sortieren API).

Es ist ein Beispiel Schlüsselgleichheitsvergleich hier .

Answer 3

Ich nehme zur Kenntnis, dass JaredPar Antwort nicht beantwortet die Frage nicht ganz, da die Set-Methoden wie Distinct und mit Ausnahme einen IEqualityComparer<T> keine IComparer<T> erfordern. Im Folgenden wird angenommen, dass ein IEquatable eine geeignete GetHashCode haben, und es hat sicherlich eine geeignete Methode Equals.

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

Dabei gilt die gleiche Folgerung aus einem statischen Klasse Trick wie in JaredPar Antwort verwendet wird.

Um allgemeinere Sie zwei Funcs bieten könnten: a. Func<T, T, bool> Gleichheit und Func<T, T, int> zu überprüfen, einen Hash-Code, um