// @nuget: System.Linq.Dynamic.Core

​

using System;

using System.Collections;

using System.Collections.Generic;

using System.Collections.Concurrent;

using System.ComponentModel;

using System.Linq;

using System.Linq.Expressions;

using System.Text.RegularExpressions;

using System.Linq.Dynamic.Core;

using System.Linq.Dynamic.Core.Parser;

public class MyModel

{

    public string Name {get;set;}

    public string Desc {get;set;}

    public DateTime Time {get;set;}

}

public class Program

{

    private static List<MyModel> list = new List<MyModel>{

            new () {Name = "test", Time = DateTime.Now},

            new () {Name = "test2", Time = DateTime.Now.AddDays(-1)},

        };

    public static Dictionary<string, Expression> Filters = new();

    private static Type ItemType { get; set; } = typeof(MyModel);

    private static Type QueryableItemType { get; set; } = typeof(IQueryable<MyModel>);

    private static Expression QueryableItemTypeExpression = new List<MyModel>().AsQueryable().Expression;

    public static Dictionary<string, bool?> Sorts = new();

    public static Expression GetDynamicQuery()

    {

       Expression? filterExpression = null;

        Expression? sortExpression = null;

        Expression? combinedExpression = null;

        var itemX = Expression.Parameter(ItemType, "x");

        var queryableX = Expression.Parameter(QueryableItemType, "x");

        // Join the filters

        foreach (var (key, value) in Filters)

        {

            var property = ItemType.GetProperty(key);

            if (property == null) continue;

            var expression = value;

            if (expression == null) continue;

            filterExpression = filterExpression == null ? expression : Expression.AndAlso(filterExpression, expression);

        }

        // Build the Where clause for filters if any set

        if (filterExpression != null)

        {

            var filterLambda = Expression.Lambda<Func<MyModel, bool>>(filterExpression, itemX);

            filterExpression = Expression.Call(

                typeof(Queryable),

                nameof(Queryable.Where),

                new [] { ItemType },

                QueryableItemTypeExpression,

                filterLambda);

​

        }

        foreach (var (key, value) in Sorts)

        {

            var property = ItemType.GetProperty(key);

            if (property == null) continue;

            var isDescending = value ?? false;

            var selector = Expression.Lambda(Expression.PropertyOrField(itemX, key), itemX);

            // Check if we are combining filters and sorts

            if (filterExpression != null && combinedExpression == null)

            {

                combinedExpression = Expression.Call(typeof(Queryable), 

                    isDescending ?  nameof(Queryable.OrderByDescending) : nameof(Queryable.OrderBy),

                    new[] { ItemType, selector.ReturnType },

                    filterExpression,

                    Expression.Quote(selector));

            }

            else if (filterExpression != null && combinedExpression != null)

            {

                combinedExpression = Expression.Call(typeof(Queryable), 

                    isDescending ?  nameof(Queryable.ThenByDescending) : nameof(Queryable.ThenBy),

                    new[] { ItemType, selector.ReturnType },

                    combinedExpression,

                    Expression.Quote(selector));

            }

            // Only sorts

            else if (sortExpression == null)

            {

                sortExpression = Expression.Call(typeof(Queryable), 

                    isDescending ?  nameof(Queryable.OrderByDescending) : nameof(Queryable.OrderBy),

                    new[] { ItemType, selector.ReturnType },

                    queryableX,

                    Expression.Quote(selector));

            }

            else

            {

                sortExpression = Expression.Call(typeof(Queryable), 

                    isDescending ? nameof(Queryable.ThenByDescending) : nameof(Queryable.ThenBy),

                    new[] { ItemType, selector.ReturnType },

                    sortExpression,

                    Expression.Quote(selector));

            }

        }

        // Convert the expression

        if (combinedExpression != null)

        {

            return combinedExpression;

            // return Expression.Lambda(Expression.Call(

            //     typeof(Queryable),

            //     nameof(Queryable.Where),

            //     new[] { _itemType },

            //     sortExpression,

            //     Expression.Lambda(filterExpression, itemX), itemX)).ToString();

        }

        if (filterExpression != null)

        {

            return filterExpression;

            // return Expression.Call(

            //     typeof(Queryable),

            //     nameof(Queryable.Where),

            //     new[] { _itemType },

            //     queryableX,

            //     Expression.Lambda(filterExpression, itemX)).ToString();

        }

        return sortExpression;

    }

    public static void Main()

    {

        var list = new List<MyModel>{

            new () {Name = "test", Time = DateTime.Now},

            new () {Name = "test2", Time = DateTime.Now.AddDays(-1)},

        };

        var paramExpression = Expression.Parameter(ItemType, "x");

        var property = ItemType.GetProperty(nameof(MyModel.Name));

        var tc = TypeDescriptor.GetConverter(property.PropertyType);

        var parsedValue = tc.ConvertFromString("Weee");

        var expression = Expression.Equal(Expression.Property(paramExpression, property), Expression.Constant(parsedValue, property.PropertyType));

        Filters.Add(nameof(MyModel.Name), expression);

        parsedValue = tc.ConvertFromString("Woo");

        expression = Expression.NotEqual(Expression.Property(paramExpression, property), Expression.Constant(parsedValue, property.PropertyType));

        Filters.Add(nameof(MyModel.Desc), expression);

        Sorts.Add(nameof(MyModel.Name), true);

        Sorts.Add(nameof(MyModel.Desc), false);

        var equalLambda = Expression.Lambda<Func<MyModel, bool>>(expression, paramExpression);

        MethodCallExpression whereEqualCallExpression = Expression.Call(

            typeof(Queryable),

            "Where",

            new Type[] { typeof(MyModel) },

            QueryableItemTypeExpression,

            equalLambda);

        Console.WriteLine(whereEqualCallExpression.ToString());

        FiddleHelper.WriteTable(list.AsQueryable().Provider.CreateQuery(whereEqualCallExpression));

        var query = GetDynamicQuery();

        //Console.WriteLine(query.ToString());

        ParameterExpression x = Expression.Parameter(typeof(MyModel), "x");

        ParameterExpression y = Expression.Parameter(typeof(IQueryable<MyModel>), "x");

​

        var symbols = new[] { y };

        var config = new ParsingConfig{ResolveTypesBySimpleName = true, RenameParameterExpression = true};

        Expression body = new ExpressionParser(symbols, "it.Where(((Name == \"Weee\") AndAlso (Name != \"Woo\"))).OrderByDescending(Name).ThenBy(Desc)", null, null).Parse(null);

​

       // Console.WriteLine(body.ToString());

        Console.WriteLine(String.Compare("test", "test"));

        //FiddleHelper.WriteTable(list);

        var param = Expression.Parameter(typeof(MyModel), "x");

        var compare = Expression.LessThan(Expression.Call(

            typeof(string), 

            "Compare", 

            null, 

            Expression.PropertyOrField(param, nameof(MyModel.Name)), 

            Expression.Constant("test")), 

                                          Expression.Constant(0));

        var lambda = Expression.Lambda<Func<MyModel, bool>>(compare, param);

        MethodCallExpression whereCallExpression = Expression.Call(

            typeof(Queryable),

            "Where",

            new Type[] { typeof(MyModel) },

            QueryableItemTypeExpression,

            lambda);

        Console.WriteLine(whereCallExpression.ToString());

        FiddleHelper.WriteTable(list.AsQueryable().Provider.CreateQuery<MyModel>(whereCallExpression));

        var parameter = Expression.Parameter(ItemType, "x");

        var propertyAccess = Expression.MakeMemberAccess(parameter, property);

        var orderByExp = Expression.Lambda(propertyAccess, parameter);

        MethodCallExpression orderByCallExpression = Expression.Call(

                typeof(Queryable),

                "OrderByDescending",

                new Type[] { ItemType, orderByExp.ReturnType },

                whereCallExpression,

                Expression.Quote(orderByExp));  

        Console.WriteLine(orderByCallExpression.ToString());

        FiddleHelper.WriteTable(list.AsQueryable().Provider.CreateQuery<MyModel>(orderByCallExpression));

    }

​

}

​