Liste <object> .Contains Expression Arbre

Question

Je voudrais construire une expression qui équivaudrait à attendre ...

Expression<Func<ReferencedEntity, bool>> expected = (ReferencedEntity referencedEntity) => foreignKeys.Contains(referencedEntity.Id); 
Expression<Func<ReferencedEntity, bool>> actual; 

type ForeignKeys est un List<object>

Voici ce que j'ai jusqu'à présent et je pense il utiliserait la méthode Expression.Call() mais ne sait pas exactement comment s'y prendre.

ParameterExpression entityParameter = Expression.Parameter(typeof(TReferencedEntity), "referencedEntity"); 
MemberExpression memberExpression = Expression.Property(entityParameter, "Id"); 
Expression convertExpression = Expression.Convert(memberExpression, typeof(object)); //This is becuase the memberExpression for Id returns a int. 

//Expression containsExpression = Expression.Call(???? 

//actual = Expression.Lambda<Func<TReferencedEntity, bool>>(????, entityParameter); 

Merci pour votre aide.

Answer 1

Voici la solution que je ne pouvais pas le faire sans la suggestion de Samuel mais ...

/// <summary> 
    /// 
    /// </summary> 
    /// <param name="foreignKeys"></param> 
    /// <returns></returns> 
    private Expression<Func<TReferencedEntity, bool>> BuildForeignKeysContainsPredicate(List<object> foreignKeys, string primaryKey) 
    { 
     Expression<Func<TReferencedEntity, bool>> result = default(Expression<Func<TReferencedEntity, bool>>); 

     try 
     { 
      ParameterExpression entityParameter = Expression.Parameter(typeof(TReferencedEntity), "referencedEntity"); 
      ConstantExpression foreignKeysParameter = Expression.Constant(foreignKeys, typeof(List<object>)); 
      MemberExpression memberExpression = Expression.Property(entityParameter, primaryKey); 
      Expression convertExpression = Expression.Convert(memberExpression, typeof(object)); 
      MethodCallExpression containsExpression = Expression.Call(foreignKeysParameter 
       , "Contains", new Type[] { }, convertExpression); 

      result = Expression.Lambda<Func<TReferencedEntity, bool>>(containsExpression, entityParameter); 

     } 
     catch (Exception ex) 
     { 
      throw ex; 
     } 

     return result; 
    } 

Answer 2

Je ne connais pas la solution, mais je sais comment vous pourriez l'obtenir. Créer une fonction fictive qui prend un Expression<Func<ReferencedEntity, bool>> et passez votre lambda. Et en utilisant un débogueur, vous pouvez examiner comment le compilateur a créé l'expression pour vous.