Markieren Sie das Kontrollkästchen Englisch, um die englische Version dieses Artikels anzuzeigen. Sie können den englischen Text auch in einem Popup-Fenster einblenden, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch
Diese Dokumentation wurde archiviert und wird nicht länger gepflegt.

Gewusst wie: Verwenden von Ausdrucksbaumstrukturen zum Erstellen dynamischer Abfragen (C# und Visual Basic)

In LINQ werden Ausdrucksbaumstrukturen verwendet, um strukturierte Abfragen darzustellen, die auf Quellen mit Daten abzielen, welche IQueryable<T> implementieren. Beispielsweise implementiert der LINQ to SQL-Provider die IQueryable<T>-Schnittstelle zum Abfragen relationaler Datenspeicher. Die Compiler für C# und Visual Basic kompilieren Abfragen auf solche Datenquellen in Code, durch den zur Laufzeit eine Ausdrucksbaumstruktur erzeugt wird. Anschließend kann der Abfrageanbieter die Ausdrucksbaumstruktur durchlaufen und in eine für die Datenquelle geeignete Abfragesprache übersetzen.

Ausdrucksbaumstrukturen werden in LINQ auch zur Darstellung von Lambda-Ausdrücken verwendet, die Variablen vom Typ Expression<TDelegate> zugewiesen sind.

In diesem Thema wird beschrieben, wie Ausdrucksbaumstrukturen verwendet werden, um dynamische LINQ-Abfragen zu erstellen. Dynamische Abfragen sind nützlich, wenn die Einzelheiten einer Abfrage zur Kompilierzeit nicht bekannt sind. Beispielsweise kann eine Anwendung über eine Benutzeroberfläche verfügen, in der der Endbenutzer ein oder mehrere Prädikate zum Filtern der Daten angeben kann. Damit LINQ für Abfragen verwendet werden kann, muss solch eine Anwendung Ausdrucksbaumstrukturen benutzen, um die LINQ-Abfrage zur Laufzeit zu erstellen.

Im folgenden Beispiel wird veranschaulicht, wie eine Abfrage für eine IQueryable-Datenquelle mithilfe von Ausdrucksbaumstrukturen erstellt und dann ausgeführt wird. Im Code wird eine Ausdrucksbaumstruktur erstellt, welche die folgende Abfrage darstellt:

C#-Abfrage

companies.Where(company => (company.ToLower() == "coho winery" || company.Length > 16)).OrderBy(company => company)

Visual Basic-Abfrage

companies.Where(Function(company) company.ToLower() = "coho winery" OrElse company.Length > 16).OrderBy(Function(company) company)

Die Factorymethoden im System.Linq.Expressions-Namespace werden zum Erstellen von Ausdrucksbaumstrukturen verwendet, welche die Ausdrücke der gesamten Abfrage darstellen. Die Ausdrücke, welche die Aufrufe der Standardabfrageoperator-Methoden darstellen, verweisen auf die Queryable-Implementierungen dieser Methoden. Die endgültige Ausdrucksbaumstruktur wird an die CreateQuery<TElement>(Expression)-Implementierung des IQueryable-Datenquellenanbieters übergeben, um eine ausführbare Abfrage vom Typ IQueryable zu erstellen. Um Ergebnisse zu erhalten, wird diese Abfragevariable aufgelistet.


            string[] companies = { "Consolidated Messenger", "Alpine Ski House", "Southridge Video", "City Power & Light",
                               "Coho Winery", "Wide World Importers", "Graphic Design Institute", "Adventure Works",
                               "Humongous Insurance", "Woodgrove Bank", "Margie's Travel", "Northwind Traders",
                               "Blue Yonder Airlines", "Trey Research", "The Phone Company",
                               "Wingtip Toys", "Lucerne Publishing", "Fourth Coffee" };

            // The IQueryable data to query.
            IQueryable<String> queryableData = companies.AsQueryable<string>();

            // Compose the expression tree that represents the parameter to the predicate.
            ParameterExpression pe = Expression.Parameter(typeof(string), "company");

            // ***** Where(company => (company.ToLower() == "coho winery" || company.Length > 16)) *****
            // Create an expression tree that represents the expression 'company.ToLower() == "coho winery"'.
            Expression left = Expression.Call(pe, typeof(string).GetMethod("ToLower", System.Type.EmptyTypes));
            Expression right = Expression.Constant("coho winery");
            Expression e1 = Expression.Equal(left, right);

            // Create an expression tree that represents the expression 'company.Length > 16'.
            left = Expression.Property(pe, typeof(string).GetProperty("Length"));
            right = Expression.Constant(16, typeof(int));
            Expression e2 = Expression.GreaterThan(left, right);

            // Combine the expression trees to create an expression tree that represents the
            // expression '(company.ToLower() == "coho winery" || company.Length > 16)'.
            Expression predicateBody = Expression.OrElse(e1, e2);

            // Create an expression tree that represents the expression
            // 'queryableData.Where(company => (company.ToLower() == "coho winery" || company.Length > 16))'
            MethodCallExpression whereCallExpression = Expression.Call(
                typeof(Queryable),
                "Where",
                new Type[] { queryableData.ElementType },
                queryableData.Expression,
                Expression.Lambda<Func<string, bool>>(predicateBody, new ParameterExpression[] { pe }));
            // ***** End Where *****

            // ***** OrderBy(company => company) *****
            // Create an expression tree that represents the expression
            // 'whereCallExpression.OrderBy(company => company)'
            MethodCallExpression orderByCallExpression = Expression.Call(
                typeof(Queryable),
                "OrderBy",
                new Type[] { queryableData.ElementType, queryableData.ElementType },
                whereCallExpression,
                Expression.Lambda<Func<string, string>>(pe, new ParameterExpression[] { pe }));
            // ***** End OrderBy *****

            // Create an executable query from the expression tree.
            IQueryable<string> results = queryableData.Provider.CreateQuery<string>(orderByCallExpression);

            // Enumerate the results.
            foreach (string company in results)
                Console.WriteLine(company);

            /*  This code produces the following output:

                Blue Yonder Airlines
                City Power & Light
                Coho Winery
                Consolidated Messenger
                Graphic Design Institute
                Humongous Insurance
                Lucerne Publishing
                Northwind Traders
                The Phone Company
                Wide World Importers
            */



In diesem Code wird in dem an die Queryable.Where-Methode übergebenem Prädikat eine feste Anzahl von Ausdrücken verwendet. Sie können jedoch auch eine Anwendung programmieren, in der eine variable Anzahl von Prädikatausdrücken kombiniert wird, die von der Benutzereingabe abhängig ist. Außerdem können abhängig von der Benutzereingabe auch die in der Abfrage aufgerufenen Standardabfrageoperatoren variieren.

  • Erstellen Sie ein neues Konsolenanwendungsprojekt in Visual Studio.

  • Fügen Sie einen Verweis auf System.Core.dll hinzu, wenn er noch nicht vorhanden ist.

  • Binden Sie den System.Linq.Expressions-Namespace ein.

  • Kopieren Sie den Code aus dem Beispiel, und fügen Sie ihn in die Main-Methode (C#) oder die Main Sub-Prozedur (Visual Basic) ein.

Anzeigen: