Daten == Code? Ja, aber Code == Daten? - JAXenter

Daten == Code? Ja, aber Code == Daten?

Baumausgabe

Um mit Expression Trees, ob selbst generiert
oder von LINQ übergeben, arbeiten
zu können, muss man natürlich einiges
über den Aufbau solcher Hierarchien wissen.
Grundsätzlich kann jede Lambda Expression,
die sich nach den oben erklärten
Kriterien in Expression> speichern
lässt, analysiert werden, sodass an
Beispielen kein Mangel herrscht. Leider
ist jedoch in der Praxis die Analyse solcher
Hierarchien keine angenehme Arbeit,
schon deshalb, weil es 46 (!) unterschiedliche
Typen von Expressions gibt. Betrachten
Sie etwa folgendes Beispiel:

Expression> expression =
(x, y) => (x > 100 ? x > y : x > String.Concat("Hal", "lo"). Length);

Das Beispiel hat keine sinnvolle Funktion,
aber es demonstriert, wie in Expressions
unterschiedliche Elemente kombiniert
werden können. Es enthält eine Abfrage (x
> 100?) mit zwei verschiedenen Fällen, wovon
einer auch noch einen Funktionsaufruf
und einen Propertyzugriff ausführt.
Dies ist sicher noch weit entfernt von der
Komplexität, die in Datenbankabfragen
oft vorkommt, aber die dynamische Erzeugung
dieser Struktur würde Ihnen sicherlich
schon etwas zu denken geben.

Um die Analyse von Expression Trees zu
vereinfachen, habe ich eine Klasse entwickelt,
die die Strukturen in lesbarer Form
auf der Konsole ausgeben kann. Die Klasse
selbst ist leider etwas zu lang, um hier
gezeigt zu werden (sie ist jedoch auf der Website des dot.net magazin verfügbar). Listing
2 zeigt die Ausgabe, die damit für das
Beispiel oben erzeugt wird:

Listing 2

LambdaExpression (
Parameters:
ParameterExpression (x)
ParameterExpression (y)
Body:
ConditionalExpression (
Test:
BinaryExpression:GreaterThan (
Left:
ParameterExpression (x)
Right:
ConstantExpression (100)
)
IfTrue:
BinaryExpression:GreaterThan (
Left:
ParameterExpression (x)
Right:
ParameterExpression (y)
)
IfFalse:
BinaryExpression:GreaterThan (
Left:
ParameterExpression (x)
Right:
MemberExpression String.Length (
Expression:
MethodCallExpression String.Concat (
Arguments:
ConstantExpression (Hal)
ConstantExpression (lo)
)
)
)
)
)
Eleganterer Code dank Expression Trees

Die Möglichkeit, Code als Daten zu behandeln,
hat das .NET Framework und
die Sprache C# zweifellos bereichert.
Obwohl die Einsatzfälle eingeschränkt
sind, lassen sich erstaunlich viele Situationen
finden, wo mithilfe von dynamisch erzeugten
Expressions eleganterer und auch
sichererer Code geschrieben werden kann.
Die Verwendung der neuen Features ist dabei
noch nicht einmal kompliziert, sodass
mit etwas Übung und dem Expression-
Dumper bei der Hand auch komplexe Expression Trees erzeugt werden können.

Oliver Sturm ist Microsoft MVP für C# und lebt im Süden Schottlands. Sie können ihn unter oliver@sturmnet.org per E-Mail erreichen.

Kommentare

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht.