Dynamisch Zu Erstellen Linq Lambda-Ausdruck

Okay, meine Vermutung ist, dass dies schon irgendwo beantwortet und ich bin einfach nicht vertraut genug mit der syntax noch nicht verstanden, so mit mir tragen.

Den Nutzern meiner web-app-filter für eine lange Liste von Elementen in einer gridview, auf die der Zugriff über eine linqdatasource-Steuerelement. Ich bin mit dem OnSelecting Veranstaltung, um weitere filter-Elemente. Ich möchte filter die Elemente basierend auf der Auswahl der Benutzer im DropDownLists.

Zum Beispiel, wählen Sie "Titel" "Enthält" "Fred"
Dies führt zu

e.Result = dbContext.Opps.Where(opp => opp.Title.Contains("Fred"));

Oder "Beschreibung" "Enthält nicht" "Alpha"
Ergebnisse in

 e.Result = dbContext.Opps.Where(opp => !opp.Description.Contains("Alpha"));

Möchte ich aufbauen, dass die Expression (System.Linq -.Ausdrücke.Ausdruck>), dynamisch, anstatt verschachtelte switch-Ausdrücke zu generieren, da gibt es eine Reihe von Feldern, die ich überprüfen möchten, und ich auch mit dem StartsWith und EndsWith überprüft. Wenn ich könnte, erstellen Sie einen Ausdruck als string, etwa so:

string stringExpression = string.Format("opp => opp.{0}.{1}(\"{2}\")",
    ddlCustomFilter.SelectedValue,
    ddlFilterType.SelectedValue,
    txtFilterText.Text);

Und dann irgendwie haben es umgewandelt werden in einen Ausdruck... ist das möglich? Oder sollte ich nur den sauren Apfel beißen und erzeugen alle die switch () - Anweisungen erforderlich, um die verschiedenen Ausdrücke?

InformationsquelleAutor Dave | 2010-02-19
  1. 9

    Können Sie sicher bauen den Ausdruck dynamisch, aber ich würde prüfen, mit Dynamische LINQ als eine alternative ersten, obwohl Sie möglicherweise nicht in der Lage sein zu verwenden, Enthält. Darüber hinaus möchten Sie vielleicht zu prüfen, mit PredicateBuilder, komplexe Abfragen zu erstellen Additiv.

    • Ich Stimme mit der Dynamischen Linq-library. Ein hässliches funktioniert heute noch, ist aber schwieriger zu pflegen/verwalten die Straße hinunter.
    • Dynamische Linq funktioniert perfekt. Es meistert sogar Feld.Enthält und !Feld.Enthält. Das ist gut, denn ich kann nicht Köpfe oder Schwänze der PredicateBuilder.
    • Muss ich etwas herunterladen, um zu bekommen PredicateBuilder in vs210 .net4.0 ?
    • Es ist nicht mit enthalten .NET haben, müssen Sie es hinzufügen. Folgen Sie dem link in der Antwort. Der Quellcode ist da.
    • Enttäuscht, dass die Frage nie wirklich beantwortet.
    InformationsquelleAutor tvanfosson
  2. 7

    versuchen, diesen code...

    call ToExpression-Methode()....

    public static Expression<Func<T, bool>> ToExpression<T>(string andOrOperator, string propName, string opr, string value, Expression<Func<T, bool>> expr = null)
    {
        Expression<Func<T, bool>> func = null;
        try
        {
            ParameterExpression paramExpr = Expression.Parameter(typeof(T));
            var arrProp = propName.Split('.').ToList();
            Expression binExpr = null;
            string partName = string.Empty;
            arrProp.ForEach(x =>
            {
                Expression tempExpr = null;
                partName = partName.IsNull() ? x : partName + "." + x;
                if (partName == propName)
                {
                    var member = NestedExprProp(paramExpr, partName);
                    var type = member.Type.Name == "Nullable`1" ? Nullable.GetUnderlyingType(member.Type) : member.Type;
                    tempExpr = ApplyFilter(opr, member, Expression.Convert(ToExprConstant(type, value), member.Type));
                }
                else
                    tempExpr = ApplyFilter("!=", NestedExprProp(paramExpr, partName), Expression.Constant(null));
                if (binExpr != null)
                    binExpr = Expression.AndAlso(binExpr, tempExpr);
                else
                    binExpr = tempExpr;
            });
            Expression<Func<T, bool>> innerExpr = Expression.Lambda<Func<T, bool>>(binExpr, paramExpr);
            if (expr != null)
                innerExpr = (andOrOperator.IsNull() || andOrOperator == "And" || andOrOperator == "AND" || andOrOperator == "&&") ? innerExpr.And(expr) : innerExpr.Or(expr);
            func = innerExpr;
        }
        catch { }
        return func;
    }

    private static MemberExpression NestedExprProp(Expression expr, string propName)
    {
        string[] arrProp = propName.Split('.');
        int arrPropCount = arrProp.Length;
        return (arrPropCount > 1) ? Expression.Property(NestedExprProp(expr, arrProp.Take(arrPropCount - 1).Aggregate((a, i) => a + "." + i)), arrProp[arrPropCount - 1]) : Expression.Property(expr, propName);
    }

    private static Expression ToExprConstant(Type prop, string value)
    {
        if (value.IsNull())
            return Expression.Constant(value);
        object val = null;
        switch (prop.FullName)
        {
            case "System.Guid":
                val = value.ToGuid();
                break;
            default:
                val = Convert.ChangeType(value, Type.GetType(prop.FullName));
                break;
        }
        return Expression.Constant(val);
    }

    private static Expression ApplyFilter(string opr, Expression left, Expression right)
    {
        Expression InnerLambda = null;
        switch (opr)
        {
            case "==":
            case "=":
                InnerLambda = Expression.Equal(left, right);
                break;
            case "<":
                InnerLambda = Expression.LessThan(left, right);
                break;
            case ">":
                InnerLambda = Expression.GreaterThan(left, right);
                break;
            case ">=":
                InnerLambda = Expression.GreaterThanOrEqual(left, right);
                break;
            case "<=":
                InnerLambda = Expression.LessThanOrEqual(left, right);
                break;
            case "!=":
                InnerLambda = Expression.NotEqual(left, right);
                break;
            case "&&":
                InnerLambda = Expression.And(left, right);
                break;
            case "||":
                InnerLambda = Expression.Or(left, right);
                break;
            case "LIKE":
                InnerLambda = Expression.Call(left, typeof(string).GetMethod("Contains", new Type[] { typeof(string) }), right);
                break;
            case "NOTLIKE":
                InnerLambda = Expression.Not(Expression.Call(left, typeof(string).GetMethod("Contains", new Type[] { typeof(string) }), right));
                break;
        }
        return InnerLambda;
    }

    public static Expression<Func<T, object>> PropExpr<T>(string PropName)
    {
        ParameterExpression paramExpr = Expression.Parameter(typeof(T));
        var tempExpr = Extentions.NestedExprProp(paramExpr, PropName);
        return Expression.Lambda<Func<T, object>>(Expression.Convert(Expression.Lambda(tempExpr, paramExpr).Body, typeof(object)), paramExpr);

    }
    public static IQueryOver<T, T> OrderBy<T>(this IQueryOver<T, T> Collection, string sidx, string sord)
    {
        return sord == "asc" ? Collection.OrderBy(NHibernate.Criterion.Projections.Property(sidx)).Asc : Collection.OrderBy(NHibernate.Criterion.Projections.Property(sidx)).Desc;
    }

    public static Expression<Func<T, TResult>> And<T, TResult>(this Expression<Func<T, TResult>> expr1, Expression<Func<T, TResult>> expr2)
    {
        var invokedExpr = Expression.Invoke(expr2, expr1.Parameters.Cast<Expression>());
        return Expression.Lambda<Func<T, TResult>>(Expression.AndAlso(expr1.Body, invokedExpr), expr1.Parameters);
    }

    public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> expr1, Expression<Func<T, bool>> expr2)
    {
        var invokedExpr = Expression.Invoke(expr2, expr1.Parameters.Cast<Expression>());
        return Expression.Lambda<Func<T, bool>>(Expression.OrElse(expr1.Body, invokedExpr), expr1.Parameters);
    }
    InformationsquelleAutor suneelsarraf
Schreibe einen Kommentar