c# List<string> to Lambda Expression with starter example: Refactor to handle the List

Question

我有这个：

List<string> fields;

fields[0] = "firstFieldName";
fields[1] = "secondFieldName";
...
fields[n] = "nthFieldName";

我想得到这个：

var selector = p => new {p.firstField, p.secondField, ..., p.nthFieldName}

// selector is of type Expression<Func<Entity, object>>

GoofBallLogic 有类似的this code，最后是p => p.column

// Entity is an object in a diagram from Entity Framework 4
var p = Expression.Parameter(typeof(Entity, "p");

var selector = Expression.Lambda<Func<Entity, string>(
    Expression.Property(p, columnToGroupBy), p );

编辑：我想要完成的事情

我有一个“通用”存储库：

public class Repository<E, C> : IRepository<E,C>
{
    private C _dc {get;set;} // ObjectContext (Entity Framework 4)
    private string _entityName {get;set;}
    public string entityKeyName {get;private set;}
    public List<string> entityKeys {get;private set;}
    public Expression<Func<E, object>> entityKey {get;private set;}
    private EntityContainer _containerName {get;set;}

    public Repository(C myDC)
    {   _dc = myDC; // TODO: check for null

        // Name of "this" ObjectContext
        _containerName = _dc.MetadataWorkspace.GetEntityContainer(
            _dc.DefaultContainerName, DataSpace.CSpace);

        // Name of "this" Entity
        _entityName = _containerName.BaseEntitySets
            .Where(p => p.ElementType.Name == typeof (E).Name)
            .Select( p => p.Name).FirstOrDefault();

        // String list of the keys
        entityKeys = _containerName
            .BaseEntitySets.First(meta => meta.ElementType.Name == 
                typeof(E).Name)
            .ElementType.KeyMembers.Select(k => k.Name).ToList();

        // Thanks Jon Skeet for this cool comma sep list formula
        entityKeyName = string.Join(",", entityKeys.ToArray() );  

        entityKey = Expression.Lambda<Func<E, object>> ... 

如何将 entityKey 设置为可用于 一个 OrderBy 语句，因为 Linq to Entities 需要 在执行 .Skip().Take() 之前订购一套

编辑：

令人惊讶的是，Orderby 可以接受这个：

p => "field1,field2,field3"

这允许我的代码执行，但实际上并没有按字段值对项目进行排序。我猜这是 TDD 的第一步：使用文字。

Answer 1

我发现这是一个有趣的问题并花了一些时间来解决它，并找到了一种相对简单的方法。

无论如何，这是一个关于如何进行单个字段排序的示例（我将使用您的第一个字段），如果您想对更多字段进行排序，您也必须为它们创建表达式并使用 .ThenBy(xxx ) 在通常的 OrderBy(xxx) 之后。

    // Create a parameter which passes the object
    ParameterExpression param = Expression.Parameter(typeof(E), "a");

    // Create body of lambda expression
    Expression body = Expression.PropertyOrField(param, fieldname);

    // Create lambda function
    Expression<Func<E, string>> exp = Expression.Lambda<Func<E, string>>(body, param);

    // Compile it so we can use it
    Func<E, string> orderFunc = exp.Compile();

现在您可以执行 OrderBy(orderFunc)，它会根据 fieldname 中命名的属性对列表进行排序。唯一的缺点是它仅适用于字符串字段（表达式的返回值）。不过可能也可以解决这个问题。

已修复以适用于任何 IComparable 类型：

        // Create a parameter which passes the field
        ParameterExpression param = Expression.Parameter(typeof(E), "a");

        // Create body of lambda expression
        Expression body = Expression.TypeAs(Expression.PropertyOrField(param, fieldname), typeof(IComparable));

        // Create lambda function
        Expression<Func<E, IComparable>> exp = Expression.Lambda<Func<E, IComparable>>(body, param);

        // Compile it so we can use it
        Func<E, IComparable> orderFunc = exp.Compile();

Answer 2

您不能轻易做到这一点，因为您无法为运行时不存在的类型构造 new 表达式。 （您可以在 C# 中使用匿名类型，因为 C# 编译器会为您创建类型。）

如果您想以 非常困难的方式 做到这一点，您可以生成一个动态程序集并实际创建您需要的类型。有一个short example here。

不过，我怀疑有一种更简单的方法。我们需要知道您没有说明的目标是什么（您需要这个表达式树来做什么）。

Answer 3

从您编辑的问题来看，您似乎只是希望能够通过多个键进行排序。这很容易通过使用.OrderBy() 后跟.ThenBy() 来实现。我假设你在这里使用IQueryable<E>：

IQueryable<E> query = ...;
IOrderedQueryable<E> ordered = null;

foreach (var key in entityKeys)
{
    // Code from Doggett to construct the lambda expression for one step
    ParameterExpression param = Expression.Parameter(typeof(E), "a");
    var body = Expression.TypeAs(
        Expression.PropertyOrField(param, key),
        typeof(IComparable));
    var exp = Expression.Lambda<Func<E, IComparable>>(body, param);

    if (ordered == null)
        ordered = query.OrderBy(exp);
    else
        ordered = ordered.ThenBy(exp);
}

var finalQuery = (ordered ?? query).Skip(n).Take(m);