LINQ：动态选择

Question

考虑，我们有这个类：

public class Data 
{ 
    public string Field1 { get; set; } 
    public string Field2 { get; set; } 
    public string Field3 { get; set; } 
    public string Field4 { get; set; } 
    public string Field5 { get; set; } 

} 

如何动态地选择指定的列？像这样：

var list = new List<Data>(); 

    var result= list.Select("Field1,Field2"); // How ? 

这是唯一的解决方案=>Dynamic LINQ？
所选字段在编译时未知。他们将在运行时指定

Answer 1

可以通过动态创建传递给Select:

Func<Data,Data> CreateNewStatement(string fields) 
{ 
    // input parameter "o" 
    var xParameter = Expression.Parameter(typeof(Data), "o"); 

    // new statement "new Data()" 
    var xNew = Expression.New(typeof(Data)); 

    // create initializers 
    var bindings = fields.Split(',').Select(o => o.Trim()) 
     .Select(o => { 

      // property "Field1" 
      var mi = typeof(Data).GetProperty(o); 

      // original value "o.Field1" 
      var xOriginal = Expression.Property(xParameter, mi); 

      // set value "Field1 = o.Field1" 
      return Expression.Bind(mi, xOriginal); 
     } 
    ); 

    // initialization "new Data { Field1 = o.Field1, Field2 = o.Field2 }" 
    var xInit = Expression.MemberInit(xNew, bindings); 

    // expression "o => new Data { Field1 = o.Field1, Field2 = o.Field2 }" 
    var lambda = Expression.Lambda<Func<Data,Data>>(xInit, xParameter); 

    // compile to Func<Data, Data> 
    return lambda.Compile(); 
} 

拉姆达这样做，那么你可以使用它像这样：

var result = list.Select(CreateNewStatement("Field1, Field2")); 

Answer 2

var result = from g in list.AsEnumerable() 
       select new {F1 = g.Field1,F2 = g.Field2}; 

Answer 3

使用反射和表达式bulid可以做你所说的。 例子：

var list = new List<Data>(); 
//bulid a expression tree to create a paramter 
ParameterExpression param = Expression.Parameter(typeof(Data), "d"); 
//bulid expression tree:data.Field1 
Expression selector = Expression.Property(param,typeof(Data).GetProperty("Field1")); 
Expression pred = Expression.Lambda(selector, param); 
//bulid expression tree:Select(d=>d.Field1) 
Expression expr = Expression.Call(typeof(Queryable), "Select", 
    new Type[] { typeof(Data), typeof(string) }, 
    Expression.Constant(list.AsQueryable()), pred); 
//create dynamic query 
IQueryable<string> query = list.AsQueryable().Provider.CreateQuery<string>(expr); 
var result=query.ToList(); 

Answer 4

您必须使用反射来获取并设置其名称的属性值。

var result = new List<Data>(); 
    var data = new Data(); 
    var type = data.GetType(); 
    var fieldName = "Something"; 

    for (var i = 0; i < list.Count; i++) 
    { 
     foreach (var property in data.GetType().GetProperties()) 
     { 
     if (property.Name == fieldName) 
     { 
      type.GetProperties().FirstOrDefault(n => n.Name == property.Name).SetValue(data, GetPropValue(list[i], property.Name), null); 
      result.Add(data); 
     } 
     } 
    } 

这里是GetPropValue（）方法

public static object GetPropValue(object src, string propName) 
{ 
    return src.GetType().GetProperty(propName).GetValue(src, null); 
} 

Answer 5

除了尼古拉斯巴特勒和马特（类型输入类是使用T）的评论暗示，我把一个提高尼古拉斯动态生成实体属性的应答，功能二进制不需要发送field作为参数。

对于使用添加类作为打击：

public static class Helpers 
{ 
    public static Func<T, T> DynamicSelectGenerator<T>(string Fields = "") 
    { 
     string[] EntityFields; 
     if (Fields == "") 
      // get Properties of the T 
      EntityFields = typeof(T).GetProperties().Select(propertyInfo => propertyInfo.Name).ToArray(); 
     else 
      EntityFields = Fields.Split(','); 

     // input parameter "o" 
     var xParameter = Expression.Parameter(typeof(T), "o"); 

     // new statement "new Data()" 
     var xNew = Expression.New(typeof(T)); 

     // create initializers 
     var bindings = EntityFields.Select(o => o.Trim()) 
      .Select(o => 
      { 

       // property "Field1" 
       var mi = typeof(T).GetProperty(o); 

       // original value "o.Field1" 
       var xOriginal = Expression.Property(xParameter, mi); 

       // set value "Field1 = o.Field1" 
       return Expression.Bind(mi, xOriginal); 
      } 
     ); 

     // initialization "new Data { Field1 = o.Field1, Field2 = o.Field2 }" 
     var xInit = Expression.MemberInit(xNew, bindings); 

     // expression "o => new Data { Field1 = o.Field1, Field2 = o.Field2 }" 
     var lambda = Expression.Lambda<Func<T, T>>(xInit, xParameter); 

     // compile to Func<Data, Data> 
     return lambda.Compile(); 
    } 
} 

的DynamicSelectGenerator方法得到实体T型，这种方法具有可选的输入参数Fields，如果你想从实体slect专业派作为一个字符串，如"Field1, Field2"，如果你不发送任何内容methid，它返回所有实体的字段，你可以使用下面这个方法：

using (AppDbContext db = new AppDbContext()) 
      { 
       //select "Field1, Field2" from entity 
       var result = db.SampleEntity.Select(Helpers.DynamicSelectGenerator<SampleEntity>("Field1, Field2")).ToList(); 

       //select all field from entity 
       var result1 = db.SampleEntity.Select(Helpers.DynamicSelectGenerator<SampleEntity>()).ToList(); 
      } 

（假设你有一个DbContext与名称AppDbContext和上下文与名称SampleEntity）

Answer 6

我已经使用的另一种方法是一个嵌套三元运算符的实体：

string col = "Column3"; 
var query = table.Select(i => col == "Column1" ? i.Column1 : 
           col == "Column2" ? i.Column2 : 
           col == "Column3" ? i.Column3 : 
           col == "Column4" ? i.Column4 : 
           null); 

三元运算符要求每个字段具有相同的类型，所以您需要在任何非字符串列上调用.ToString（）。