c# - 动态创建用于从 Entity Framework 获取数据的表达式查询

Question

我想创建一个 Expression 类型的查询，它从 Entity Framework 中获取实体的某些列。

假设我们有两个这样的类:

public class Parent
{
    public int Id { get; set; }
    public string Name { get; set; }
    public Child MyChild { get; set; }
}

public class Child
{
    public int Id { get; set; }
    public string Name { get; set; }
}

我们有一个 IQueryable Parent 列表:

var q = new List<Parent>()
{
    new Parent {Id = 1, Name = "a", Number = 1, MyChild=new Child{Id=11,Name="Child_a",Number=2}},
    new Parent {Id = 2, Name = "b", Number = 1, MyChild=new Child{Id=22,Name="Child_b",Number=2}},
    new Parent {Id = 3, Name = "c", Number = 1, MyChild=new Child{Id=33,Name="Child_c",Number=2}},
}.AsQueryable();

我想获得用户确定的 q 的那些属性的列表。例如，用户确定他需要 Parent.Name 和 Parent.MyChils.Name。所以我应该给用户一个匿名类型的列表，如下所示:

{"a","Child_a"}
{"b","Child_b"}
{"c","Child_c"} 

如果 Parent 实体不包含任何外键属性(在本例中为 MyChild 属性)，那么很容易创建一个表达式属性，它采用一些属性Parent 动态。我有一段代码可以获取 Person 的一些属性，但没有 MyChild 属性:

var columns = new List<string> { "Id", "Name" };
var xParam = Expression.Parameter(typeof(Parent), "x");
var sourceProperties = columns.ToDictionary(name => name,
    name => q.ElementType.GetProperty(name));
var dynamicType = LinqRuntimeTypeBuilder.GetDynamicType(sourceProperties.Values);
var bindings =
    dynamicType.GetFields()
        .Select(p => Expression.Bind(p, Expression.Property(xParam, sourceProperties[p.Name])))
        .OfType<MemberBinding>();
var newExpr = Expression.New(dynamicType.GetConstructor(Type.EmptyTypes));
Expression selector = Expression.Lambda(Expression.MemberInit(
    Expression.New(dynamicType.GetConstructor(Type.EmptyTypes)), bindings), xParam);
var body = Expression.MemberInit(newExpr, bindings);
var lambda = Expression.Lambda<Func<Parent, dynamic>>(body, xParam);
var t = q.Select(lambda);

(这里有2个用到的方法:)

public static Type GetDynamicType2(Dictionary<string, Type> fields)
{
    if (null == fields)
        throw new ArgumentNullException("fields");
    if (0 == fields.Count)
        throw new ArgumentOutOfRangeException("fields", "fields must have at least 1 field definition");
    try
    {
        Monitor.Enter(builtTypes);
        string className = "MyDynamicType";
        if (builtTypes.ContainsKey(className))
            return builtTypes[className];
        TypeBuilder typeBuilder = moduleBuilder.DefineType(className,
            TypeAttributes.Public | TypeAttributes.Class | TypeAttributes.Serializable);
        foreach (var field in fields)
            typeBuilder.DefineField(field.Key, field.Value, FieldAttributes.Public);
        builtTypes[className] = typeBuilder.CreateType();
        return builtTypes[className];
    }
    catch (Exception ex)
    {
    }
    finally
    {
        Monitor.Exit(builtTypes);
    }

    return null;
}

public static Type GetDynamicType(IEnumerable<PropertyInfo> fields)
{
    return GetDynamicType(fields.ToDictionary(f => f.Name, f => f.PropertyType));
}

但我仍然无法获取 Parent 的 MyChild 属性的内部属性。

怎么做？

Answer 1

由于没有人回答我的问题，我尝试了很多不同的方法来解决它，结果问题利用 Expression 的递归创建解决了。对于 Class 类型的每个属性(如问题中的 MyChild)，我们大多数情况下都会创建一个 Expression。 表达式的创建大部分是这样递归的:

    private Expression BuildExpression(Expression parentExpression,
        Type parentPropertyType, string pathOfChildProperty)
    {
        string remainPathOfChild;
        var childPropertyName = 
              GetFirstPropertyNameFromPathAndRemainPath(pathOfChildProperty, out remainPathOfChild);
        if (string.IsNullOrEmpty(childPropertyName)) return parentExpression;
        var childPropInfo = parentPropertyType.GetProperty(childPropertyName);
        var childExpression = Expression.Property(parentExpression, childPropInfo);
        return !string.IsNullOrEmpty(remainPathOfChild)
            ? BuildExpressionForInternalProperty(childExpression, childPropInfo.PropertyType, remainPathOfChild)
            : childExpression;
    }
    private string GetFirstPropertyNameFromPathAndRemainPath(string path, out string remainPath)
    {
        if (string.IsNullOrEmpty(path))
        {
            remainPath = null;
            return null;
        }
        var indexOfDot = path.IndexOf('.');
        if (indexOfDot < 0)
        {
            remainPath = null;
            return path;
        }
        remainPath = path.Substring(indexOfDot + 1);
        return path.Substring(0, indexOfDot);
    }
    }

当内部属性的剩余路径为空时，递归调用将停止。在最高级别调用此方法是这样的:

var inputParameter = Expression.Parameter(typeof(GrandParent), "x");
var expChildProperty = 
    BuildExpression(inputParameter,typeof(Parent),"Parent.MyChils.Name");

上述问题的最终结果表达式是 (($x.Parent).MyChils).Name 在调试 View 中。