1

假设一个数组Type作为标准对象，它指示必须显示的子类型。

楷模：

public abstract class Shape { }

public class Circle : Shape { }

public class Rectangle : Shape { }

我已经实现了应用此类查询的扩展方法

public static IQueryable<TSource> OfTypes<TSource, TResult>(
    this IQueryable<TSource> source, 
    Expression<Func<TSource, TResult>> expression, 
    params Type[] types)
{
    if (!types.Any())
    {
        return source;
    }

    Expression finalExpression = Expression.TypeIs(expression, types.First());

    foreach (var type in types.Skip(1))
    {
        finalExpression = Expression.OrElse(
            Expression.TypeIs(expression, type),
            finalExpression);
    }

    var lambdaExpression = Expression.Lambda<Func<TSource, bool>>(
        finalExpression, 
        expression.Parameters);

    return source.Where(lambdaExpression);
}

然后我可以像这样使用它

var types = new Type[] { typeof(Circle), typeof(Rectange) };
db.Shapres.OfTypes(s => s, types);

生成的表达式类似于

e => e is Circle || e is Rectange

正是我想要的，但我得到了这个错误

LINQ to Entities 不支持 LINQ 表达式节点类型“Lambda”。

甚至我在扩展方法的最后一行使用AsExpandable()了LinqKit的方法：

return source.AsExpandable().Where(lambdaExpression);

但又是同样的错误。

我也尝试过这样的PredicateBuilder但同样的错误

var finalExpression = PredicateBuilder.False<TSource>();

foreach (var type in types)
{
    var expressionParameter = Expression.Parameter(typeof(TSource), "it");
    var lambdaExpression = Expression.Lambda<Func<TSource, bool>>(
        Expression.TypeIs(expression, type), 
        expressionParameter);
    finalExpression.Or(lambdaExpression);
}

问题是什么？

如何在 EF 中毫无问题地将 an 转换Expression为 an ？Expression<Func<T, TResult>>

或者如何将Expression实例传递给Where扩展方法？

或者我如何使用Expression.TypeIsEF？

4

1 回答 1

1

您需要将参数传递给 Lambda 函数，将传入的表达式（即 lambda）传递给它。尝试通过删除不需要的“表达式”参数来在扩展方法内部创建参数。

public static IQueryable<TSource> OfTypes<TSource>(
        this IQueryable<TSource> source,
        params Type[] types)
    {
        if (!types.Any())
        {
            return source;
        }

        var param = Expression.Parameter(typeof(TSource), "p");

        Expression finalExpression = Expression.TypeIs(param, types.First());

        foreach (var type in types.Skip(1))
        {
            finalExpression = Expression.OrElse(
                Expression.TypeIs(param, type),
                finalExpression);
        }

        var lambdaExpression = Expression.Lambda<Func<TSource, bool>>(
            finalExpression, param);


        return source.Where(lambdaExpression);
    }

像这样调用：

var types = new Type[] { typeof(Circle), typeof(Rectangle) };
var test = context.Shapes.OfTypes(types);
于 2013-07-21T15:38:12.433 回答