5 
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Net;
using System.Text;
using System.Text.RegularExpressions;
using System.Web.UI.WebControls;
using dynamic = System.Linq.Dynamic;
using System.Linq.Expressions;

namespace Project.Lib.Extensions
{
    public static partial class Utils
    {
        public static List<T> SortForMe<T>(this List<T> list, string propertyName,SortDirection sortDirection)
        {
            string exp1 = string.Format("model.{0}", propertyName);
            var p1 = Expression.Parameter(typeof(T), "model");
            var e1 = dynamic.DynamicExpression.ParseLambda(new[] { p1 }, null, exp1);

            if (e1 != null)
            {
                if (sortDirection==SortDirection.Ascending)
                {
                    var result = list.OrderBy((Func<T, object>)e1.Compile()).ToList();
                    return result;
                }
                else
                {
                    var result = list.OrderByDescending((Func<T, object>)e1.Compile()).ToList();
                    return result;
                }
            }
            return list;
        }
    }
}

我正在使用此代码按 propertyName 对我的通用列表进行排序。当属性类型为string时，此代码成功运行，但当类型为longorint时，我收到此异常：

无法将“System.Func`2[Project.Lib.Model.UserQueryCount,System.Int64]”类型的对象转换为“System.Func`2[Project.Lib.Model.UserQueryCount,System.Object]”。

var result = list.OrderBy((Func<T, dyamic>)e1.Compile()).ToList();

在上面的行中，我决定使用dynamic，但再次遇到异常。我应该怎么办？

我改变了我的方法是这样的：

public static List<TModel> SortForMe<TModel>(this List<TModel> list, string propertyName,SortDirection sortDirection) where TModel:class
    {
        var ins = Activator.CreateInstance<TModel>();
        var prop= ins.GetType().GetProperty(propertyName);
        var propertyType =  prop.PropertyType;

    string exp1 = string.Format("model.{0}", propertyName);
    var p1 = System.Linq.Expressions.Expression.Parameter(typeof(TModel), "model");
    var e1 = System.Linq.Dynamic.DynamicExpression.ParseLambda(new[] { p1 }, null, exp1);

    if (e1 != null)
    {
        if (sortDirection==SortDirection.Ascending)
        {
            return list.OrderBy((Func<TModel, propertyType>)e1.Compile()).ToList();
        }

        return list.OrderByDescending((Func<TModel, propertyType>)e1.Compile()).ToList();
    }
        return list;
}

我使用反射获得了 propertyType，但在 Func 中我不能像这样使用它："Func<TModel, propertyType>"有什么方法可以解决这个问题

谢谢您的帮助。

4

2 回答 2

2

如另一个答案所述，它不起作用的原因确实是拳击。

class S
{
  public int f;
  public S s;
}

{
  Func<S, S> sGetter = s => s.s; // okay
  Func<S, object> objectGetter = s => s.s; // okay
  objectGetter = sGetter; // also okay
}

{
  Func<S, int> intGetter = s => s.f; // okay
  Func<S, object> objectGetter = s => s.f; // still okay
  objectGetter = intGetter; // not okay
}

有效但最后一个分配无效的原因Func<S, object> objectGetter = s => s.f是它实际上被解释为Func<S, object> objectGetter = s => (object)s.f，并且强制转换执行了实际操作。intGetter和objectGetter不做同样的事情，所以不能将一个重新解释为另一个。意识到这一点，如果您自己包含该演员表，您应该没问题。据我所知，如果您简单地指定所需的返回类型为object：

var e1 = DynamicExpression.ParseLambda(new[] { p1 }, typeof(object), exp1);
于 2012-08-04T13:35:15.990 回答
0

我怀疑这与值类型的装箱有关，但我不能确定。但是，有一种解决方法不涉及装箱，既可以解决您的问题，又可以使您的方法更易于使用。

您实际上可以使用返回该属性的 lambda 表达式，而不是标识要排序的属性的字符串。这可以通过以下方法完成：

private static string GetPropertyName<TObject, TProperty>(Expression<Func<TObject,     TProperty>> property)
{
    MemberExpression memberExpression = (MemberExpression)property.Body;
    PropertyInfo propertyInfo = (PropertyInfo)memberExpression.Member;

    return propertyInfo.Name;
}

请注意，我已将Func委托包装到Expression类型中（您可能想了解更多相关信息）。这样，我可以询问表达式并找出它使用了哪些成员。当然，除了简单的x => x.Propertylambda 之外，这将失败，因此您可能需要进行一些错误检查。

要使用它，您必须稍微更改扩展方法：

public static List<TObject> SortForMe<TObject, TProperty>(
    this List<TObject> list, 
    Expression<Func<TObject, TProperty>> property, 
    SortDirection sortDirection)
{
     string propertyName = GetPropertyName(property);
     ...
     ...          
     // when casting compiled expression to Func, instead of object, use TProperty
     // that way, you will avoid boxing
     var result = list.OrderBy((Func<T, TProperty>)e1.Compile()).ToList();
     ...
     ...
}

实际用法可能如下所示：

List<Foo> foos = ... ;
foos.SortForMe(x => x.IntegerProperty, SortDirection.Ascending);
foos.SortForMe(x => x.StringProperty, SortDirection.Ascending);

IntegerProperty和是在类型上定义的StringProperty实际属性。Foo使用该方法时无需指定实际的类型参数 - C# 的类型推断在这里非常好地发挥了作用。

于 2012-08-03T20:30:33.640 回答