Distinct() mit Lambda?

Question

Richtig, ich habe also eine Aufzählung und möchte verschiedene Werte daraus erhalten.

Verwendung von System.Linq gibt es natürlich eine Erweiterungsmethode namens Distinct . Im einfachen Fall kann es ohne Parameter verwendet werden, wie:

var distinctValues = myStringList.Distinct();

Schön und gut, aber wenn ich eine Aufzählung von Objekten habe, für die ich Gleichheit angeben muss, ist die einzige verfügbare Überladung:

var distinctValues = myCustomerList.Distinct(someEqualityComparer);

Das Argument des Gleichheitsvergleichers muss eine Instanz von IEqualityComparer<T> . Das kann ich natürlich auch tun, aber es ist etwas langatmig und, nun ja, unübersichtlich.

Was ich erwartet hätte, ist eine Überladung, die ein Lambda, sagen wir ein Func<T, T, bool> :

var distinctValues = myCustomerList.Distinct((c1, c2) => c1.CustomerId == c2.CustomerId);

Weiß jemand, ob es eine solche Erweiterung oder eine gleichwertige Umgehung gibt? Oder übersehe ich etwas?

Gibt es alternativ dazu eine Möglichkeit, eine IEqualityComparer inline (mich blamieren)?

Update

Ich habe eine Antwort von Anders Hejlsberg auf eine Beitrag in einem MSDN-Forum zu diesem Thema. Er sagt:

Das Problem, auf das Sie stoßen werden, ist, dass beim Vergleich zweier Objekte gleich sind, müssen sie denselben GetHashCode-Rückgabewert haben (oder die Hash-Tabelle, die intern von Distinct verwendet wird, nicht korrekt funktionieren). Wir verwenden IEqualityComparer, weil es kompatible Implementierungen von Equals und GetHashCode in einer einzigen Schnittstelle zusammenfasst.

Ich denke, das macht Sinn.

Answer 1

Nein, es gibt keine solche Überladung der Erweiterungsmethode für diese Aufgabe. Ich habe dies in der Vergangenheit selbst als frustrierend empfunden und schreibe daher normalerweise eine Hilfsklasse, um dieses Problem zu lösen. Das Ziel ist die Konvertierung einer Func<T,T,bool> a IEqualityComparer<T,T> .

Ejemplo

public class EqualityFactory {
  private sealed class Impl<T> : IEqualityComparer<T,T> {
    private Func<T,T,bool> m_del;
    private IEqualityComparer<T> m_comp;
    public Impl(Func<T,T,bool> del) { 
      m_del = del;
      m_comp = EqualityComparer<T>.Default;
    }
    public bool Equals(T left, T right) {
      return m_del(left, right);
    } 
    public int GetHashCode(T value) {
      return m_comp.GetHashCode(value);
    }
  }
  public static IEqualityComparer<T,T> Create<T>(Func<T,T,bool> del) {
    return new Impl<T>(del);
  }
}

Damit können Sie Folgendes schreiben

var distinctValues = myCustomerList
  .Distinct(EqualityFactory.Create((c1, c2) => c1.CustomerId == c2.CustomerId));

Answer 2

Hier ist eine einfache Erweiterung Methode, die tut, was ich brauche ...

public static class EnumerableExtensions
{
    public static IEnumerable<TKey> Distinct<T, TKey>(this IEnumerable<T> source, Func<T, TKey> selector)
    {
        return source.GroupBy(selector).Select(x => x.Key);
    }
}

Es ist eine Schande, dass sie eine solche Methode nicht in den Rahmen eingebaut haben, aber was soll's.

Answer 3

Damit erreichen Sie, was Sie wollen, aber ich weiß nicht, wie es mit der Leistung aussieht:

var distinctValues =
    from cust in myCustomerList
    group cust by cust.CustomerId
    into gcust
    select gcust.First();

Wenigstens ist es nicht langatmig.

Answer 4

Alle Lösungen, die ich hier gesehen habe, beruhen auf der Auswahl eines bereits vergleichbaren Feldes. Wenn man jedoch auf eine andere Art und Weise vergleichen muss, diese Lösung hier scheint im Allgemeinen zu funktionieren, z. B. für:

somedoubles.Distinct(new LambdaComparer<double>((x, y) => Math.Abs(x - y) < double.Epsilon)).Count()

Answer 5

Etwas, das ich verwendet habe und das bei mir gut funktioniert hat.

/// <summary>
/// A class to wrap the IEqualityComparer interface into matching functions for simple implementation
/// </summary>
/// <typeparam name="T">The type of object to be compared</typeparam>
public class MyIEqualityComparer<T> : IEqualityComparer<T>
{
    /// <summary>
    /// Create a new comparer based on the given Equals and GetHashCode methods
    /// </summary>
    /// <param name="equals">The method to compute equals of two T instances</param>
    /// <param name="getHashCode">The method to compute a hashcode for a T instance</param>
    public MyIEqualityComparer(Func<T, T, bool> equals, Func<T, int> getHashCode)
    {
        if (equals == null)
            throw new ArgumentNullException("equals", "Equals parameter is required for all MyIEqualityComparer instances");
        EqualsMethod = equals;
        GetHashCodeMethod = getHashCode;
    }
    /// <summary>
    /// Gets the method used to compute equals
    /// </summary>
    public Func<T, T, bool> EqualsMethod { get; private set; }
    /// <summary>
    /// Gets the method used to compute a hash code
    /// </summary>
    public Func<T, int> GetHashCodeMethod { get; private set; }

    bool IEqualityComparer<T>.Equals(T x, T y)
    {
        return EqualsMethod(x, y);
    }

    int IEqualityComparer<T>.GetHashCode(T obj)
    {
        if (GetHashCodeMethod == null)
            return obj.GetHashCode();
        return GetHashCodeMethod(obj);
    }
}