Utilisation de l’expression lambda à la place de l’argument IComparer

Est-il possible avec C # de passer une expression lambda en tant qu’argument IComparer dans un 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 ne peux pas vraiment comstackr cela, alors je suppose que non, mais il semble que la synergie entre les delegates et les delegates anonymes soit si évidente que je pense que je dois faire quelque chose de mal.

TIA

Comme le souligne Jeppe, si vous utilisez .NET 4.5, vous pouvez utiliser la méthode statique Comparer.Create .

Sinon, il s’agit d’une implémentation qui devrait être équivalente:

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

Si vous utilisez .NET 4.5, vous pouvez utiliser la méthode statique Comparer.Create .

Documentation: Comparer.Create .

Exemple:

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

Si vous souhaitez systématiquement comparer des clés projetées (par exemple, une propriété unique), vous pouvez définir une classe qui encapsule toute la logique de comparaison de clés, y compris les vérifications NULL, l’extraction de clés sur les deux objects et la comparaison de clés comparer:

 public class KeyComparer : Comparer { private readonly Func _keySelector; private readonly IComparer _innerComparer; public KeyComparer( Func keySelector, IComparer innerComparer = null) { _keySelector = keySelector; _innerComparer = innerComparer ?? Comparer.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 d’usine:

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

Vous pourriez alors l’utiliser comme ceci:

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

Vous pouvez vous référer à mon article de blog pour une discussion approfondie de cette implémentation.