Crashkurs: Lambda Expressions

Als ich das erste Mal eine Lambda Expression gesehen habe dachte ich mir: „Was ist denn das für eine merkwürdige Syntax?“. Im ersten Moment war mir der Zweck des Quellcodes nicht klar. Nach kurzer Einarbeitungszeit habe ich aber nicht nur den Quellcode verstanden, sondern empfand die Lambda Expressions als wertvolle Spracherweiterung.

Mit diesem Crashkurs möchte ich Ihnen daher ebenfalls einen schnellen Einstieg in die Lambda Expressions geben. Ich werde Ihnen deren Zweck, Syntax und Anwendung an einfachen Beispielen zeigen.

 
Zweck

Lambda Expressions erlauben das Erstellen von anonymen Methoden. Sie können als Weiterentwicklung der anonymen Methoden angesehen werden und erlauben eine kürzere und besser lesbare Syntax. Lambda Expressions werden beispielsweise bei der Verwendung von LINQ benötigt. Auch im Rahmen der asynchronen Programmierung sind sie sehr hilfreich.

Der Name „Lambda Expression“ nimmt Bezug auf das Lambda Kalkül, eine formale Sprache zur Untersuchung von Funktionen.

 
Syntax

Lambda Expressions haben folgende Form:

(Eingabeparameter) => {Anweisungsblock}

  • => ist der sogenannte Lambda-Operator
  • Links vom Operator stehen die Parameter
  • Rechts vom Operator stehen die Anweisungen

 
Die nachfolgenden Richtlinien sollten beim Erstellen vom Lambda Expressions beachtet werden. Zu jeder Richtlinie ist ein entsprechendes Beispiel angegeben.

  • Es sind beliebig viele Eingabeparameter möglich. Eingabeparameter werden mit Komma getrennt.

(x, y) => {return x + y;};

 

  • Wird nur ein Eingabeparameter verwendet, dann kann die Klammer entfallen.

x => {return x + „abc“;};

 

  • Die Parametertypen der Eingabeparameter werden von Compiler automatisch ermittelt. Sie können aber auch explizit angegeben werden.

(string x, string y) => {return x + y;};

 

  • Besteht der Anweisungsblock aus nur einer Anweisung dann können die geschweiften Klammern und das Schlüsselwort return entfallen.

(x, y) => x + y;

 

  • Im Anweisungsblock sollten maximal drei Anweisungen stehen da Lambda Expressions nur für kurze Methoden verwendet werden sollten.

(x, y) => { string s = x + “ “ + y; return s; };

 
Beispiel

Bei einer Einführung in ein Programmierkonzept darf natürlich das klassische „Hello World“ Beispiel nicht fehlen. Der nachfolgende Code-Ausschnitt zeigt dieses Beispiel realisiert mit einer Lambda Expression.

    1 Func<string, string, string> concat = (x, y) =>

    2 {

    3     string s = x + “ „ + y;

    4     return s;

    5 };

    6

    7 Console.WriteLine(concat(„Hello“, „World“));

 
Wenn Sie sich an die oben genannten Richtlinien zur Syntax zurückerinnern, dann sehen Sie bestimmt schon viele Optimierungsmöglichkeiten in dem Beispielcode. Der nachfolgende Code-Ausschnitt zeigt die gleiche Funktionalität wie zuvor, aber die Lambda Expression wurde stark gekürzt.

    1 Func<string, string, string> concatShort = (x, y) => x + “ „ + y;

    2

    3 Console.WriteLine(concatShort(„Hello“, „World“));

 
Variablen der umschliessenden Methode nutzen

Lambda Expressions können lokale Variablen der Methode nutzen, in der sie erstellt wurden. Das heisst, sie können die äusseren Variablen der umschliessenden Methode verwenden. Das nachfolgende Beispiel zeigt eine Lambda Expression welche auf eine lokale Variable zugreift.

    1 int outerValue = 0;

    2 Action print = () => Console.WriteLine(outerValue);

    3

    4 outerValue = 10;

    5 print();

 
Die lokale Variable wird innerhalb der Lambda Expression erst ausgewertet wenn diese aufgerufen wird. Daher wird in dem zuvor gezeigten Beispiel „10“ ausgegeben.

Die äusseren Variablen können innerhalb der Lambda Expression auch verändert werden. Der nachfolgende Code-Ausschnitt zeigt eine Funktion welche die äussere Variable verändert.

    1 int outerValue = 0;

    2 Func<int> increment = () => outerValue++;

    3 

    4 Console.WriteLine(increment());

    5 Console.WriteLine(increment());

    6 Console.WriteLine(increment());

 
Der Beispielcode generiert folgende Ausgabe:
0
1
2

 
Interessanterweise wird zuerst „0“ ausgegeben. Das heisst, es wird zuerst der WriteLine Befehl ausgeführt und erst danach wird der Wert um eins erhöht. Was geschieht wenn statt der Postfix-Schreibweise die Präfix-Schreibweise zum Inkrementieren verwendet wird? Das folgende Beispiel zeigt den angepassten Quellcode. Dabei wurde in Zeile 2 der ++ Operator verschoben.

    1 int outerValue = 0;

    2 Func<int> increment = () => ++outerValue;

    3 

    4 Console.WriteLine(increment());

    5 Console.WriteLine(increment());

    6 Console.WriteLine(increment());

 
Der Beispielcode generiert diesmal folgende Ausgabe:
1
2
3

 
Fazit

Lambda Expressions sind eine effiziente Weiterentwicklung von anonymen Methoden. Durch die stark verkürzte Syntax lässt sich gut lesbarer Quellcode erzeugen. Einige Sprachfeatures wie zum Beispiel LINQ basieren auf Lambda Expressions und verwenden diese in hohem Mass.

Advertisements
Dieser Beitrag wurde unter .NET, C#, Crashkurs abgelegt und mit verschlagwortet. Setze ein Lesezeichen auf den Permalink.

2 Antworten zu Crashkurs: Lambda Expressions

  1. Pingback: Multithreading in C#, Teil 9: Lambda Expressions mit Variablen | coders corner

  2. Pingback: Java 8 mit Lambda-Expressions veröffentlicht - ComputerBase

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