C# Action (Wie es für Entwickler funktioniert)

In diesem Tutorial werden die Konzepte C# Action, Func delegate und verwandte Themen behandelt. Dieser Leitfaden richtet sich an Anfänger und führt Sie durch die Grundlagen, liefert Beispiele und erklärt die wichtigsten Begriffe der aktionsdelegierter.

Beginnen wir damit, zu verstehen, was Delegates in C# sind. Wir werden erforschen IronPDF weiter unten in dem Artikel.

Das Verständnis von Delegaten in C#;

Delegate sind ein Programmierkonstrukt, das als Verweis auf Methoden fungiert, die durch einen bestimmten Satz von Parametern und einen Rückgabetyp definiert sind, und das Funktionalitäten wie vordefinierte Delegatstypen kapselt und es Methoden ermöglicht, Werte zurückzugeben.

Sie erlaubt die Übergabe von Methoden als Argumente. Im Wesentlichen dient ein Delegat als Funktionszeiger, der auf die Methode verweist, die er darstellt. In C# gibt es zwei vordefinierte Delegatentypen, die häufig verwendet werden: Func und Action.

Was ist ein Func-Delegierter?

Der Func-Delegat stellt eine Methode dar, die einen Rückgabewert haben kann. Der letzte Typparameter gibt den Rückgabetyp an, und die vorangehenden Typen geben die Eingabeparameter an.

Eine Func<int, int, string> nimmt zum Beispiel zwei Integer-Parameter entgegen und gibt eine String-Nachricht zurück.

Delegierte in der Praxis: Beispiele

Schauen wir uns einige Beispiele an, um zu verstehen, wie Func- und Action-Delegierte in C# funktionieren.

Beispiel für einen Aktionsdelegierten

Ein Aktionsdelegat, ein vordefinierter Delegattyp, wird verwendet, wenn Sie eine Methode ausführen möchten, die keinen Wert zurückgibt und sich stattdessen auf Operationen konzentriert. Hier ist ein einfaches Beispiel:

Action<string> display = message => Console.WriteLine(message);
display("Hello, World!");

Action<string> display = message => Console.WriteLine(message);
display("Hello, World!");

Dim display As Action(Of String) = Sub(message) Console.WriteLine(message)
display("Hello, World!")

Dieser Code definiert einen Action-Delegaten, der die Verwendung einer anonymen Methode veranschaulicht, die einen einzelnen String-Parameter annimmt und ihn auf der Konsole ausgibt. Das =>-Symbol wird zur Definition eines Lambda-Ausdrucks verwendet, mit dem anonyme Methoden in knapper Form geschrieben werden können.

Beispiel für einen Func-Delegaten

Ein Func-Delegierter, der einen Wert zurückgibt, kann wie folgt verwendet werden:

Func<int, int, int> add = (x, y) => x + y;
int result = add(5, 3);
Console.WriteLine(result);

Func<int, int, int> add = (x, y) => x + y;
int result = add(5, 3);
Console.WriteLine(result);

Dim add As Func(Of Integer, Integer, Integer) = Function(x, y) x + y
Dim result As Integer = add(5, 3)
Console.WriteLine(result)

In diesem Beispiel wird ein Func-Delegat erstellt, der zwei ganzzahlige Parameter annimmt und deren Summe zurückgibt. Die Summe wird auf der Konsole wie folgt angezeigt:

Wichtige Konzepte

Anonyme Methoden

Anonyme Methoden in C# bieten eine Möglichkeit, Inline-Methoden ohne Namen zu definieren. Sie werden häufig zusammen mit Delegaten verwendet, um Delegateninstanzen direkt zu erstellen.

Lambda-Ausdrücke

Lambda-Ausdrücke sind eine Kurzform für das Schreiben anonymer Methoden. Sie ermöglichen es Ihnen, weniger Code zu schreiben und dennoch das gleiche Ergebnis zu erzielen.

Generischer Delegierter

Ein generischer Delegat kann mit jedem Datentyp arbeiten. Func und Action sind Beispiele für generische Delegierte, die mehr Flexibilität bieten, indem sie es Ihnen ermöglichen, Eingabe- und Ausgabetypen zur Laufzeit anzugeben.

Delegierte Instanz

Eine Delegateninstanz wird mit dem Schlüsselwort new oder durch einfache Zuweisung einer Methode, die der Signatur des Delegaten entspricht, erstellt.

System-Namensraum

Der Namensraum System in .NET enthält eingebaute Typen wie Func und Action, die Teil der Basisklassenbibliothek sind.

Asynchrone Programmierung mit Delegaten

Delegates, einschließlich Action und Func, sind für die Verwaltung asynchroner Aufgaben in C# unerlässlich. Sie ermöglichen es Entwicklern, einen Verweis auf eine Methode zu kapseln, die dann asynchron ausgeführt werden kann. Das bedeutet, dass der Hauptanwendungsthread eine Aufgabe initiieren und dann mit anderen Arbeiten fortfahren kann, bis die Aufgabe abgeschlossen ist.

Zu diesem Zeitpunkt wird eine Callback-Methode aufgerufen, die von einem Delegaten referenziert wird, um das Ergebnis zu verarbeiten. Dieses Muster ist entscheidend für die Erstellung von reaktionsfähigen Benutzeroberflächen, die auch bei langwierigen Vorgängen interaktiv bleiben.

Beispiel: Asynchrone Dateiverarbeitung

Nehmen wir eine Anwendung, die eine große Datei verarbeiten muss. Die Verwendung eines Action-Delegaten in Verbindung mit asynchronen Programmiermustern wie Task kann die Anwendungsleistung erheblich verbessern:

public async Task ProcessFileAsync(string filePath, Action<string> onComplete)
{
    // Asynchronously read file content
    string fileContent = await File.ReadAllTextAsync(filePath);
    // Process the file content here (omitted for brevity)
    // Once processing is complete, invoke the onComplete callback
    onComplete?.Invoke("File processing completed successfully.");
}

public async Task ProcessFileAsync(string filePath, Action<string> onComplete)
{
    // Asynchronously read file content
    string fileContent = await File.ReadAllTextAsync(filePath);
    // Process the file content here (omitted for brevity)
    // Once processing is complete, invoke the onComplete callback
    onComplete?.Invoke("File processing completed successfully.");
}

Public Async Function ProcessFileAsync(ByVal filePath As String, ByVal onComplete As Action(Of String)) As Task
	' Asynchronously read file content
	Dim fileContent As String = Await File.ReadAllTextAsync(filePath)
	' Process the file content here (omitted for brevity)
	' Once processing is complete, invoke the onComplete callback
	If onComplete IsNot Nothing Then
		onComplete.Invoke("File processing completed successfully.")
	End If
End Function

In diesem Beispiel wird File.ReadAllTextAsync verwendet, um den Inhalt der Datei zu lesen, ohne den Hauptthread zu blockieren. Sobald die Datei verarbeitet ist, wird ein Action-Delegat mit dem Namen onComplete aufgerufen, um dem Aufrufer mitzuteilen, dass der Vorgang abgeschlossen ist, so dass weitere Aktionen wie die Aktualisierung der Benutzeroberfläche oder die Protokollierung der Ergebnisse möglich sind.

Einführung von IronPDF: Eine C# PDF-Bibliothek

IronPDF ist eine umfassende C#-PDF-Bibliothek für .NET-Entwickler, mit der sich PDF-Dateien mühelos erstellen, bearbeiten und manipulieren lassen. Es zeichnet sich durch eine Chrome-basierte Rendering-Engine aus, die Folgendes gewährleistet pixelgenaue PDFs aus HTML, CSS, JavaScript und Bilder.

IronPDF ist mit einer Vielzahl von .NET-Frameworks und -Umgebungen kompatibel, einschließlich .NET-Standard, .NET-Framework und .NET Core, auf allen Windows-, Linux- und macOS-Plattformen.

Installation von IronPDF

Um IronPDF in Ihre .NET-Projekte einzubinden, können Sie NuGet verwenden, was die einfachste Methode ist. Öffnen Sie einfach die Paketmanager-Konsole in Visual Studio und führen Sie den folgenden Befehl aus:

Install-Package IronPdf

Dieser Befehl holt und installiert das IronPDF-Paket und richtet Ihr Projekt so ein, dass es IronPDF für die PDF-Erzeugung und -Bearbeitung verwenden kann.

Codebeispiel mit Aktionsdelegat

Hier ist ein einfaches Beispiel, das zeigt, wie IronPDF in Verbindung mit einem Action-Delegaten verwendet werden kann, um eine PDF-Generierungsaufgabe durchzuführen:

using IronPdf;
using System;
class Program
{
    static void Main(string [] args)
    {
        var renderer = new ChromePdfRenderer();
        Action<string> generatePdf = html =>
        {
            var pdf = renderer.RenderHtmlAsPdf(html);
            pdf.SaveAs("example.pdf");
        };
        generatePdf("<p>Hello, world!</p>");
        Console.WriteLine("PDF generated successfully.");
    }
}

using IronPdf;
using System;
class Program
{
    static void Main(string [] args)
    {
        var renderer = new ChromePdfRenderer();
        Action<string> generatePdf = html =>
        {
            var pdf = renderer.RenderHtmlAsPdf(html);
            pdf.SaveAs("example.pdf");
        };
        generatePdf("<p>Hello, world!</p>");
        Console.WriteLine("PDF generated successfully.");
    }
}

Imports IronPdf
Imports System
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()
		Dim generatePdf As Action(Of String) = Sub(html)
			Dim pdf = renderer.RenderHtmlAsPdf(html)
			pdf.SaveAs("example.pdf")
		End Sub
		generatePdf("<p>Hello, world!</p>")
		Console.WriteLine("PDF generated successfully.")
	End Sub
End Class

In diesem Beispiel wird ein Aktionsdelegat definiert, der eine HTML-Zeichenfolge aufnimmt und sie mit IronPDF in ein PDF-Dokument umwandelt.

Das erzeugte PDF wird dann im Dateisystem gespeichert. Dieser Ansatz zeigt, wie Delegates verwendet werden können, um die Logik der PDF-Generierung zu kapseln und den Code modularer und flexibler zu gestalten.

Lizenzvergabe

IronPDF bietet verschiedene lizenzierungsoptionenvon individuellen Entwicklerlizenzen bis hin zu Unternehmensverträgen. Die Preise für diese Lizenzen beginnen bei $749.

Schlussfolgerung

Inzwischen sollten Sie ein grundlegendes Verständnis von Action- und Func-Delegaten in C# haben und wissen, wie man anonyme Methoden und Lambda-Ausdrücke verwendet. Denken Sie daran, dass Übung der Schlüssel zur Beherrschung von Delegierungskonzepten ist. Versuchen Sie, Ihre eigenen Beispiele für die Definition, Zuweisung und den Aufruf von Delegaten zu erstellen.

Sie können die Möglichkeiten von IronPDF frei erkunden, indem Sie die kostenloser Test. Sollte es Ihren Projektanforderungen entsprechen, können Sie sich eine Lizenz zu Preisen ab $749 sichern.