Início / coding / Perguntas / 77993370
Accepted
Adem Aygun
Asked: 2024-02-14 17:50:53 +0800 CST

EF Core 6: .Any() no filtro de consulta produz "não pôde ser traduzido. Reescreva a consulta em um formato que possa ser traduzido"

  • 772

Eu tenho a entidade Product e escrevo um método em uma classe de repositório (usando npgsql). Mas recebo um erro:

não pôde ser traduzido. Reescreva a consulta em um formato que possa ser traduzido ou alterne explicitamente para a avaliação do cliente inserindo uma chamada para 'AsEnumerable', 'AsAsyncEnumerable', 'ToList' ou 'ToListAsync'. Consulte https://go.microsoft.com/fwlink/?linkid=2101038 para obter mais informações. System.InvalidOperationException: A expressão LINQ 's => s.ProductId == EntityShaperExpression:

public class Product:IEntity
{
  public string Id { get; set; }
  public string SerialNo { get; set; }
  public string Imei { get; set; }
  public string Name { get; set; }
}   

public class ProductInput
{
  public string ProductId { get; set; }
  public string SerialNo { get; set; }
  public string Imei { get; set; }
}

public async Task<List<Product>> GetProducts(List<ProductInput> input) //EfCoreProductRepository.cs
{
      var result = (from product in (await GetDbContextAsync()).Products
                    where input.Any(s => s.ProductId == product.Id && s.SerialNo == product.SerialNo && s.Imei == product.Imei)
                    select product).ToList();
    return result;
}

Como devo editar minha consulta para evitar esse erro?

.net-core

1 respostas

  1. Best Answer

    Parece que você está tentando recuperar linhas do banco de dados que correspondem às suas inputlinhas por vários critérios. Existem várias maneiras de fazer isso, como:

    • Colocar os inputdados em um parâmetro com valor de tabela (SQL Server) ou array digitado (Postgres), ou até mesmo em um blob de string JSON ( horrível ) e fazer um INNER JOINcom esse parâmetro.
      • Posso estar errado, mas não acredito que o Entity Framework Core suporte isso, exceto para filtragem de coluna única.
    • Alternativamente (e de forma mais confiável), você pode criar dinamicamente uma nova consulta Linq que defina as correspondências desejadas na WHEREpeça.
      • A única desvantagem real disso é que as consultas dinâmicas não podem aproveitar as vantagens dos planos de consulta em cache ou de coisas como o Query Store.
    • A abordagem à prova de falhas seria fazer uma consulta RBAR fazendo um loop inputem C# e executando consultas individuais
      • Ai credo . Não.

    Na opinião deste autor, a Opção 2 (Consulta Linq construída dinamicamente) é a "melhor" geral aqui, então faça assim:

    Primeiro, entendaPredicateBuilder - é uma dependência pequena que torna significativamente mais fácil construir Orpredicados com o Linq. É literalmente classcopiar e colar do site de Albahari.

    Em segundo lugar, use-o assim:

    public async Task<List<Product>> GetProductsAsync( List<ProductInput> input, CancellationToken cancellationToken )
{
    DbSet<Product> dbSet = await this.GetDbSetAsync();

    var predicate = PredicateBuilder.False<Product>();
    foreach( ProductInput pi in input )
    {
        predicate = predicate.Or( p => (
            p.ProductId == pi.Id
            &&
            p.SerialNo == pi.SerialNo
            &&
            p.Imei == pi.Imei
        ) );
    }

    IQueryable<Product> query = dbSet.Where( predicate );

    List<Product> results = await query.ToListAsync(cancellationToken);
    return results;
}

    PredicadoBuilder

    Para a posteridade, reproduzi class PredicateBuilderaqui:

    using System;
using System.Linq;
using System.Linq.Expressions;
using System.Collections.Generic;
 
public static class PredicateBuilder
{
  public static Expression<Func<T,Boolean>> True<T> ()  => ( f => true );
  public static Expression<Func<T,Boolean>> False<T> () => ( f => false );
 
  public static Expression<Func<T,Boolean>> Or<T>(this Expression<Func<T,Boolean>> expr1, Expression<Func<T,Boolean>> expr2)
  {
    var invokedExpr = Expression.Invoke(
      expr2,
      expr1.Parameters.Cast<Expression>()
    );

    return Expression.Lambda<Func<T,Boolean>>(
      Expression.OrElse(expr1.Body, invokedExpr),
      expr1.Parameters
    );
  }
 
  public static Expression<Func<T,Boolean>> And<T>(this Expression<Func<T,Boolean>> expr1, Expression<Func<T,Boolean>> expr2)
  {
    var invokedExpr = Expression.Invoke(
      expr2,
      expr1.Parameters.Cast<Expression>()
    );
    
    return Expression.Lambda<Func<T,Boolean>>(
      Expression.AndAlso(expr1.Body, invokedExpr),
      expr1.Parameters
    );
  }
}
    • 1

relate perguntas