using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Data;

using System.ComponentModel.DataAnnotations;

using System.Globalization;

using System.Reflection;

using System.Collections.ObjectModel;

using System.Threading;

using System.Threading.Tasks;

using System.Linq.Expressions;

using System.Text.Json;

​

using Microsoft.EntityFrameworkCore;

using Microsoft.EntityFrameworkCore.Query;

​

public static partial class EntityFrameworkQueryableExtensions

{

    public static IIncludableQueryable<TEntity, IEnumerable<TItem>> Include<TEntity, TItem> (

        this IQueryable<TEntity> source, 

        Expression<Func<TEntity, IEnumerable<TItem>>> navigationPropertyPath,

        Expression<Func<TItem, bool>> filter) where TEntity : class => 

        source.Include(navigationPropertyPath.Where(filter));

    public static IQueryable<TEntity> Where<TEntity, TItem> (

        this IQueryable<TEntity> source, 

        Expression<Func<TEntity, IEnumerable<TItem>>> navigationPropertyPath,

        Expression<Func<IEnumerable<TItem>, bool>> filter) where TEntity : class => 

        source.Where(filter.Compose(navigationPropertyPath));

}

​

public static partial class ExpressionExtensions

{

    public static Expression<Func<T, IEnumerable<TItem>>> Where<T, TItem>(

        this Expression<Func<T, IEnumerable<TItem>>> outer, Expression<Func<TItem, bool>> predicate) =>

        ((Expression<Func<IEnumerable<TItem>, Func<TItem, bool>, IEnumerable<TItem>>>) ((q, f) => q.Where(i => f(i))))

            .Inject(predicate)

            .Compose(outer);

​

    // Compose two Func<Tx, Ty> expressions with compatible generic parameters into a third.

    public static Expression<Func<T1, TResult>> Compose<T1, T2, TResult>(this Expression<Func<T2, TResult>> outer, Expression<Func<T1, T2>> inner) =>

        Expression.Lambda<Func<T1, TResult>>(

            new ParameterReplacer((outer.Parameters[0], inner.Body)).Visit(outer.Body), 

            false, inner.Parameters[0]);    

    public static Expression<Func<T1, TResult>> InjectInto<T1, T2, T3, TResult>(this Expression<Func<T2, T3>> inner, Expression<Func<T1, Func<T2, T3>, TResult>> outer) =>

        outer.Inject(inner);

​

    // Uncurry and compose an Expression<Func<T1, Func<T2, T3>, TResult>> into an Expression<Func<T1, TResult>> by composing with an Expression<Func<T2, T3>>

    public static Expression<Func<T1, TResult>> Inject<T1, T2, T3, TResult>(this Expression<Func<T1, Func<T2, T3>, TResult>> outer, Expression<Func<T2, T3>> inner) =>

        Expression.Lambda<Func<T1, TResult>>(

            new InvokeReplacer((outer.Parameters[1], inner)).Visit(outer.Body), 

            false, outer.Parameters[0]);

}

​

class InvokeReplacer : ExpressionVisitor

{

    // Replace an Invoke() with the body of a lambda, replacing the formal paramaters of the lambda with the arguments of the invoke.

    // TODO: Handle replacing of functions that are not invoked but just passed as parameters to some external method, e.g.

    //   collection.Select(map) instead of collection.Select(i => map(i))

    readonly Dictionary<Expression, LambdaExpression> funcsToReplace;

    public InvokeReplacer(params (Expression func, LambdaExpression replacement) [] funcsToReplace) =>

        this.funcsToReplace = funcsToReplace.ToDictionary(p => p.func, p => p.replacement);

    protected override Expression VisitInvocation(InvocationExpression invoke) => 

        funcsToReplace.TryGetValue(invoke.Expression, out var lambda)

        ? (invoke.Arguments.Count != lambda.Parameters.Count

            ? throw new InvalidOperationException("Wrong number of arguments")

            : new ParameterReplacer(lambda.Parameters.Zip(invoke.Arguments)).Visit(lambda.Body))

        : base.VisitInvocation(invoke);

}   

​

class ParameterReplacer : ExpressionVisitor

{

    // Replace formal parameters (e.g. of a lambda body) with some containing expression in scope.

    readonly Dictionary<ParameterExpression, Expression> parametersToReplace;

    public ParameterReplacer(params (ParameterExpression parameter, Expression replacement) [] parametersToReplace) 

        : this(parametersToReplace.AsEnumerable()) { }

    public ParameterReplacer(IEnumerable<(ParameterExpression parameter, Expression replacement)> parametersToReplace) =>

        this.parametersToReplace = parametersToReplace.ToDictionary(p => p.parameter, p => p.replacement);

    protected override Expression VisitParameter(ParameterExpression p) => 

        parametersToReplace.TryGetValue(p, out var e) ? e : base.VisitParameter(p);

}

​

public class Program

{

    private static void Main(string[] args)

    {

        using var ctx = MyContext.MakeInMemoryContext();

​

        var blogs = GetBlogsInlined(ctx, DateTime.Today).ToList();

        Console.WriteLine("GetBlogsInlined(ctx, DateTime.Today).ToList();   = {0}\n", JsonSerializer.Serialize(blogs));

        var blogs2 = GetBlogsExpression(ctx, DateTime.Today).ToList();

        Console.WriteLine("GetBlogsExpression(ctx, DateTime.Today).ToList() = {0}", JsonSerializer.Serialize(blogs2));

        try

        {

            var blogs3 = GetBlogsFunction(ctx, DateTime.Today).ToList();

            Console.WriteLine("GetBlogsFunction(ctx, DateTime.Today).ToList()   = {0}\n", JsonSerializer.Serialize(blogs3));

        }

        catch (Exception ex)

        {

            Console.WriteLine("\nWhen calling {0}, caught expected exception {1}", nameof(GetBlogsFunction), ex.Message);

        }

    }

​

    public static IQueryable<BlogEntryDTO> GetBlogsInlined(MyContext ctx, DateTime dateTime)

    {

        return ctx

            .Blogs.Include(blog => blog.Comments.Where(comment => comment.Created < dateTime))

            .Where(blog => blog.Comments.Any(comment => comment.Created < dateTime))

            .Select(b => new BlogEntryDTO(b));

    }

​

    // Compile time error:

    // Cannot resolve method 'Where(Expression<Func<Comment,bool>>)', candidates are:

    // IEnumerable<Comment> Where<Comment>(this IEnumerable<Comment>, Func<Comment,bool>) (in class Enumerable)

    // IEnumerable<Comment> Where<Comment>(this IEnumerable<Comment>, Func<Comment,int,bool>) (in class Enumerable)

    public static IQueryable<BlogEntryDTO> GetBlogsExpression(MyContext ctx, DateTime dateTime)

    {

        Expression<Func<Comment, bool>> commentFilter = comment => comment.Created < dateTime;

​

        return ctx

            .Blogs

            //.Include(inTime.InjectInto((b, f) => b.Comments.Where(c => f(c))))

            //.Include(inTime.InjectInto((BlogEntry b, Func<Comment, bool> f) => b.Comments.Where(c => f(c))))

            .Include(b => b.Comments, commentFilter)

            .Where(commentFilter.InjectInto((BlogEntry b, Func<Comment, bool> f) => b.Comments.Any(c => f(c))))

            .Select(b => new BlogEntryDTO(b));

    }

​

    // Runtime error:

    // Unhandled exception.

    // ArgumentException: Expression of type 'Func`[Comment,Boolean]' cannot be used for parameter of type 'Expression`[Func`[Comment,Boolean]]' of method 'IQueryable`[Comment] Where[Comment](IQueryable`1[Comment], Expression`1[Func`2[Comment,Boolean]])' (Parameter 'arg1')

    // at Dynamic.Utils.ExpressionUtils.ValidateOneArgument(MethodBase method, ExpressionType nodeKind, Expression arguments, ParameterInfo pi, String methodParamName, String argumentParamName, Int32 index)

​

    public static IQueryable<BlogEntryDTO> GetBlogsFunction(MyContext ctx, DateTime dateTime)

    {

        Func<Comment, bool> inTime = comment => comment.Created < dateTime;

​

        return ctx

            .Blogs.Include(blog => blog.Comments.Where(inTime))

            .Where(blog => blog.Comments.Any(inTime))

            .Select(b => new BlogEntryDTO(b));

    }

​

    public class MyContext(DbContextOptions<MyContext> options) : DbContext(options)

    {

        public DbSet<BlogEntry> Blogs { get; set; }

        public DbSet<Comment> Comments { get; set; }

​

        public static MyContext MakeInMemoryContext()

        {

            var builder = new DbContextOptionsBuilder<MyContext>().UseInMemoryDatabase("context");

            var ctx = new MyContext(builder.Options);

            ctx.Database.EnsureDeleted();

            ctx.Database.EnsureCreated();

            ctx.SetupBlogs();

            return ctx;

        }

​

        private void SetupBlogs()

        {

            Blogs.AddRange(

                [

                    new BlogEntry

                    {

                        Name = "1",

                        Created = DateTime.Now.AddDays(-3),

                        Comments =

                        [

                            new Comment { Content = "c1", Created = DateTime.Now.AddDays(-2) },

                            new Comment { Content = "c2", Created = DateTime.Now.AddDays(-1) }

                        ]

                    },

                    new BlogEntry

                    {

                        Name = "2",

                        Created = DateTime.Now.AddDays(-2),

                        Comments = [new Comment { Content = "c3", Created = DateTime.Now.AddDays(-1) }]

                    },

                    new BlogEntry { Name = "2", Created = DateTime.Now.AddDays(-1), Comments = [] }

                ]

            );

            SaveChanges();

        }

    }

​

    public class BlogEntry

    {

        [Key]

        public int Id { get; set; }

        public string Name { get; set; }

        public DateTime Created { get; set; }

        public virtual ICollection<Comment> Comments { get; set; }

    }

​

    public class Comment

    {

        [Key]

        public int Id { get; set; }

        public string Content { get; set; }

        public DateTime Created { get; set; }

        public int BlogEntryId { get; set; }

        public virtual BlogEntry BlogEntry { get; set; }

    }

​

    public class BlogEntryDTO(BlogEntry blogEntry)

    {

        public int Id { get; set; } = blogEntry.Id;

        public string Name { get; set; } = blogEntry.Name;

        public string[] Comments { get; set; } = blogEntry.Comments.Select(c => c.Content).ToArray();

    }

}