Решить «InvalidOperationException: не удалось перевести выражение LINQ [...]» и сохранить ToListAsyn c ()

Question

В EF Core 3.x запросы LINQ, которые не могут быть переведены, больше не оцениваются на клиенте. Из того, что я понимаю, это означает, что он не может обрабатывать код, который не может быть непосредственно переведен в SQL.

---

В моем случае я хочу использовать foreach (PropertyInfo в type.GetProperties ()) оценивать каждый компонент класса.

private static bool stringInMovement(Movement m, string toTest)
{
    foreach(PropertyInfo component in typeof(Movement).GetProperties())
    {
        try {
            if (component.GetValue(m).ToString().ToLower().Contains(toTest.ToLower()))
                return true;
        }
        catch { }

    }
    return false;
}

И затем использовать это в выражении where:

movements = movements.Where(m=> stringInMovement(m, SearchString));

Я хочу сохранить результат IQueryable, потому что после функции, в которой он находится, находится asyn c Task и последняя строка

Movements = await movements.AsNoTracking().ToListAsync();

Я хотел бы сохранить все функции асинхронными, и я не хочу писать оператор where с 10x m.Component.Contains (SearchString). Между прочим, это поиск указанного c элемента базы данных.

Спасибо за вашу помощь!

Ошибка, возникающая при попытке что-то найти:

    Microsoft.EntityFrameworkCore.Query.QueryableMethodTranslatingExpressionVisitor.<VisitMethodCall>g__CheckTranslated|8_0(ShapedQueryExpression translated, ref <>c__DisplayClass8_0 )
    Microsoft.EntityFrameworkCore.Query.QueryableMethodTranslatingExpressionVisitor.VisitMethodCall(MethodCallExpression methodCallExpression)
    Microsoft.EntityFrameworkCore.Query.RelationalQueryableMethodTranslatingExpressionVisitor.VisitMethodCall(MethodCallExpression methodCallExpression)
    System.Linq.Expressions.MethodCallExpression.Accept(ExpressionVisitor visitor)
    System.Linq.Expressions.ExpressionVisitor.Visit(Expression node)
    Microsoft.EntityFrameworkCore.Query.QueryCompilationContext.CreateQueryExecutor<TResult>(Expression query)
    Microsoft.EntityFrameworkCore.Storage.Database.CompileQuery<TResult>(Expression query, bool async)
    Microsoft.EntityFrameworkCore.Query.Internal.QueryCompiler.CompileQueryCore<TResult>(IDatabase database, Expression query, IModel model, bool async)
    Microsoft.EntityFrameworkCore.Query.Internal.QueryCompiler+<>c__DisplayClass12_0<TResult>.<ExecuteAsync>b__0()
    Microsoft.EntityFrameworkCore.Query.Internal.CompiledQueryCache.GetOrAddQueryCore<TFunc>(object cacheKey, Func<Func<QueryContext, TFunc>> compiler)
    Microsoft.EntityFrameworkCore.Query.Internal.CompiledQueryCache.GetOrAddQuery<TResult>(object cacheKey, Func<Func<QueryContext, TResult>> compiler)
    Microsoft.EntityFrameworkCore.Query.Internal.QueryCompiler.ExecuteAsync<TResult>(Expression query, CancellationToken cancellationToken)
    Microsoft.EntityFrameworkCore.Query.Internal.EntityQueryProvider.ExecuteAsync<TResult>(Expression expression, CancellationToken cancellationToken)
    Microsoft.EntityFrameworkCore.Query.Internal.EntityQueryable<TResult>.GetAsyncEnumerator(CancellationToken cancellationToken)
    System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable<T>.GetAsyncEnumerator()
    Microsoft.EntityFrameworkCore.EntityFrameworkQueryableExtensions.ToListAsync<TSource>(IQueryable<TSource> source, CancellationToken cancellationToken)
    Intuo.IndexModel.OnGetAsync() in Index.cshtml.cs
    +
                Movements = await movements.AsNoTracking().ToListAsync();
    Microsoft.AspNetCore.Mvc.RazorPages.Infrastructure.ExecutorFactory+NonGenericTaskHandlerMethod.Execute(object receiver, object[] arguments)
    Microsoft.AspNetCore.Mvc.RazorPages.Infrastructure.PageActionInvoker.InvokeHandlerMethodAsync()
    Microsoft.AspNetCore.Mvc.RazorPages.Infrastructure.PageActionInvoker.InvokeNextPageFilterAsync()
    Microsoft.AspNetCore.Mvc.RazorPages.Infrastructure.PageActionInvoker.Rethrow(PageHandlerExecutedContext context)
    Microsoft.AspNetCore.Mvc.RazorPages.Infrastructure.PageActionInvoker.Next(ref State next, ref Scope scope, ref object state, ref bool isCompleted)
    Microsoft.AspNetCore.Mvc.RazorPages.Infrastructure.PageActionInvoker.InvokeInnerFilterAsync()
    Microsoft.AspNetCore.Mvc.Infrastructure.ResourceInvoker.<InvokeNextResourceFilter>g__Awaited|24_0(ResourceInvoker invoker, Task lastTask, State next, Scope scope, object state, bool isCompleted)
    Microsoft.AspNetCore.Mvc.Infrastructure.ResourceInvoker.Rethrow(ResourceExecutedContextSealed context)
    Microsoft.AspNetCore.Mvc.Infrastructure.ResourceInvoker.Next(ref State next, ref Scope scope, ref object state, ref bool isCompleted)
    Microsoft.AspNetCore.Mvc.Infrastructure.ResourceInvoker.InvokeFilterPipelineAsync()
    Microsoft.AspNetCore.Mvc.Infrastructure.ResourceInvoker.<InvokeAsync>g__Awaited|17_0(ResourceInvoker invoker, Task task, IDisposable scope)
    Microsoft.AspNetCore.Routing.EndpointMiddleware.<Invoke>g__AwaitRequestTask|6_0(Endpoint endpoint, Task requestTask, ILogger logger)
    Microsoft.AspNetCore.Authorization.AuthorizationMiddleware.Invoke(HttpContext context)
    Microsoft.AspNetCore.Diagnostics.DeveloperExceptionPageMiddleware.Invoke(HttpContext context)

Answer 1

Вам нужно динамически сгенерировать Expression<Lambda> для использования в предложении where.

        public static Expression<Func<T,bool>> ContainsString<T>(string value)
        {
            var constValue = Expression.Constant(value);
            var parameter = Expression.Parameter(typeof(T), "p");

            return Expression.Lambda<Func<T, bool>>(
                typeof(T).GetProperties()
                    .Where(p => p.PropertyType == typeof(string))
                    .Select(p => (Expression)Expression.Call(
                        Expression.Property(parameter, p), 
                        "Contains", 
                        new Type[] { typeof(string) },
                        constValue))
                    .Aggregate((a, c) => Expression.OrElse(a, c)),
                parameter);
        }

        movements = movements.Where(ContainsString<Movement>(SearchString));

Answer 2

EF / EF Core не может перевести все, что связано с отражением, или более сложные логики c в SQL. Вместо этого есть несколько способов достичь того, что требуется - записать все реквизиты в запросе:

movements = movements
    .Where(m => m.Property1.ToString().ToLower().Contains(SearchString.ToString().ToLower() &&
                m.Property2.ToString().ToLower().Contains(SearchString.ToString().ToLower() /* ... */ );

или указать спецификацию c Expression, которая будет передана в качестве аргумента в .Where через пользовательский Expression Visitor или с помощью метода:

public static Expression<Func<Movement, bool>> CompareToStr(string searchString) 
{
    Expression res = null;
    var param = Expression.Parameter(typeof(Movement), "x");
    foreach (var component in typeof(Movement).GetProperties())
    {
        // building the expression to get a property
        var arg = Expression.Property(param, component.Name);
        // now we have `x.Property1` expression

        var toStrCall = Expression.Call(
                // to what expression we applying the .ToString method
                arg,
                // link to 'ToString', 
                // needed to be altered, if it would be used in non-sql runtime as if there are nullable types with `null` values, this would cause NRE at runtime
                component.PropertyType.GetMethod(nameof(object.ToString), new Type[] { }));
        // now we have `x.Property1.ToString()` (watch out NRE)

        var toLowerCall = Expression.Call(
            toStrCall, 
            typeof(string).GetMethod(nameof(string.ToLower), new Type[] { }));

        // now we have `x.Property1.ToString().ToLower()`
        var containsCall = Expression.Call(
                toLowerCall,
                typeof(string).GetMethod(nameof(string.Contains), new[] { typeof(string) }),
                Expression.Constant(searchString.ToLower())); // since arguments of expression tree should be the expressions
        // here we passed the constant string expression, so now we have
        // x.Property1.ToString().ToLower().Contains( value of testString.ToLower())

        if (res == null)
        {
            res = containsCall;
        }
        else
        {
            res = Expression.Or(res, containsCall);
        }

        // after several iterations it has
        // x.Property1...Contains(testString) || x.Property2...Contains(testString) and so on
    }

    return Expression.Lambda<Func<Movement, bool>>(res, param);
    // and result x => x.Property1... || x.Property2 ...
}

(я не проверял этот код). Поэтому цель состоит в том, чтобы создать экземпляр Expression Tree и передать его в качестве аргумента для вызова .Where. Таким образом, EF / EF Core сможет перевести его в SQL, поскольку он знает, как переводить .ToString() звонки и .ToLower() звонки:

movements = movements.Where(CompareToStr(SearchString));