C# Lambda-Ausdrücke (Wie es für Entwickler funktioniert)

Einführung

Im Bereich der C#-Programmierung gehören Lambda-Ausdrücke zu den mächtigsten Funktionen. Diese prägnanten und ausdrucksstarken Konstrukte ermöglichen es Entwicklern, kompakten und dennoch robusten Code zu schreiben, der die Lesbarkeit, Wartbarkeit und allgemeine Effizienz verbessert.

In diesem Artikel tauchen wir tief in die C#-Lambda-Ausdrücke ein und untersuchen ihre Syntax, Anwendungsfälle, Vorteile und fortgeschrittenen Techniken. Wir werden auch erforschen, wie die Fähigkeiten von IronPDF von Iron Software ein PDF-Dokument spontan in C#-Anwendungen erstellen können.

Verstehen von Lambda-Ausdrücken

Lambda-Ausdrücke, die in C# 3.0 eingeführt wurden, bieten eine prägnante Möglichkeit, anonyme Funktionen oder Delegaten zu definieren. Sie sind im Wesentlichen anonyme Inline-Funktionen, die überall dort verwendet werden können, wo ein Delegatentyp erwartet wird.

Die Syntax für einen Lambda-Ausdruck lautet:

(parameters) => expression // lambda operator oe method syntax
x=> x*x // expression to square a number

(parameters) => expression // lambda operator oe method syntax
x=> x*x // expression to square a number

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'(parameters) => expression x=> x*x ' expression to square a number

Dabei sind Parameter die Eingabeparameter des Lambda-Ausdrucks und Ausdruck die auszuführende Anweisung oder der Block von Anweisungen. Die .NET-Laufzeitumgebung erstellt während der Kompilierung eine anonyme Funktion für jeden Lambda-Ausdruck.

Grundlegende Verwendung

Sehen wir uns ein Beispiel für einen Lambda-Ausdruck an, bei dem wir eine Liste von ganzen Zahlen haben und die geraden Zahlen herausfiltern wollen.

Wir können dies erreichen, indem wir die Methode List<T>.FindAll zusammen mit einem Lambda-Ausdruck verwenden:

List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
List<int> evenNumbers = numbers.FindAll(x => x % 3 == 0);

List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
List<int> evenNumbers = numbers.FindAll(x => x % 3 == 0);

Dim numbers As New List(Of Integer) From {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
Dim evenNumbers As List(Of Integer) = numbers.FindAll(Function(x) x Mod 3 = 0)

Im obigen Beispiel ist x => x % 3 == 0 ein Lambda-Ausdruck, der eine Ganzzahl x als Eingabeparameter nimmt und true zurückgibt, wenn x gerade ist, sonst false. Der Lambda-Ausdruck wird auf jedes Array-Element angewendet.

Anwendungsfälle

Die Verwendung eines Lambda-Ausdrucks in der modernen Anwendungsprogrammierung findet eine Vielzahl von Anwendungsfällen, darunter:

1. LINQ-Abfragen: Lambda-Ausdrücke werden in LINQ (Language Integrated Query) umfassend genutzt, um Filter-, Projektions-, Sortierungs- und Gruppierungsoperationen auf Datensammlungen durchzuführen.

2. Ereignisbehandlung: Bei der Arbeit mit Ereignissen und Delegaten bieten Lambda-Ausdrücke eine prägnante Möglichkeit, Ereignis-Handler inline zu definieren.

3. Asynchrones Programmieren: In asynchronen Programmiervorlagen wie Task.Run können Lambda-Ausdrücke verwendet werden, um die auszuführende asynchrone Operation zu definieren.

4. Funktionale Programmierung: Lambda-Ausdrücke unterstützen funktionale Programmierparadigmen und ermöglichen Operationen wie Map, Filter und Reduce auf Sammlungen.

Arten von Lambda-Ausdrücken

Ausdrucks-Lambdas

Die Lambda-Ausdrücke mit => werden Ausdrucks-Lambdas genannt. Sie haben das folgende Format:

x=> x*x // expression to square a number

x=> x*x // expression to square a number

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'x=> x*x ' expression to square a number

Im obigen Beispiel erstellen wir ein Quadrat aus einer Zahl. In Ausdrucks-Lambdas kann der Körper Methodenaufrufe enthalten. Wenn jedoch Ausdrucksbäume erstellt werden, die zur Auswertung außerhalb der .NET Common Language Runtime (CLR) bestimmt sind, wie beispielsweise in SQL Server, ist es ratsam, auf jegliche Methodenaufrufe innerhalb von Lambda-Ausdrücken zu verzichten.

Dies liegt daran, dass Methoden außerhalb des CLR-Kontextes keine Bedeutung haben können. Daher ist es von entscheidender Bedeutung, bei der Konstruktion eines Ausdrucksbaums die Zielumgebung zu berücksichtigen, um Kompatibilität und sinnvolle Interpretation zu gewährleisten.

Anweisungs-Lambdas

Der folgende Code zeigt, wie man Lambda-Ausdrücke deklariert. Hier wird zuerst ein Delegat deklariert, der eine Methode mit nur Parametern und Körper hat.

Bei Bedarf wird dann ein Funktions-/Methodenname zum Delegatenparameter hinzugefügt.

Func<int> mySquareDelegate = (x =>
{
    return x*x;
});
Console.WriteLine(mySquareDelegate(4));

Func<int> mySquareDelegate = (x =>
{
    return x*x;
});
Console.WriteLine(mySquareDelegate(4));

Dim mySquareDelegate As Func(Of Integer) = (Function(x)
	Return x*x
End Function)
Console.WriteLine(mySquareDelegate(4))

Fortgeschrittene Techniken

Erfassen von Variablen

Lambda-Ausdrücke können Variablen aus dem umschließenden Bereich erfassen. Diese Funktion, die als Variablenerfassung oder Closure bekannt ist, ermöglicht Lambda-Ausdrücken den Zugriff auf und die Verwendung von Variablen, die außerhalb ihres Körpers deklariert sind.

int factor = 2;
Func<int, int> multiplier = x => x * factor;

int factor = 2;
Func<int, int> multiplier = x => x * factor;

Dim factor As Integer = 2
Dim multiplier As Func(Of Integer, Integer) = Function(x) x * factor

In diesem Beispiel erfasst der Lambda-Ausdruck x => x * factor die Variable factor aus dem umgebenden Bereich.

Mehrere Parameter und Anweisungen

Lambda-Ausdrücke können mehr als einen Parameter haben und mehrere in einen Block eingeschlossene Anweisungen ausführen.

Func<int, int, int> add = (a, b) => 
{
    int result = a + b;
    Console.WriteLine($"The sum of {a} and {b} is {result}");
    return result;
};

Func<int, int, int> add = (a, b) => 
{
    int result = a + b;
    Console.WriteLine($"The sum of {a} and {b} is {result}");
    return result;
};

Dim add As Func(Of Integer, Integer, Integer) = Function(a, b)
	Dim result As Integer = a + b
	Console.WriteLine($"The sum of {a} and {b} is {result}")
	Return result
End Function

IronPDF eine PDF-Bibliothek von Iron Software

Erkunden Sie IronPDF als vielseitige und leistungsstarke Bibliothek zur PDF-Generierung und -Analyse von Iron Software, die zur Erstellung von PDF-Dokumenten verwendet werden kann.

IronPDF kann über den NuGet-Paketmanager mit dem folgenden Befehl installiert werden:

Install-Package IronPdf

Oder von Visual Studio aus installiert, wie unten gezeigt:

Kommen wir nun zur PDF-Erzeugung mithilfe eines Lambda-Ausdrucks.

namespace IronPatterns;
class Program
{
    static void Main()
    {
        Console.WriteLine("-----------Iron Software-------------");
        var renderer = new ChromePdfRenderer(); // var pattern
        var content = " <h1> Iron Software is Awesome </h1> Made with IronPDF!";
        content += "<h2>Demo C# lambda expressions</h2>";
        content += $"<p>Generating Square of list of numbers x=>x*x</p>";
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        List<int> squares = numbers.Select(x => x * x).ToList();
        content += $"<p>Numbers list: {string.Join(",",numbers)}</p>";
        content += $"<p>Squares: {string.Join(",",squares)}</p>";
        var pdf = renderer.RenderHtmlAsPdf(content);
        pdf.SaveAs("output.pdf"); // Saves PDF
    }
}

namespace IronPatterns;
class Program
{
    static void Main()
    {
        Console.WriteLine("-----------Iron Software-------------");
        var renderer = new ChromePdfRenderer(); // var pattern
        var content = " <h1> Iron Software is Awesome </h1> Made with IronPDF!";
        content += "<h2>Demo C# lambda expressions</h2>";
        content += $"<p>Generating Square of list of numbers x=>x*x</p>";
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        List<int> squares = numbers.Select(x => x * x).ToList();
        content += $"<p>Numbers list: {string.Join(",",numbers)}</p>";
        content += $"<p>Squares: {string.Join(",",squares)}</p>";
        var pdf = renderer.RenderHtmlAsPdf(content);
        pdf.SaveAs("output.pdf"); // Saves PDF
    }
}

Namespace IronPatterns
	Friend Class Program
		Shared Sub Main()
			Console.WriteLine("-----------Iron Software-------------")
			Dim renderer = New ChromePdfRenderer() ' var pattern
			Dim content = " <h1> Iron Software is Awesome </h1> Made with IronPDF!"
			content &= "<h2>Demo C# lambda expressions</h2>"
			content &= $"<p>Generating Square of list of numbers x=>x*x</p>"
			Dim numbers As New List(Of Integer) From {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
			Dim squares As List(Of Integer) = numbers.Select(Function(x) x * x).ToList()
			content &= $"<p>Numbers list: {String.Join(",",numbers)}</p>"
			content &= $"<p>Squares: {String.Join(",",squares)}</p>"
			Dim pdf = renderer.RenderHtmlAsPdf(content)
			pdf.SaveAs("output.pdf") ' Saves PDF
		End Sub
	End Class
End Namespace

Ausgabe

Probelizenz

IronPDF-Code kann nur mit einer Testlizenz ausgeführt werden, die von der IronPDF-Testlizenzseite bezogen wurde. Geben Sie im Pop-up-Fenster eine E-Mail-ID an, um einen Lizenzschlüssel zu generieren und diesen an Ihre E-Mail-Adresse zu senden.

"IronPDF.LicenseKey": "<Your Key>"

Platzieren Sie den Lizenzschlüssel in der Datei AppSettings.Json.

Schlussfolgerung

C# Lambda-Ausdrücke bieten eine prägnante und ausdrucksstarke Möglichkeit, Inline-Funktionen zu definieren, wodurch der Code lesbarer, wartbarer und effizienter wird. Sie finden in verschiedenen Bereichen Anwendung, darunter LINQ-Abfragen, Ereignisbehandlung, asynchrone Programmierung und funktionale Programmierung.

Durch die Beherrschung von Lambda-Ausdrücken können Entwickler neue Dimensionen der Produktivität und Eleganz in ihren C#-Codebasen erschließen.

Ganz gleich, ob Sie ein erfahrener C#-Entwickler sind oder gerade erst mit dem Programmieren beginnen, das Verständnis und die Nutzung der Möglichkeiten von Lambda-Ausdrücken wird Ihre Programmierkenntnisse zweifellos auf ein neues Niveau heben.

Also tauchen Sie ein, experimentieren Sie und genießen Sie die Schönheit von Lambda-Ausdrücken in Ihren C#-Projekten!