Erweiterungsmethode, die den Lambda-Ausdruck durch Vergleich zurückgibt

Ich bin gerade dabei, ein ausgefeilteres Filtersystem für dieses riesige Projekt von uns zu entwickeln. Eines der wichtigsten Prädikate ist die Möglichkeit, Vergleiche über einen Zeichenfolgenparameter zu übergeben. Dies drückt sich in der folgenden Form aus: "> 50" oder "5-10" oder "<123,2"

Was ich habe (als Beispiel zur Veranschaulichung)

ViewModel:

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

EF-Modell:

TotalCost (double)
Required(double)

Ausdruck, den ich verwenden möchte:

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

Ausdruck, den ich erhalten möchte:

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

Oder so ähnlich

Allerdings ... ich habe keine Ahnung, wo ich anfangen soll. Ich habe es auf eingegrenzt

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

Es mag nicht einmal richtig sein, aber das ist ungefähr alles, was ich habe. Der Vergleichs-Builder ist nicht das Problem, das ist das Einfache. Der schwierige Teil ist eigentlich die Rückgabe des Ausdrucks. Ich habe nie versucht, Ausdrücke als Funktionswerte zurückzugeben. Im Grunde genommen muss ich also das Feld behalten und einen Vergleichsausdruck zurückgeben.

Irgendeine Hilfe? : x

Aktualisieren:

Leider löst dies nicht mein Problem. Es mag daran liegen, dass ich in den letzten 23 Stunden aufgestanden bin, aber ich habe nicht die geringste Ahnung, wie ich daraus eine Erweiterungsmethode machen kann. Wie gesagt, was ich möchte ... ist im Grunde eine Art zu schreiben:

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

Die Art und Weise, wie ich diese Funktion herausgearbeitet habe (wahrscheinlich völlig falsch), ist

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

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

Es fehlt der "this -something- value", mit dem ich vergleichen kann, und ich habe noch nicht herausgefunden, wie es möglich sein soll, eine Ausdruckseingabe zu erhalten ... für ReSharper empfehle ich die Konvertierung es stattdessen zu booleschen ...

Mein Kopf ist im Moment voller Flusen ...

Update 2:

Ich habe es geschafft, einen Weg zu finden, einen Code zu haben, der in einem Speicher-Repository einer Konsolenanwendung funktioniert. Ich muss es jedoch noch mit Entity Framework versuchen.

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);
    }

Ich bezweifle jedoch sehr, dass ich danach bin

Update 3:

Richtig, nachdem ich mich hingesetzt und die Lambda-Ausdrücke noch einmal durchgesehen hatte, kam ich vor der letzten Antwort auf etwas Ähnliches: Es erfüllt nicht die genauen Anforderungen von "Compare ()", aber es ist ein "Überlastungsfaktor". Where-Methode:

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);
    }

Trotz meiner Augen, alles scheint logisch, bekomme ich Laufzeitausnahme von:

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)

Dies ist offensichtlich die Schuldige Linie:

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

Ich bin der Lösung sehr nahe. Wenn ich diesen Fehler von meinem Rücken kriegen kann, sollte EF in der Lage sein, das in SQL zu übersetzen. Ansonsten ... naja, die letzte Antwort wird wahrscheinlich gehen.

Antworten auf die Frage(3)

Ihre Antwort auf die Frage