Estoy en el proceso de crear un sistema de filtrado más elaborado para este gran proyecto nuestro. Uno de los principales predicados es poder pasar comparaciones a través de un parámetro de cadena. Esto se expresa en la siguiente forma: "> 50" o "5-10" o "<123.2"

Lo que tengo (como ejemplo para ilustrar)

ViewModel:

TotalCost (string) (value: "<50")
Required (string) (value: "5-10")

Modelo EF:

TotalCost (double)
Required(double)

Expresión que me gustaría usar:

model => model.Where(field => field.TotalCost.Compare(viewModel.TotalCost) && field.Required.Compare(viewModel.Required));

Expresión que me gustaría recibir:

model => model.Where(field => field.TotalCost < 50 && field.Required > 5 && field.Required < 10);

O algo parecido a eso

Sin embargo ... no tengo idea de por dónde empezar. Lo he reducido a

public static Expression Compare<T>(this Expression<Func<T, bool>> value, string compare)

Puede que ni siquiera sea correcto, pero esto es todo lo que tengo. El generador de comparación no es el problema, eso es lo fácil. La parte difícil es en realidad devolver la expresión. Nunca he intentado devolver expresiones como valores de función. Básicamente, lo que necesito mantener es el campo y devolver una expresión de comparación, más o menos.

¿Alguna ayuda? :X

Actualizar:

Ay, esto no resuelve mi problema. Puede ser porque he estado despierto durante las últimas 23 horas, pero no tengo la menor idea de cómo convertirlo en un método de extensión. Como dije, lo que me gustaría ... es básicamente una forma de escribir:

var ex = new ExTest();
var items = ex.Repo.Items.Where(x => x.Cost.Compare("<50"));

La forma en que configuré esa función (probablemente completamente incorrecta) es

public static Expression<Func<decimal, bool>> Compare(string arg)
{
    if (arg.Contains("<"))
        return d => d < int.Parse(arg);

    return d => d > int.Parse(arg);
}

Falta el valor de "este -algo-valor" con el que compararlo en primer lugar, y aún no he logrado averiguar cómo hacer que sea capaz de obtener una entrada de expresión ... como para ReSharper, me sugiere que convierta en lugar de boolean ...

Mi cabeza está llena de pelusa en este momento ...

Actualización 2:

Me las arreglé para encontrar una manera de tener un fragmento de código que funcione en un repositorio de memoria en una aplicación de consola. Todavía tengo que probarlo con Entity Framework.

public static bool Compare(this double val, string arg)
    {
        var arg2 = arg.Replace("<", "").Replace(">", "");
        if (arg.Contains("<"))
            return val < double.Parse(arg2);

        return val > double.Parse(arg2);
    }

Sin embargo, dudo mucho que sea lo que busco

Actualización 3:

Correcto, después de sentarme y mirar las expresiones lambda de nuevo, antes de la última respuesta, se me ocurrió algo parecido a lo siguiente, no cumple con los requisitos exactos de "Comparar ()", pero es una 'sobrecarga'. Donde metodo:

public static IQueryable<T> WhereExpression<T>(this IQueryable<T> queryable, Expression<Func<T, double>> predicate, string arg)
    {
        var lambda =
            Expression.Lambda<Func<T, bool>>(Expression.LessThan(predicate.Body, Expression.Constant(double.Parse(50.ToString()))));

        return queryable.Where(lambda);
    }

Sin embargo, a pesar de lo que veo, todo parece lógico, tengo la excepción de tiempo de ejecución de:

System.ArgumentException was unhandled
  Message=Incorrect number of parameters supplied for lambda declaration
  Source=System.Core
  StackTrace:
       at System.Linq.Expressions.Expression.ValidateLambdaArgs(Type delegateType, Expression& body, ReadOnlyCollection`1 parameters)
       at System.Linq.Expressions.Expression.Lambda[TDelegate](Expression body, String name, Boolean tailCall, IEnumerable`1 parameters)
       at System.Linq.Expressions.Expression.Lambda[TDelegate](Expression body, Boolean tailCall, IEnumerable`1 parameters)
       at System.Linq.Expressions.Expression.Lambda[TDelegate](Expression body, ParameterExpression[] parameters)

Siendo esta la línea culpable obviamente:

var lambda =
                Expression.Lambda<Func<T, bool>>(Expression.LessThan(predicate.Body, Expression.Constant(double.Parse(50.ToString()))));

Estoy muy cerca de la solución. Si puedo quitarme ese error, creo que EF debería ser capaz de traducirlo a SQL. De lo contrario ... bueno, la última respuesta probablemente irá.