C# 使用lambda表达式代替IComparer参数

使用C#是否可以在方法调用中将lambda表达式作为IComparer参数传递

例如

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

var x=someIEnumerable.OrderBy（aClass e=>e.someProperty，
（aClass x，aClass y）=>
x、 someProperty>y.someProperty？1:x.someProperty

我不能很好地编译它，所以我猜不会，但lambdas和匿名委托之间的协同作用似乎非常明显，我觉得我一定是做了一些愚蠢的错误

---

TIA

如果您在.NET4.5上，可以使用静态方法

比较器

例如：

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

var x=someIEnumerable.OrderBy（e=>e.someProperty，
创建比较器（（x，y）=>x.someProperty>y.someProperty？1:x.someProperty
正如Jeppe指出的，如果您使用的是.NET4.5，那么可以使用静态方法
Comparer.Create

如果不是，则这是一个等效的实现：

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

公共类函数比较程序：IComparer
{
专用函数比较器；
公职人员比较员（职能比较员）
{
this.comparer=比较器；
}
公共静态IComparer创建（Func comparer）
{
返回新的功能比较程序（比较器）；
}
公共整数比较（TX，TY）
{
返回比较器（x，y）；
}
}
如果您始终希望比较投影的键（例如单个属性），可以定义一个类来封装所有键比较逻辑，包括空检查、两个对象上的键提取以及使用指定或默认内部比较器进行键比较：

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

公共类键比较器：比较器
{
专用只读功能键选择器；
专用只读IComparer\u innerComparer；
公钥比较器(
Func键选择器，
IComparer innerComparer=null）
{
_键选择器=键选择器；
_innerComparer=innerComparer？？Comparer.Default；
}
公共覆盖int比较（TSource x，TSource y）
{
if（object.ReferenceEquals（x，y））
返回0；
如果（x==null）
返回-1；
如果（y==null）
返回1；
TKey xKey=_keySelector（x）；
TKey yKey=_keySelector（y）；
返回_innerComparer.Compare（xKey，yKey）；
}
}

为方便起见，工厂方法：

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

公共静态类密钥比较器
{
公共静态键比较器创建(
Func键选择器，
IComparer innerComparer=null）
{
返回新的KeyComparer（KeySelect，innerComparer）；
}
}

然后您可以这样使用：

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

var sortedSet=new sortedSet（keycomarer.Create（（MyClass o）=>o.MyProperty））；

有关此实现的详细讨论，请参阅my。
此处可能的答案：可能希望为此类指定不同的名称，以避免与库的类冲突。语法详细信息：泛型类的构造函数不得包含类名的
部分。遗憾的是，我们正在.Net 3.5中苦苦挣扎！无法负担将TFS升级到最新版本所需的mega wedge:-（@haughtonomous如果这是唯一阻碍您的因素，您是否考虑过将TFS转为其他类型？您知道基本理论（不像“因为它需要lambda以外的类型”）关于为什么我们不能直接将lambda放在那里，但需要一个包装器？@jw_u。我不确定这背后有多少理论。OrderBy

（Linq）的作者决定不让重载接受用于比较的委托（如

比较

委托）。如果需要，您可以创建自己的扩展方法。理论上该接口有2+个方法。