C# IQueryable 在 Where throws 中使用字典无法创建异常类型的常量值

Question

我在 IQueryable lambda linq 中使用字典抛出了

Unable to create a constant value of type 'System.Collections.Generic.KeyValuePair`2

代码：

Dictionary<int, int> keyValues = new Dictionary<int, int>();

IQueryable<Account> = context.Account
    .Where(W => keyValues
        .Where(W1 => W1.Key == S.AccountID)
        .Where(W1 => W1.Value == S.Balance)
        .Count() > 0);

详情：

我有这样的字典里面的数据

AccountID 余额

11000

2 2000

3 3000

我希望用户具有 (ID = 1 AND Balance = 1000) OR (ID = 2 AND BALANCE = 2000) OR (ID = 3 AND BALANCE = 3000)

那么我该如何为它编写 lambda 表达式呢？

已编辑

谢谢@caesay，你的回答对我帮助很大。

我希望你再帮我一个忙。

根据您的回答，我创建了如下所示的表达式：

private static Expression<Func<Accounting, bool>> GenerateExpression(Dictionary<int, int> lstAccountsBalance)
{
    try
    {
        var objAccounting = Expression.Parameter(typeof(Accounting));
        Expression expr = null;
        const bool NOT_ALLOWED = false;

        if (lstAccountsBalance != null && lstAccountsBalance.Count > 0)
        {
            var clauses = new List<Expression>();

            foreach (var kvp in lstAccountsBalance)
            {
                clauses.Add(Expression.AndAlso(
                    Expression.Equal(Expression.Constant(kvp.Key), Expression.Property(objAccounting, nameof(Accounting.ID))),
                    Expression.Equal(Expression.Constant(kvp.Value), Expression.Property(objAccounting, nameof(Accounting.Balance)))
                ));
            }

            expr = clauses.First();
            foreach (var e in clauses.Skip(1))
            {
                expr = Expression.OrElse(e, expr);
            }

            var notAllowedExpr = Expression.AndAlso(
                    Expression.Equal(Expression.Constant(NOT_ALLOWED), Expression.Property(objAccounting, nameof(Accounting.ALLOWED))),
                    Expression.Equal(Expression.Constant(true), Expression.Constant(true))
                );

            expr = Expression.And(notAllowedExpr, expr);
        }

        var allowedExpr = Expression.AndAlso(
                Expression.Equal(Expression.Constant(!NOT_ALLOWED), Expression.Property(objAccounting, nameof(Accounting.ALLOWED))),
                Expression.Equal(Expression.Property(objAccounting, nameof(Accounting.ID)), Expression.Property(objAccounting, nameof(Accounting.ID)))
            );

        if (expr != null)
        {
            expr = Expression.OrElse(allowedExpr, expr);
        }
        else
        {
            expr = allowedExpr;
        }

        return Expression.Lambda<Func<Accounting, bool>>(expr, objAccounting);
    }
    catch (Exception ex)
    {
        throw objEx;
    }
}

之后我编译了这样的表达式：

Expression<Func<Accounting, bool>> ExpressionFunctions = GenerateExpression(lstAccountsBalance);

var compiledExpression = ExpressionFunctions.Compile();

我是这样使用的：

.Select(S => new
{
    Accounting = S.Accounts
        .Join(context.AccountInfo,
                objAccounts => objAccounts.ID,
                objAccountInfo => objAccountInfo.ID,
                (objAccounts, objAccountInfo) => new Accounting
                {
                    ID = objAccounts.ID,
                    Balance = objAccountInfo.Balance,                               
                })
        .Where(W => W.ID == user.ID)
        .AsQueryable()
        .Where(W => compiledExpression(W))
        .Select(S1 => new Accounting()
        {
            ID = S1.ID,
            Balance = S1.Balance
        })
        .ToList(),
}

它会抛出异常并显示消息：

System.NotSupportedException：LINQ 表达式节点类型“Invoke” 在 LINQ to Entities 中不受支持。

不编译

没有编译它就像魅力一样。它提供了我想要的输出。

 Expression<Func<Accounting, bool>> ExpressionFunctions = GenerateExpression(lstAccountsBalance);

用途：

.Select(S => new
{
    Accounting = S.Accounts
        .Join(context.AccountInfo,
                objAccounts => objAccounts.ID,
                objAccountInfo => objAccountInfo.ID,
                (objAccounts, objAccountInfo) => new Accounting
                {
                    ID = objAccounts.ID,
                    Balance = objAccountInfo.Balance,                               
                })
        .Where(W => W.ID == user.ID)
        .AsQueryable()
        .Where(ExpressionFunctions)
        .Select(S1 => new Accounting()
        {
            ID = S1.ID,
            Balance = S1.Balance
        })

谢谢你..

Answer 1

EF linq 查询中的所有内容都需要编译为表达式树，然后编译为 SQL，但字典是 IEnumerable，因此 EF 无法知道如何编译它。

您可以自己构建表达式树，也可以使用System.Linq.Dynamic nuget 包自己构建sql。

使用System.Linq.Dynamic的例子，首先安装nuget包并将using添加到你的文件顶部，然后会有一个Where重载，它接受一个字符串作为参数：

context.Account.Where(
    String.Join(" OR ", keyValues.Select(kvp => $"(ID = {kvp.Key} AND Balance = {kvp.Value})")));

基本上，Where 子句中的所有内容都将直接作为 SQL 执行，因此如果接受用户输入，请小心使用 Where(string, params object[]) 重载参数化您的查询。

表达式树（未经测试）方法可能如下所示：

var account = Expression.Parameter(typeof(Account));
var clauses = new List<Expression>();
foreach(var kvp in keyValues)
{
    clauses.Add(Expression.AndAlso(
        Expression.Equal(Expression.Constant(kvp.Key), Expression.Property(account, nameof(Account.AccountID))),
        Expression.Equal(Expression.Constant(kvp.Value), Expression.Property(account, nameof(Account.Balance)))
    ));
}

var expr = clauses.First();
foreach (var e in clauses.Skip(1))
    expr = Expression.OrElse(e, expr);

context.Account.Where(Expression.Lambda<Func<Account, bool>>(expr, account));

基本上在 foreach 循环中，我们创建了所有 (ID = ... AND Balance = ...)，最后我们用 OR 将它们全部连接起来。