Создание вложенных выражений с помощью linq и Entity Framework

Причина вашей проблемы

Вы должны знать между IEnumerable и IQueryable. В объекте IEnumerable есть все для перечисления всех элементов: вы можете запросить первый элемент последовательности, и как только вы получите элемент, вы можете запросить следующий элемент, пока не останется элементов.

IQueryable кажется похожим, однако IQueryable не содержит всего для перечисления последовательности. Он содержит Expression и Provider. Expression — это общая форма того, что должно быть запрошено. Provider знает, кто должен выполнить запрос (обычно это система управления базой данных), как общаться с этим исполнителем и какой язык использовать (обычно что-то вроде SQL).

Как только вы начинаете перечислять, либо явно, вызывая GetEnumerator и MoveNext, либо неявно, вызывая foreach, ToList, FirstOrDefault, Count и т. д., Expression отправляется в Provider, который преобразует его в SQL и вызывает СУБД. Возвращаемые данные представлены в виде объекта IEnumerable, который перечисляется с помощью GetEnumerator

Поскольку провайдер должен перевести Expression в SQL, Expression может вызывать только те функции, которые могут быть переведены в SQL. Увы, Provider не знает ни HasProductsWithState, ни ваших собственных определенных функций, и поэтому не может перевести их в SQL. На самом деле поставщик Entity Framework также не знает, как перевести несколько стандартных функций LINQ, и поэтому их нельзя использовать AsQueryable. См. Поддерживаемые и неподдерживаемые методы LINQ.

Поэтому вам придется придерживаться функций, которые возвращают IQueryable, где выражение содержит только поддерживаемые функции.

Описание класса

Увы, вы забыли дать нам свои классы сущностей, поэтому мне придется сделать некоторые предположения о них.

По-видимому, у вас есть DbContext как минимум с тремя наборами DbSet: MainGroups, SubGroups и Products.

Похоже, что между MaingGroups и SubGroups существует отношение один ко многим (или, возможно, многие ко многим): каждый MainGroup имеет ноль или более SubGroups.

Похоже, что между SubGroups и Products также существует отношение «один ко многим»: каждый SubGroup имеет ноль или более Products.

Увы, вы забыли упомянуть это отношение возврата: каждый Product принадлежит ровно одному SubGroup (один ко многим) или каждый Product принадлежит нулю или более SubGroups (многие ко многим`)?

Если вы следовали первым соглашениям кода фреймворка сущностей, у вас будут классы, подобные этому:

class MainGroup
{
    public int Id {get; set;}
    ...

    // every MainGroup has zero or more SubGroups (one-to-many or many-to-many)
    public virtual ICollection<SubGroup> SubGroups {get; set;}
}
class SubGroup
{
    public int Id {get; set;}
    ...

    // every SubGroup has zero or more Product(one-to-many or many-to-many)
    public virtual ICollection<Product> Products{get; set;}

    // alas I don't know the return relation
    // one-to-many: every SubGroup belongs to exactly one MainGroup using foreign key
    public int MainGroupId {get; set;}
    public virtual MainGroup MainGroup {get; set;}
    // or every SubGroup has zero or more MainGroups:
    public virtual ICollection<MainGroup> MainGroups {get; set;}
}

Нечто подобное для продукта:

class Product
{
    public int Id {get; set;}
    public bool? IsActive {get; set;} // might be a non-nullable property
    ...

    // alas I don't know the return relation
    // one-to-many: every Productbelongs to exactly one SubGroup using foreign key
    public int SubGroupId {get; set;}
    public virtual SubGroup SubGroup {get; set;}
    // or every Product has zero or more SubGroups:
    public virtual ICollection<SubGroup> SubGroups {get; set;}
}

И, конечно же, ваш DbContext:

class MyDbContext : DbContext
{
    public DbSet<MainGroup> MainGroups {get; set;}
    public DbSet<SubGroup> SubGroups {get; set;}
    public DbSet<Product> Products {get; set;}
}

Это все, что необходимо знать инфраструктуре сущностей для обнаружения ваших таблиц, столбцов в ваших таблицах и отношений между таблицами (один ко многим, многие ко многим, один к нулю или один). Только если вы хотите отклониться от стандартного именования, вам понадобятся атрибуты Fluent API.

In entity framework the columns of the tables are represented by non-virtual properties. The virtual properties represent the relations between the tables (one-to-many, many-to-many).

Обратите внимание, что хотя SubGroups из MainGroup объявлен как коллекция, если вы запросите SubGroups из MaingGroup with Id 10, вы все равно получите IQueryable.

Требования

Учитывая запрашиваемую последовательность Products и логическое значение, допускающее значение null State, HasProductsWithState(products, state) должна возвращать запрашиваемую последовательность Products, которая имеет значение IsActive, равное State

Учитывая запрашиваемую последовательность SubGroups и логическое значение State, допускающее значение NULL, HasProductsWithState(subGroups, state) должна возвращать запрашиваемую последовательность SubGroups, у которой есть хотя бы один Product, который "HasProductsWithState(Product, State)1

Учитывая запрашиваемую последовательность MainGroups и нулевое логическое значение State, HasProductsWithState(mainGroups, state) должна возвращать запрашиваемую последовательность MainGroups, которая содержит все MainGroups, у которых есть хотя бы один SubGroup, который HasProductsWithState(SubGroup, State)

Решение

Что ж, если вы напишите такие требования, методы расширения просты:

IQueryable<Product> WhereHasState(this IQueryable<Product> products, bool? state)
{
    return products.Where(product => product.IsActive == state);
}

Поскольку эта функция не проверяет, имеет ли продукт это состояние, а возвращает все продукты, которые имеют это состояние, я решил использовать другое имя.

bool HasAnyWithState(this IQueryable<Product> products, bool? state)
{
    return products.WhereHasState(state).Any();
}

Ваш код будет немного отличаться, если IsActive является свойством, не допускающим значение NULL.

Я сделаю что-то подобное с SubGroups:

IQueryable<SubGroup> WhereAnyProductHasState(this IQueryable<SubGroup> subGroups, bool? state)
{
    return subgroups.Where(subGroup => subGroup.Products.HasAnyWithState(state));
}

bool HasProductsWithState(this IQueryable<SubGroup> subGroups, bool? state)
{
     return subGroups.WhereAnyProductHasState(state).Any();
}

Что ж, теперь вы знаете упражнение для MainGroups:

IQueryable<MainGroup> WhereAnyProductHasState(this IQueryable<MainGroup> mainGroups, bool? state)
{
    return maingroups.Where(mainGroup => mainGroup.SubGroups.HasProductsWithState(state));
}

bool HasProductsWithState(this IQueryable<MainGroup> mainGroups, bool? state)
{
     return mainGroups.WhereAnyProductHasState(state).Any();
}

Если вы внимательно посмотрите, то увидите, что я не использовал никаких самоопределяемых функций. Мои вызовы функций изменят только Expression. Измененный Expression можно перевести в SQL.

Я разделил функцию на множество более мелких функций, потому что вы не сказали, хотите ли вы использовать HasProductsWithState(this IQueryable<SubGroup>, bool?) и HasProductsWithState(this IQueryable<Product>, bool?).

TODO: сделать что-то подобное для аналогичного для HasChildrenWithName: разделить на более мелкие функции, которые содержат только функции LINQ и ничего больше

Если вы будете вызывать только HasProductsWithState(this IQueryable<MainGroup>, bool?), вы можете сделать это в одной функции, используя `SelectMany:

IQueryable<MainGroup> HasProductsWithState(this IQueryable<MainGroup> mainGroups, bool? state)
{
    return mainGroups
        .Where(mainGroup => mainGroup.SelectMany(mainGroup.SubGroups)
                                     .SelectMany(subGroup => subGroup.Products)
                                     .Where(product => product.IsActive == state)
                                     .Any() );
}

But when I walk through my code at runtime it does not enter the function again when

   return maingroups.Where(x => x.Subgroups.AsQueryable().HasProductsWithState(state)

Добро пожаловать в мир деревьев выражений!

x => x.Subgroups.AsQueryable().HasProductsWithState(state)

это лямбда-выражение (Expression<Func<...>) с телом

x.Subgroups.AsQueryable().HasProductsWithState(state)

Тело — это дерево выражений, другими словами — код как данные, следовательно, выполняется никогда (за исключением случая, когда он скомпилирован для делегирования, как в LINQ to Objects).

Это легко упустить из виду, поскольку визуально лямбда-выражения выглядят как делегаты. Даже Харальд в своем ответе после всех объяснений, что не следует использовать пользовательские методы, поскольку решение фактически предоставляет несколько методов обычай с обоснованием «Я не использовал какую-либо самоопределяемую функцию. Мои вызовы функций изменяют только выражение. Измененное выражение можно преобразовать в SQL». Конечно, но если ваши функции называется! Чего, конечно же, не происходит, когда они находятся внутри дерева выражений.

С учетом сказанного, хорошего общего решения не существует. Что я могу предложить, так это решение вашей конкретной проблемы - преобразование пользовательских методов, которые получают IQueryable<T> плюс другие параметры просто и возвращают IQueryable<T>.

Идея состоит в том, чтобы использовать пользовательский ExpressionVisitor, который идентифицирует «вызовы» такого метода внутри дерева выражений, фактически вызывает их и заменяет результатом вызова.

Проблема в том, чтобы вызвать

x.Subgroups.AsQueryable().HasProductsWithState(state)

когда у нас нет реального x объекта. Хитрость заключается в том, чтобы вызвать их с поддельным запрашиваемым выражением (например, LINQ to Objects Enumerable<T>.Empty().AsQueryble()), а затем использовать другой посетитель выражения, чтобы заменить поддельное выражение исходным выражением в результате (почти как string.Replace, но для выражений).

Вот пример реализации вышеизложенного:

public static class QueryTransformExtensions
{ 
    public static IQueryable<T> TransformFilters<T>(this IQueryable<T> source)
    {
        var expression = new TranformVisitor().Visit(source.Expression);
        if (expression == source.Expression) return source;
        return source.Provider.CreateQuery<T>(expression);
    }

    class TranformVisitor : ExpressionVisitor
    {
        protected override Expression VisitMethodCall(MethodCallExpression node)
        {
            if (node.Method.IsStatic && node.Method.Name.StartsWith("Has")
                && node.Type.IsGenericType && node.Type.GetGenericTypeDefinition() == typeof(IQueryable<>)
                && node.Arguments.Count > 0 && node.Arguments.First().Type == node.Type)
            {
                var source = Visit(node.Arguments.First());
                var elementType = source.Type.GetGenericArguments()[0];
                var fakeQuery = EmptyQuery(elementType);
                var args = node.Arguments
                    .Select((arg, i) => i == 0 ? fakeQuery : Evaluate(Visit(arg)))
                    .ToArray();
                var result = (IQueryable)node.Method.Invoke(null, args);
                var transformed = result.Expression.Replace(fakeQuery.Expression, source);
                return Visit(transformed); // Apply recursively
            }
            return base.VisitMethodCall(node);
        }

        static IQueryable EmptyQuery(Type elementType) =>
            Array.CreateInstance(elementType, 0).AsQueryable();

        static object Evaluate(Expression source)
        {
            if (source is ConstantExpression constant)
                return constant.Value;
            if (source is MemberExpression member)
            {
                var instance = member.Expression != null ? Evaluate(member.Expression) : null;
                if (member.Member is FieldInfo field)
                    return field.GetValue(instance);
                if (member.Member is PropertyInfo property)
                    return property.GetValue(instance);
            }
            throw new NotSupportedException();
        }
    }

    static Expression Replace(this Expression source, Expression from, Expression to) =>
        new ReplaceVisitor { From = from, To = to }.Visit(source);

    class ReplaceVisitor : ExpressionVisitor
    {
        public Expression From;
        public Expression To;
        public override Expression Visit(Expression node) =>
            node == From ? To : base.Visit(node);
    }
}

Теперь все, что вам нужно, это вызывать .TransformFilters() методы расширения в конце ваших запросов, например, в вашем образце.

var result = query.AsQueryable()
    // ...
    .TransformFilters();

Вы также можете вызывать его в промежуточных запросах. Просто убедитесь, что вызов находится вне дерева выражений :)

Обратите внимание, что пример реализации обрабатывает static методы, имеющие первый параметр IQueryable<T>, возвращая IQueryable<T> и имя, начинающееся с Has. Последнее — пропустить Queryable и методы расширения EF. В реальном коде вы должны использовать некоторые лучшие критерии — например, тип определяющего класса или пользовательский атрибут и т. д.