h1

.NET 3.5 – Neuerungen bei C#3.0 – Teil 4 von 9

Februar 8, 2008

Expression Trees und Lambda Expressions

Nach langer langer Zeit will ich mal wieder in meiner kleinen Serie fortfahren. Da es jetzt schon etwas komplexer wird habe ich mich so lange gesträubt hier weiter zu schreiben. Jetzt versuche ich mal wieder so einfach wie möglich in das Thema einzuführen.
Eigentlich liegt der Ursprung in den anonymen Methoden, die mit C# 2.0 eingeführt wurden. Zur Erinnerung ein kurzes Beispiel einer anonymen Methode:

IEnummerable<Customer> list = customers.Where(
	delegate(Customer c)
	{
		return c.Name == "Microsoft";
	});

In diesem Beispiel ist das es das Ziel alle „customers“ mit dem Namen „Microsoft“ in einer Enummeration zusammenzufassen. Hier ist auch das erste mal ersichtlich, dass wir mit der Methode „Where“ auf ein bereits erläutertes neues Feature der Extension Methods zurückgreifen.

public static IEnumerable<T> Where<T>(
	this IEnumerable<T>   source, Func<T, bool> predicate)
{
	foreach(T item in source) {
		if (predicate(item)) yield return item;
	}
}

Mit C#3.0 kann man nun die oben gezeigte anonyme Methode auf eine Zeile Code reduzieren:

IEnummerable<Customer> list = 
	customers.Where(c=>c.Name=="Microsoft");

In C# wird ein Lambda-Ausdruck syntaktisch als Parameter-Liste gefolgt von einem => Token und dann gefolgt von dem Ausdruck oder einer ausführ-baren Block-Anweisung (wenn der Ausdruck aufgerufen wird) geschrieben:

params => Ausdruck

also in diesem Beispiel:

c => c.Name == „Microsoft“ oder in ausführlicher Schreibweise
(Customer c) => c.Name == „Microsoft“

x => x + 1     // Implicitly typed, expression body 
x => {return x + 1;}// Implicitly typed, statement body 
(int x) => x + 1    // Explicitly typed, expression body 
(int x) => {return x + 1;} // Explicitly typed, stmnt body 
(x, y) => x * y            // Multiple parameters 
() => Console.WriteLine()  // No parameters 

Im Gegensatz zu anonymen Methoden muss bei Lambda Expression der verwendete Typ nicht explizit angegeben werden. Bei der Schreibweise c=>c.Name ist dem Compiler bereits klar, dass c vom Typ Customer sein muss, da die Extension Methode „Where“ mit einer generischen Liste vom Typ „Customer“ gearbeitet hat. Bei Verwendung von Visual Studio 2008 handelt es sich nicht nur um Compilezeit Support, sondern es wird auch bei der Designzeit mit Intellisense unterstützt.

Einige Dinge müssen beachtet werden:

delegate R Func<A,R>(A arg);

–>

Func<int,int> f1 = x => x + 1; // Ok 
Func<int,double> f2 = x => x + 1; // Ok 
Func<double,int> f3 = x => x + 1; // Error 

In der letzten Zeile ist „x+1“ nicht implizit ein double, weswegen diese Zeile schon beim Compilieren zum Fehler führt.

Was sind nun Expression Trees?

Eines der Dinge warum die Lambda-Ausdrücke so ein mächtiges Werkzeug aus der Entwickler-Perspektive sind, ist dass man sie kompiliert kann. Entweder als delegate-Code (in Form einer IL Methode) oder als Expression Tree Objekt, die benutzt während der Laufzeit benutzt werden können um den Ausdruck zum optimieren, zu analysieren oder zu transformieren. Die Extension Methode „Where“ im oberen Beispiel zeigt wie man diese in Form eines delegate Code kompilieren kann.

Kompilierte Lambda-Ausdrücke funktioniert toll, wenn wir diese für Daten innerhalb des Speichers verwenden wollen. Aber bei Fällen, in denen Sie Abfrage von Daten aus einer Datenbank durchführen wollen, ist das nicht immer der geeignete Weg. Stattdessen würde ich gerne das LINQ zu SQL ORM zur Übersetzung meines Lambda-Filters in einen SQL-Ausdruck verwenden und die Filter-Abfrage in der Remote-SQL-Datenbank durchführen lassen. Auf diese Weise würde ich nur die gefilterten Zeilen als Ergebnis erhalten.

Func<int,int> f = x => x + 1; // Code 
Expression<Func<int,int>> e = x => x + 1; // Data 

Framework-Entwickler können dies erreichen, indem sie die Argumente zu Lambda-Ausdruck vom Typ Expression <T> statt Func <T> erklären. Dies führt dazu, dass ein Lambda-Ausdruck Argument als Expression-Tree kompiliert wird. Dieser kann dann zur Laufzeit analysiert werden:

Expression<Func>Customer, bool>> filter;
filter = c => c.Name = "Microsoft";
BinaryExpression body = (BinaryExpression)filter.Body;

Im Fall von LINQ zu SQL, kann dieser Expression und Lambda-Filter verwendet werden, um diesen in SQL-Standard zu übersetzen und gegen eine Datenbank auszuführen (logisch „SELECT * from Customers where Name = ‚Microsoft'“).

^ Teil 1: Übersicht aller Neuerungen (Einleitung)

< Teil 3: Extension-Methods

> Teil 5: Object und Collection Initializer

Advertisements

Kommentar verfassen

Trage deine Daten unten ein oder klicke ein Icon um dich einzuloggen:

WordPress.com-Logo

Du kommentierst mit Deinem WordPress.com-Konto. Abmelden / Ändern )

Twitter-Bild

Du kommentierst mit Deinem Twitter-Konto. Abmelden / Ändern )

Facebook-Foto

Du kommentierst mit Deinem Facebook-Konto. Abmelden / Ändern )

Google+ Foto

Du kommentierst mit Deinem Google+-Konto. Abmelden / Ändern )

Verbinde mit %s

%d Bloggern gefällt das: