C# 如何从列表创建新对象<&燃气轮机；按表达式数组

我有一个列表，希望能够定义一个表达式列表，选择这个表达式列表中定义的新对象

但我不知道如何将表达式列表传递给data.Select（）。 类似这样的内容：data.Select（SelectExpressionList）

公共类测试
{
公共程序（）
{
var foo=new foo（）；
Add（newuser（）{id=1，LastName=“User1”，Other=“A”}）；
添加（newuser（）{id=2，LastName=“User2”，Other=“B”}）；
Add（newuser（）{id=3，LastName=“User3”，Other=“C”}）；
foo.AddExpression（u=>u.id）；
foo.AddExpression（u=>u.LastName）；
var result=foo.CreateNewByExpression（）；//我想要列表对象{id，LastName}
}
}
公共类用户
{
公共int id{get；set；}
公共字符串LastName{get；set；}
公共字符串其他{get；set；}
}
公开课Foo
{
公共列表数据=新列表（）；
public List SelectExpressionsList=新建列表（）；
公共列表CreateNewByExpression（）
{
返回数据。Select（..）；//我想要由SelectExpressions定义的列表对象
}
public void AddExpression（表达式exp）
{
选择表达式列表。添加（exp）；
}
}

希望，很清楚，我想要实现的。 谢谢

编辑：

---

它不必是匿名类型。我想要只具有“选定”属性的列表…

您可以使用

ExpandoObject

。看我的

使用系统；
使用System.Linq；
使用System.Collections.Generic；
使用System.Linq.Expressions；
运用系统动力学；
公共课程
{
公共静态void Main（）
{       
var foo=new foo（）；
Add（newuser（）{id=1，LastName=“User1”，Other=“A”}）；
添加（newuser（）{id=2，LastName=“User2”，Other=“B”}）；
Add（newuser（）{id=3，LastName=“User3”，Other=“C”}）；
foo.AddExpression（u=>u.id）；
foo.AddExpression（u=>u.LastName）；
var result=foo.CreateNewByExpression（）；
Console.WriteLine（result.First（）.LastName）；
}
}
公共类用户
{
公共int id{get；set；}
公共字符串LastName{get；set；}
公共字符串其他{get；set；}
}
公开课Foo
{
公共列表数据=新列表（）；
public List SelectExpressionsList=新建列表（）；
public IEnumerable CreateNewByExpression（）
{
foreach（数据中的var项）
{
IDictionary result=新的ExpandooObject（）；
foreach（SelectExpressionList中的var exp）
{
string name=GetMember（exp.Body）.Member.name；
结果[名称]=exp.Compile（）（项）；
}
将返回结果作为ExpandooObject；
}
}
public void AddExpression（表达式exp）
{
选择表达式列表。添加（exp）；
}
公共静态MemberExpression GetMember（表达式）
{
MemberExpression=null；
开关（表达式.节点类型）
{
case ExpressionType.MemberAccess：
exp=作为MemberExpression的表达式；
打破
大小写表达式类型。转换：
exp=（（UnaryExpression）表达式）。操作数作为MemberExpression；
打破
违约：
打破
}
返回经验；
}
}

你不能这样做：匿名对象的类是由编译器创建的；编译完成后，无法创建它们。此外，如果没有知道并使用匿名对象结构的代码，那么匿名对象就没有那么大的帮助。它不必是匿名类型。我可以选择只有“选定”属性的对象。这正是我所需要的。非常感谢。

public class Test
{
    public void Process()
    {
        var foo = new Foo<User>();

        foo.data.Add(new User() { id = 1, LastName = "User1", Other = "A" });
        foo.data.Add(new User() { id = 2, LastName = "User2", Other = "B" });
        foo.data.Add(new User() { id = 3, LastName = "User3", Other = "C" });

        foo.AddExpression(u => u.id);
        foo.AddExpression(u => u.LastName);

        var result = foo.CreateNewByExpression(); // I want List<> object {id, LastName}

    }

}

public class User
{
    public int id { get; set; }
    public string LastName { get; set; }

    public string Other { get; set; }


}
public class Foo<T>
{

    public List<T> data = new List<T>();

    public List<Expression> SelectExpressionsList = new List<Expression>();
    public List<object> CreateNewByExpression()
    {
        return data.Select(....); // I want List<> object defined by SelectExpressions
    }

    public void AddExpression<TKey>(Expression<Func<T, TKey>> exp)
    {
        SelectExpressionsList.Add(exp);
    }


}

using System;
using System.Linq;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Dynamic;

public class Program
{
    public static void Main()
    {       
        var foo = new Foo<User>();

        foo.data.Add(new User() { id = 1, LastName = "User1", Other = "A" });
        foo.data.Add(new User() { id = 2, LastName = "User2", Other = "B" });
        foo.data.Add(new User() { id = 3, LastName = "User3", Other = "C" });

        foo.AddExpression(u => u.id);
        foo.AddExpression(u => u.LastName);

        var result = foo.CreateNewByExpression(); 
        Console.WriteLine(result.First().LastName);
    }
}

public class User
{
    public int id { get; set; }

    public string LastName { get; set; }

    public string Other { get; set; }

}

public class Foo<T>
{
    public List<T> data = new List<T>();

    public List<Expression<Func<T, object>>> SelectExpressionsList = new List<Expression<Func<T, object>>>();

    public IEnumerable<dynamic> CreateNewByExpression()
    {
        foreach (var item in data)
        {
            IDictionary<string, object> result = new ExpandoObject();
            foreach (var exp in SelectExpressionsList)
            {
                string name = GetMember(exp.Body).Member.Name;
                result[name] = exp.Compile()(item);
            }

            yield return result as ExpandoObject;
        }
    }

    public void AddExpression(Expression<Func<T, object>> exp)
    {
        SelectExpressionsList.Add(exp);
    }

    public static MemberExpression GetMember(Expression expression)
    {
        MemberExpression exp = null;
        switch (expression.NodeType)
        {
            case ExpressionType.MemberAccess:
                exp = expression as MemberExpression;
                break;
            case ExpressionType.Convert:
                exp = ((UnaryExpression)expression).Operand as MemberExpression;
                break;
            default:
                break;
        }

        return exp;
    }
}