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, aber robusten Code zu schreiben, der die Lesbarkeit, Wartbarkeit und Gesamteffizienz verbessert.
In diesem Artikel werden wir tief in die C#-Lambda-Ausdrücke eintauchen und ihre Syntax, Anwendungsfälle, Vorteile und fortgeschrittenen Techniken erkunden. Wir werden auch untersuchen, wie die Fähigkeiten von IronPDF von Iron Software ein PDF-Dokument spontan in C#-Anwendungen erzeugen können.
Lambda-Ausdrücke, eingeführt in C# 3.0, bieten eine prägnante Möglichkeit, anonyme Funktionen oder Delegaten zu definieren. Sie sind im Wesentlichen Inline-anonyme Funktionen, die überall dort verwendet werden können, wo ein Delegaten-Typ erwartet wird.
Die Syntax eines Lambda-Ausdrucks lautet:
(parameters) => expression // lambda expression syntax'INSTANT VB TODO TASK: The following line uses invalid syntax:
'(parameters) => expression ' lambda expression syntaxBeispiel:
x => x * x // lambda expression to square a number'INSTANT VB TODO TASK: The following line uses invalid syntax:
'x => x * x ' lambda expression to square a numberHier sind die Eingabeparameter des Lambda-Ausdrucks parameters und expression ist die auszuführende Anweisung oder der Anweisungsblock. Die .NET Common Language Runtime erstellt zur Kompilierungszeit eine anonyme Funktion für jeden Lambda-Ausdruck.
Sehen wir uns ein Beispiel für einen Lambda-Ausdruck an, bei dem wir eine Liste von Ganzzahlen haben und die geraden Zahlen herausfiltern wollen.
Dies können wir mit der List<t>.FindAll-Methode zusammen mit einem Lambda-Ausdruck erreichen:
List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
List<int> evenNumbers = numbers.FindAll(x => x % 2 == 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 2 = 0)Im obigen Beispiel ist x => x % 2 == 0 ein Lambda-Ausdruck, der eine ganze Zahl x als Eingabeparameter nimmt und true zurückgibt, wenn x gerade ist, andernfalls false. Der Ausdruck des Lambdakörpers wird auf jedes Listenelement angewendet.
Die Verwendung von Lambda-Ausdrücken in der modernen Anwendungsprogrammierung bietet eine Vielzahl von Anwendungsfällen, darunter:
Task.Run können Lambda-Ausdrücke verwendet werden, um die auszuführende asynchrone Operation zu definieren.Lambda-Ausdrücke mit => werden Ausdrucks-Lambdas genannt. Sie haben das Format:
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 numberIm obigen Beispiel erstellen wir das Quadrat einer Zahl. Im Ausdrucks-Lambda können Methodenaufrufe eingeschlossen werden. Doch beim Generieren von Ausdrucksbäumen, die außerhalb der .NET Common Language Runtime (CLR) ausgewertet werden sollen, wie beispielsweise in SQL Server, ist es ratsam, auf Methodenaufrufe innerhalb von Lambda-Ausdrücken zu verzichten.
Dies liegt daran, dass Methoden außerhalb des CLR-Kontextes möglicherweise keine Bedeutung haben. Daher ist es wichtig, die Zielumgebung beim Erstellen eines Ausdrucksbaums zu berücksichtigen, um Kompatibilität und sinnvolle Interpretation sicherzustellen.
Anweisungs-Lambda-Ausdrücke erlauben mehrere Anweisungen und bieten komplexere Operationen:
Func<int, int> mySquareDelegate = (x) =>
{
return x * x;
};
Console.WriteLine(mySquareDelegate(4)); // Output: 16Dim mySquareDelegate As Func(Of Integer, Integer) = Function(x)
Return x * x
End Function
Console.WriteLine(mySquareDelegate(4)) ' Output: 16In diesem Code wird ein Delegat deklariert, der auf Ganzzahlen wirkt und ihr Quadrat zurückgibt. Der Lambdakörper kann mehrere Anweisungen innerhalb eines Blocks {} umfassen.
Lambda-Ausdrücke können Variablen aus dem umgebenden Kontext erfassen. Diese Funktion, bekannt als Variablen-Einfangen oder Closure, ermöglicht es Lambda-Ausdrücken, Variablen zuzugreifen und zu nutzen, die außerhalb ihres Bodys deklariert sind:
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 * factorIn diesem Beispiel erfasst der Lambda-Ausdruck x => x * factor die Variable factor aus dem umgebenden Bereich.
Lambda-Ausdrücke können mehr als einen Parameter haben und mehrere Anweisungen ausführen, die in einem Block eingeschlossen sind:
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 FunctionEntdecken Sie IronPDF als eine vielseitige und leistungsstarke PDF-Erstellungs- und Parsing-Bibliothek von Iron Software, die zur Erstellung von PDF-Dokumenten verwendet werden kann.
IronPDF kann mit dem folgenden Befehl aus dem NuGet-Paketmanager installiert werden:
Oder aus Visual Studio wie unten gezeigt installiert werden:
Nun tauchen wir in die PDF-Erstellung mit einem Lambda-Ausdruck ein:
using IronPdf; // Import the IronPdf library
using System;
using System.Collections.Generic;
using System.Linq;
namespace IronPatterns
{
class Program
{
static void Main()
{
Console.WriteLine("-----------Iron Software-------------");
var renderer = new ChromePdfRenderer(); // Initialize the PDF renderer
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 };
// Use Select to create a list of squared numbers
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); // Render the HTML as a PDF
pdf.SaveAs("output.pdf"); // Save the PDF document
}
}
}Imports IronPdf ' Import the IronPdf library
Imports System
Imports System.Collections.Generic
Imports System.Linq
Namespace IronPatterns
Friend Class Program
Shared Sub Main()
Console.WriteLine("-----------Iron Software-------------")
Dim renderer = New ChromePdfRenderer() ' Initialize the PDF renderer
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}
' Use Select to create a list of squared numbers
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) ' Render the HTML as a PDF
pdf.SaveAs("output.pdf") ' Save the PDF document
End Sub
End Class
End Namespace
Der IronPDF-Code kann nur mit einer Testlizenz ausgeführt werden, die von der IronPDF-Testlizenzseite bezogen wird. Geben Sie eine E-Mail-ID im Pop-up an, um einen Lizenzschlüssel zu generieren, und liefern Sie diesen Schlüssel an Ihre E-Mail.
"IronPdf.LicenseKey": "<YourKey>"Platzieren Sie den Lizenzschlüssel in der Datei AppSettings.json.
C#-Lambda-Ausdrücke bieten eine prägnante und ausdrucksstarke Möglichkeit, Inline-Funktionen zu definieren, was den Code lesbarer, wartbarer und effizienter macht. Sie finden Anwendungen in verschiedenen Bereichen, einschließlich LINQ-Abfragen, Ereignisbehandlung, asynchronem Programmieren und funktionaler Programmierung.
Durch das Meistern von Lambda-Ausdrücken können Entwickler neue Dimensionen der Produktivität und Eleganz in ihren C#-Codebasen erschließen.
Ob Sie ein erfahrener C#-Entwickler sind oder gerade erst mit Ihrer Reise beginnen, das Verstehen und Nutzen der Leistungsfähigkeit von Lambda-Ausdrücken wird zweifellos Ihre Programmierfähigkeiten auf neue Höhen heben.
Also tauchen Sie ein, experimentieren Sie und genießen Sie die Schönheit von Lambda-Ausdrücken in Ihren C#-Projekten!
Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO Cameron Rimington in ein Unternehmen mit mehr als 50 Mitarbeitern verwandelt, das die NASA, Tesla und globale Regierungsbehörden beliefert.
IronPDF ist ein Teil der IRONSUITE
10 .NET-API-Produkte für Ihre Bürodokumente
Wenn Ihr PDF wie HTML aussehen soll, schnell.
