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 IronPDF von Iron Software kann in C#-Anwendungen ein PDF-Dokument im Handumdrehen erzeugen.

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 mit der Funktion `List.FindAll"-Methode zusammen mit einem Lambda-Ausdruck:

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 ganze Zahl x als Eingabeparameter annimmt und true zurückgibt, wenn x gerade ist, und false andernfalls. Der Lambda-Körperausdruck wird für jedes Array-Element ausgeführt.

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 ausgiebig verwendet (Sprache Integrierte Abfrage) um Filter-, Projektions-, Sortier- und Gruppierungsoperationen für 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. Asynchrone Programmierung: In asynchronen Programmiermustern wie Task.Run können Lambda-Ausdrücke verwendet werden, um den auszuführenden asynchronen Vorgang 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 als Ausdrucks-Lambdas bezeichnet. 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. Bei der Erzeugung von Ausdrucksbäumen, die für die Auswertung außerhalb der .NET Common Language Runtime (CLR)wie z.B. in SQL Server, ist es ratsam, Methodenaufrufe innerhalb von Lambda-Ausdrücken zu vermeiden.

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 * Faktor" die Faktor-Variable aus dem umschließenden 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

IronPDF ist eine vielseitige und leistungsstarke PDF-Erzeugungs- und Parsing-Bibliothek 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 bei hier. 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.

Tauchen Sie also ein, experimentieren Sie und nutzen Sie die Schönheit von Lambda-Ausdrücken in Ihren C#-Projekten!