c# - son - Usar la expresión lambda en lugar del argumento de IComparer

linq lambda c# pdf

Question

¿Es posible que C # pase una expresión lambda como argumento IComparer en una llamada a método?

por ejemplo, algo así como

var x = someIEnumerable.OrderBy(aClass e => e.someProperty, 
(aClass x, aClass y) => 
  x.someProperty > y.SomeProperty ?  1 : x.someProperty < y.SomeProperty ?  -1 : 0);

No puedo hacer que compile, así que supongo que no, pero parece una sinergia tan obvia entre lambdas y delegados anónimos que siento que debo estar haciendo algo tontamente equivocado.

TIA

Answer 1

Como señala Jeppe, si tiene .NET 4.5, puede usar el método estático Comparer<T>.Create .

Si no, esta es una implementación que debería ser equivalente:

public class FunctionalComparer<T> : IComparer<T>
{
    private Func<T, T, int> comparer;
    public FunctionalComparer(Func<T, T, int> comparer)
    {
        this.comparer = comparer;
    }
    public static IComparer<T> Create(Func<T, T, int> comparer)
    {
        return new FunctionalComparer<T>(comparer);
    }
    public int Compare(T x, T y)
    {
        return comparer(x, y);
    }
}

Answer 2

Si constantemente quiere comparar claves proyectadas (como una sola propiedad), puede definir una clase que encapsule toda la lógica de comparación de claves para usted, incluidas las comprobaciones nulas, la extracción de claves en ambos objetos y la comparación de claves usando el valor interno predeterminado o predeterminado. comparador:

public class KeyComparer<TSource, TKey> : Comparer<TSource>
{
    private readonly Func<TSource, TKey> _keySelector;
    private readonly IComparer<TKey> _innerComparer;

    public KeyComparer(
        Func<TSource, TKey> keySelector, 
        IComparer<TKey> innerComparer = null)
    {
        _keySelector = keySelector;
        _innerComparer = innerComparer ?? Comparer<TKey>.Default;
    }

    public override int Compare(TSource x, TSource y)
    {
        if (object.ReferenceEquals(x, y))
            return 0;
        if (x == null)
            return -1;
        if (y == null)
            return 1;

        TKey xKey = _keySelector(x);
        TKey yKey = _keySelector(y);
        return _innerComparer.Compare(xKey, yKey);
    }
}

Por conveniencia, un método de fábrica:

public static class KeyComparer
{
    public static KeyComparer<TSource, TKey> Create<TSource, TKey>(
        Func<TSource, TKey> keySelector, 
        IComparer<TKey> innerComparer = null)
    {
        return new KeyComparer<TSource, TKey>(keySelector, innerComparer);
    }
}

Entonces podrías usar esto así:

var sortedSet = new SortedSet<MyClass>(KeyComparer.Create((MyClass o) => o.MyProperty));

Puede consultar la publicación de mi blog para obtener una explicación ampliada de esta implementación.

Answer 3

Si tiene .NET 4.5, puede usar el método estático Comparer<aClass>.Create .

Documentación: Comparer<T>.Create método .

Ejemplo:

var x = someIEnumerable.OrderBy(e => e.someProperty, 
    Comparer<aClass>.Create((x, y) => x.someProperty > y.SomeProperty ?  1 : x.someProperty < y.SomeProperty ?  -1 : 0)
    );