创建匿名LINQ Lambda排序表达式

Question

如何创建可以基于MyObject属性的sortExpression的通用方法，如下所示：

void CreateSortedReport(IList<MyObject> list, Expression<Func<MyObject, TSort>> sortExpression, bool ascending = true) 
{
    //sort the [list] by sortExpression and by direction;
}

这样我就可以像这样使用它：

CreateSortedReport(myItems, x=>x.Name);

要么

CreateSortedReport(myItems, x=>x.CreateDate);

编辑1：之所以我要求通用方法，是因为有些方法非常相似：

CreateReportSortedByName(myItems) {
    return myItems.OrderBy(x=>x.Name);
}

CreateReportSortedByDate(myItems) {
    return myItems.OrderBy(x=>x.CreateDate);
}

Answer 1

假设MyObject是一个具体类型，只需将一个通用参数（ <TSort> ）添加到您的方法签名中：

void CreateReport<TSort>(IList<MyObject> list, Expression<Func<MyObject, TSort>> sortExpression, bool ascending = true)

如果希望MyObject作为通用参数，则签名将如下所示：

void CreateReport<MyObject, TSort>(IList<MyObject> list, Expression<Func<MyObject, TSort>> sortExpression, bool ascending = true)

Answer 2

要使用内置排序功能提供就地排序，您需要编写一个实现IComparer<T> 。

例如：

class CompareWithDelegate<TOnObject, TSort> : IComparer<TOnObject>
{
    Func<TOnObject, TSort> evaluator;
    IComparer comparer = Comparer.Default;
    bool ascending;
    public CompareWithDelegate(Expression<Func<TOnObject, TSort>> expr, bool ascending = true)
    {
        evaluator = expr.Compile();
        this.ascending = ascending;
    }
    public int Compare(TOnObject left, TOnObject right)
    {
        var leftVal = evaluator(left);
        var rightVal = evaluator(right);
        return (ascending ? 1 : -1) * comparer.Compare(leftVal, rightVal);
    }
}

接着：

void CreateSortedReport<TSort>(List<MyObject> list, Expression<Func<MyObject, TSort>> sortExpression, bool ascending = true) 
{
    list.Sort(new CompareWithDelegate<MyObject, TSort>(sortExpression));
    list.Dump();    
}

请注意， list必须是List<MyObject> ，而不是IList<MyObject> 。

另外，如果您不需要就地安装，则有两种选择：

将签名更改为Func<MyObject, TSort> ：

void CreateSortedReport<TSort>(List<MyObject> list, Func<MyObject, TSort> sortExpression, bool ascending = true) 
{
    var t = 
        ascending 
        ? list.OrderBy (sortExpression)
        : list.OrderByDescending(sortExpression);
}

或即时编译表达式：

void CreateSortedReport<TSort>(List<MyObject> list, Expression<Func<MyObject, TSort>> sortExpression, bool ascending = true) 
{
    var method = sortExpression.Compile();
    var t = 
        ascending 
        ? list.OrderBy (method)
        : list.OrderByDescending(method);
}

Answer 3

您可以基于内置List（of T）.Sort（IComparer（of T））构建扩展方法。

public static class SortExtension
{
    public static void SortBy<T, TProperty>(this List<T> list, Func<T, TProperty> orderby, bool ascending = true)
    {
        list.Sort(new InnerComparer<T, TProperty>(orderby, ascending));
    }

    class InnerComparer<T, TProperty> : IComparer<T>
    {
        private readonly Func<T, TProperty> _property;
        private readonly int _ascending;

        public InnerComparer(Func<T, TProperty> property, bool ascending)
        {
            _property = property;
            _ascending = ascending ? 1 : -1;
        }

        int IComparer<T>.Compare(T x, T y)
        {
            var p1 = _property(x);
            var p2 = _property(y);

            return _ascending * Comparer<TProperty>.Default.Compare(p1, p2);
        }
    }
}

用法：

myObjects.SortBy(o => o.MyProperty);