En utilisant la lambda expression à la place de IComparer argument

Est-il possible avec C# pour passer d'une expression lambda comme un IComparer argument dans l'appel de méthode?

par exemple quelque chose comme

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

Je n'arrive pas à obtenir ce pour compiler donc je suppose que non, mais il semble une synergie évidente entre les lambdas et les délégués anonymes que j'ai le sentiment que je dois faire quelque chose de follement mal.

TIA

InformationsquelleAutor haughtonomous | 2013-05-30
  1. 52

    Comme Jeppe, si vous êtes sur .NET 4.5, vous pouvez utiliser la méthode statique Comparer<T>.Create.

    Si non, c'est une mise en œuvre qui devrait être équivalent:

    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);
    }
}
    • Pourriez vouloir donner à cette classe un nom différent pour éviter les conflits avec la bibliothèque de la classe.
    • Syntaxique détail: Le constructeur d'une classe générique ne doit pas inclure le <T> partie du nom de la classe.
    InformationsquelleAutor Timothy Shields
  2. 74

    Si vous êtes sur .NET 4.5, vous pouvez utiliser la méthode statique Comparer<aClass>.Create.

    Documentation: Comparer<T>.Créer Méthode .

    Exemple:

    var x = someIEnumerable.OrderBy(e => e.someProperty, 
    Comparer<aClass>.Create((x, y) => x.someProperty > y.SomeProperty ?  1 : x.someProperty < y.SomeProperty ?  -1 : 0)
    );
    • Malheureusement, nous croupissent dans .Net 3.5 terre! Ne peut pas se permettre le mega-wedge nécessaires à la mise à niveau de TFS pour la dernière version:-(
    • si c'est la seule chose qui vous retient, avez-vous envisagé de dumping TSF en faveur de quelque chose d'autre?
    • Connaissez-vous l'essentiel de la théorie (pas comme "puisqu'il reqire autre type que lambda") à propos de pourquoi nous ne pouvons pas mettre lambda directement là-bas, mais besoin d'un conteneur?
    • Je ne suis pas sûr de savoir comment beaucoup de théorie il y a derrière ce. Les auteurs de .OrderBy (Linq) a décidé de ne pas avoir une surcharge qui a accepté un délégué pour la comparaison (comme un Comparison<TKey> délégué). Vous pouvez créer votre propre méthode d'extension si vous le souhaitez.
    • La théorie semble être que l'Interface a 2+ méthodes.
    • Maintenant je veux utiliser lambda à la place de IEqualityComparer, mais IEqualityComparer<T> ne pas Créer, pourquoi et comment?
    • Vous avez besoin de deux méthodes, Equals et GetHashCode. Il n'existe pas de méthode qui vous permet de le faire à partir de deux délégués (lambda). Au lieu de cela, créez votre propre classe et de l'utilisation EqualityComparer<YourType> comme la classe de base. Vous aurez besoin de mettre en œuvre seulement deux méthodes abstraites, et pour que vous obtenez un objet qui est à la fois IEqualityComparer<YourType> et IEqualityComparer (vous n'avez pas à spécifier ces deux interfaces, ils viennent gratuitement à partir de la classe de base). Notez que IEqualityComparer<in T> est contravariant en T, de sorte que votre classe peut également être utilisé comme un IEqualityComparer<AnyDerivedYourType>.
    • Cette question de fournir une solution de stackoverflow.com/questions/3189861/.... Mais pourquoi le SDK ne fournit pas un tel wrapper comme Comparer<T>.Créer?

    InformationsquelleAutor Jeppe Stig Nielsen
  3. 3

    Si vous avez toujours souhaitez comparer projetée clés (par exemple une seule propriété), vous pouvez définir une classe qui encapsule toutes les clés logique de comparaison pour vous, y compris null contrôles, d'extraction de clé sur les deux objets, et de la comparaison clé à l'aide de la spécifiés ou à défaut intérieure comparer:

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

    Pour plus de commodité, une méthode de fabrique:

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

    Vous pouvez ensuite utiliser ce comme suit:

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

    Vous pouvez vous référer à mon post de blog une discussion étendue de cette mise en œuvre.

    InformationsquelleAutor Douglas