2

我写了一些谓词，并希望它们构造一个实体查询。

通常，如果我有一个类型的实体，EntityA我会写这种表达式Expression<Func<EntityA, bool>>。

我想要完成的是Expression<Func<EntityB, bool>>在 type 的查询中使用EntityA。

假设EntityA有一个集合EntityB。我有一个谓词EntityAlike ：

public static Expression<Func<EntityA, bool>> HasId(int id)
{
    return p => p.Id == id;
}

现在在查询我的 EntityB 时，我希望能够使用这个谓词以避免在Expression<EntityB, bool>> (with p => p.EntityA.Id == id).

我想要类似的东西：

Expression<Func<EntityB, bool>> predicates = p => **initial condition on EntityB**
var myfunc = HasId(12).Compile();
predicates = predicates.And(p => myfunc(p.EntityA));

此语法不起作用。

如何Expression<Func<EntityA, bool>>在Expression<Func<EntityB,bool>>谓词中使用 a？

* 编辑 *

忘了提我在我的项目中使用 Devforce（来自 Ideablade）。谓词。并且来自它们（我最初以为我来自系统）。

错误消息是：

未知表达式类型：Invoke(value(UserQuery+<>c__DisplayClass1).myfunc , p.EntityA)

Stacktrace 是：

   à IdeaBlade.Linq.ExpressionVisitor.VisitExpressionCore(Expression e)
   à IdeaBlade.Linq.TransformExpressionVisitor.VisitExpressionCore(Expression expr)
   à IdeaBlade.Linq.ExpressionVisitor.VisitExpression(Expression expr)
   à IdeaBlade.Linq.ExpressionVisitor.VisitExpressionCore(Expression e)
   à IdeaBlade.Linq.TransformExpressionVisitor.VisitExpressionCore(Expression expr)
   à IdeaBlade.Linq.ExpressionVisitor.VisitExpression(Expression expr)
   à IdeaBlade.Linq.ExpressionVisitor.VisitExpressionCore(Expression e)
   à IdeaBlade.Linq.TransformExpressionVisitor.VisitExpressionCore(Expression expr)
   à IdeaBlade.Linq.ExpressionVisitor.VisitExpression(Expression expr)
   à IdeaBlade.Linq.ExpressionVisitor.VisitExpressionCore(Expression e)
   à IdeaBlade.Linq.TransformExpressionVisitor.VisitExpressionCore(Expression expr)
   à IdeaBlade.Linq.ExpressionVisitor.VisitExpression(Expression expr)
   à IdeaBlade.Linq.ExpressionVisitor.VisitExpressionCore(Expression e)
   à IdeaBlade.Linq.TransformExpressionVisitor.VisitExpressionCore(Expression expr)
   à IdeaBlade.Linq.ExpressionVisitor.VisitExpression(Expression expr)
   à IdeaBlade.Linq.ExpressionVisitor.<VisitExpressions>b__0(Expression e)
   à System.Linq.Enumerable.WhereSelectEnumerableIterator`2.MoveNext()
   à System.Linq.Buffer`1..ctor(IEnumerable`1 source)
   à System.Linq.Enumerable.ToArray[TSource](IEnumerable`1 source)
   à IdeaBlade.Linq.ExpressionVisitor.VisitExpressions(IEnumerable`1 expressions)
   à IdeaBlade.Linq.ExpressionVisitor.VisitExpressionCore(Expression e)
   à IdeaBlade.Linq.TransformExpressionVisitor.VisitExpressionCore(Expression expr)
   à IdeaBlade.Linq.ExpressionVisitor.VisitExpression(Expression expr)
   à IdeaBlade.Linq.ExpressionVisitor.Visit(Expression expr)
   à IdeaBlade.EntityModel.EntityQuery`1.ProcessExpression(Expression e)
   à IdeaBlade.EntityModel.EntityQuery`1..ctor(Expression expression, IQueryable queryable)
   à IdeaBlade.EntityModel.EntityQuery`1.System.Linq.IQueryProvider.CreateQuery[TElement](Expression expression)
   à System.Linq.Queryable.Where[TSource](IQueryable`1 source, Expression`1 predicate)
   à IdeaBlade.EntityModel.EntityQueryExtensions.Where[TSource](IEntityQuery`1 source1, Expression`1 predicate)
4

1 回答 1

0

您可以动态构建Expression<EntityB,bool>谓词，但它的可重用性值得怀疑。请注意，如果使用实体框架，则不支持调用表达式。

- 更新

这有效并且可重复使用：

public static Expression<Func<T2, bool>> SubPredicate<T1, T2>( Expression<Func<T1, bool>> predicate, Expression<Func<T2, T1>> selector )
{
    var parms = selector.Parameters;

    var a = Expression.Invoke( selector, parms );

    var invocation = Expression.Invoke( predicate, a );

    return ( Expression<Func<T2, bool>> )Expression.Lambda( invocation, parms );
}

用法：

var filteredResults = list.Where( 
    SubPredicate<EntityA, EntityB>( 
        a => a.ID % 2 == 1, 
        b => b.EntityA )
        .Compile() );

-- 演示：

static void Main( string[] args )
{
    var list = new List<EntityB>()
    {
        new EntityB()
        {
            ID = 11,
            EntityA = new EntityA() { ID = 1 }
        },
        new EntityB()
        {
            ID = 22,
            EntityA = new EntityA() { ID = 2 }
        },
        new EntityB()
        {
            ID = 33,
            EntityA = new EntityA() { ID = 3 }
        },
    };

    var filteredResults = list.Where( 
        SubPredicate<EntityA, EntityB>( 
            a => a.ID % 2 == 1, 
            b => b.EntityA )
            .Compile() );

    foreach( var b in filteredResults )
    {
        Console.WriteLine( "{0}/{1}", b.ID, b.EntityA.ID );
    }

    Console.ReadLine();
}
于 2014-08-04T15:07:59.500 回答