c# - inside - iqueryable vs ienumerable

extender Donde para IQueryable

Question

Necesito extender el método Where para IQueryable a algo como esto:

.WhereEx("SomeProperty", "==", "value")

No sé si esto es posible, pero encontré esto en SO: no se puede ordenar con el nombre de la propiedad en LINQ OrderBy

Intenté esta respuesta y parece bastante interesante (respuesta de Ziad):

using System.Linq;
using System.Linq.Expressions;
using System;

namespace SomeNameSpace
{
    public static class SomeExtensionClass
    {
        public static IQueryable<T> OrderByField<T>(this IQueryable<T> q, string SortField, bool Ascending)
        {
            var param = Expression.Parameter(typeof(T), "p");
            var prop = Expression.Property(param, SortField);
            var exp = Expression.Lambda(prop, param);
            string method = Ascending ? "OrderBy" : "OrderByDescending";
            Type[] types = new Type[] { q.ElementType, exp.Body.Type };
            var mce = Expression.Call(typeof(Queryable), method, types, q.Expression, exp);
            return q.Provider.CreateQuery<T>(mce);
        }
    }
}

¿Es posible hacer lo mismo con el método Where ?

Gracias.

Actualización :

Ahora puedo establecer una expresión para pasar al método Call , pero obtengo la siguiente excepción: "Ningún método genérico ''Where'' en el tipo ''System.Linq.Queryable'' es compatible con los argumentos y argumentos de tipo suministrados. se proporcionará si el método no es genérico ".

aquí está mi código:

public static IQueryable<T> WhereEx<T>(this IQueryable<T> q, string Field, string Operator, string Value)
    {
        var param = Expression.Parameter(typeof(T), "p");
        var prop = Expression.Property(param, Field);

        var val = Expression.Constant(Value);
        var body = Expression.Equal(prop, val);

        var exp = Expression.Lambda<Func<T, bool>>(body, param);

        Type[] types = new Type[] { q.ElementType, typeof(bool) };

        var mce = Expression.Call(
                typeof(Queryable),
                "Where",
                types,
                exp
            );
        return q.Provider.CreateQuery<T>(mce);
    }

Tenga en cuenta que aún no utilizo el argumento Operator , en su lugar utilizo Equal para fines de depuración.

Alguien me puede ayudar con esto por favor ?

Answer 1

Hice otra publicación con una pregunta simplificada. el enlace está aquí

    public static IQueryable<T> WhereEx<T>(this IQueryable<T> q, string Field, string Operator, string Value)
    {
        var param = Expression.Parameter(typeof(T), "p");
        var prop = Expression.Property(param, Field);

        var val = Expression.Constant(Value);
        var body = Expression.Equal(prop, val);

        var exp = Expression.Lambda<Func<T, bool>>(body, param);

        return System.Linq.Queryable.Where(q, exp);
    }