構建動態Lambda表達式時，order和select有什么區別？

Question

此類使用字符串參數對記錄進行排序。它的工作原理

public class Order
{
    public static IEnumerable<T> OrderByDynamic<T>(IEnumerable<T> items, string sortby)
    {
        var property = typeof(T).GetProperty(sortby);

        var result = typeof(Order)
            .GetMethod("OrderByDynamic_Private", BindingFlags.NonPublic | BindingFlags.Static)
            .MakeGenericMethod(typeof(T), property.PropertyType)
            .Invoke(null, new object[] { items, sortby});

        return (IEnumerable<T>)result;
    }

    private static IEnumerable<T> OrderByDynamic_Private<T, TKey>(IEnumerable<T> items, string sortby)
    {
        var parameter = Expression.Parameter(typeof(T), "x");

        Expression<Func<T, TKey>> property_access_expression =
            Expression.Lambda<Func<T, TKey>>(
            Expression.Property(parameter, sortby),
            parameter);
            return items.OrderByDescending(property_access_expression.Compile());
        throw new Exception("Invalid Sort Direction");
    }
}

然后，我想使用字符串參數來確定選擇lambda表達式中的列。 它只是將所有名稱“ order”替換為“ select”，並將返回值替換為items.Select（property_access_expression.Compile（））;

然后我得到了錯誤“錯誤CS0266無法將類型'System.Collections.Generic.IEnumerable'隱式轉換為'System.Collections.Generic.IEnumerable'。存在顯式轉換。”如何解決此錯誤。

Answer 1

據我了解，您想動態選擇字段。 我建議您使用不同的方法進行訂購和選擇。 這是如何動態選擇給定字段的方法。 它僅選擇給定的字段，並為其他字段打印默認值。 因此，它適用於您的用例。

class test
{
    public string Code { get; set; }
    public int Id { get; set; }

    public override string ToString()
    {
        return Code + " " + Id;
    }
}

class MainClass
{
    public static void Main(string[] args)
    {
        List<test> list = new List<test>();

        list.Add(new test { Code = "1", Id = 5 });
        list.Add(new test { Code = "2", Id = 6 });
        list.Add(new test { Code = "3", Id = 7 });
        list.Add(new test { Code = "4", Id = 8 });

        list.AsQueryable()
             .Select(DynamicSelect<test>("Id"))
             .ToList()
             .ForEach(Console.WriteLine);
    }
}


public static Expression<Func<T, T>> DynamicSelect<T>(string fields)
{
    var members = fields.Split(',').Select(f => f.Trim());
    var targetType = typeof(T);
    var parameter = Expression.Parameter(targetType, "x");
    var bindings = new List<MemberBinding>();
    var target = Expression.Constant(null, targetType);

    foreach (var name in members)
    {
        var targetMember = Expression.PropertyOrField(target, name);
        var sourceMember = Expression.PropertyOrField(parameter, name);
        bindings.Add(Expression.Bind(targetMember.Member, sourceMember));
    }

    var body = Expression.MemberInit(Expression.New(targetType), bindings);
    return Expression.Lambda<Func<T, T>>(body, parameter);
}