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

In diesem Tutorial werden wir die Konzepte von C# Action, Func-Delegat und verwandte Themen vermitteln. Dieser Leitfaden ist für Anfänger konzipiert und führt Sie durch die Grundlagen, bietet Beispiele und erklärt die Schlüsselbegriffe des Action-Delegaten.

Beginnen wir damit, zu verstehen, was Delegates in C# sind. Wir werden die IronPDF-Bibliothek später im Artikel erkunden.

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 Delegattypen, die weit verbreitet sind: Func und Action.

Was ist ein Func-Delegierter?

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

Zum Beispiel nimmt ein Func<int, int, string> zwei Integer-Parameter entgegen und gibt eine Zeichenfolgennachricht zurück.

Delegierte in der Praxis: Beispiele

Schauen wir uns einige Beispiele an, um zu verstehen, wie Func- und Action-Delegaten 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 verwendet, um einen Lambda-Ausdruck zu definieren, der eine prägnante Möglichkeit bietet, anonyme Methoden zu schreiben.

Beispiel für einen Func-Delegaten

Ein Func-Delegat, 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)

Dieses Beispiel erstellt einen Func-Delegaten, der zwei Ganzzahlen als Parameter entgegennimmt 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 Delegaten, die mehr Flexibilität bieten, indem sie es ermöglichen, Eingabe- und Ausgabetypen zur Laufzeit anzugeben.

Delegierte Instanz

Eine Delegate-Instanz wird mit dem new-Schlüsselwort erstellt oder indem einfach eine Methode zugewiesen wird, die der Signatur des Delegates entspricht.

System-Namensraum

Der System-Namensraum 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 integrale Bestandteile bei der Verwaltung asynchroner Aufgaben in C#. 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

Betrachten Sie 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 Dateiinhalte zu lesen, ohne den Hauptthread zu blockieren. Sobald die Datei verarbeitet ist, wird ein Action-Delegat namens onComplete aufgerufen, um den Anrufer darüber zu informieren, dass der Vorgang abgeschlossen ist, sodass weitere Aktionen wie das Aktualisieren der UI oder das Protokollieren von Ergebnissen durchgeführt werden können.

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

IronPDF ist eine umfassende C# PDF-Bibliothek, die für .NET-Entwickler entwickelt wurde, um PDF-Dateien mühelos zu erstellen, zu bearbeiten und zu bearbeiten. Es zeichnet sich durch eine auf Chrome basierende Rendering-Engine aus, die pixelgenaue PDFs aus HTML-Inhalten, CSS, JavaScript und Bildern gewährleistet.

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 Lizenzierungsoptionen für Entwickler an, die von Einzellizenzen für Entwickler bis hin zu Unternehmensvereinbarungen reichen. Die Preise für diese Lizenzen beginnen bei $749.

Schlussfolgerung

Inzwischen sollten Sie ein grundlegendes Verständnis für Action und Func Delegaten in C# haben, zusammen mit dem 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 Fähigkeiten von IronPDF mit der kostenlosen Testversion frei erkunden. Falls es den Anforderungen Ihres Projekts entspricht, können Sie eine Lizenz mit Preisen ab $749 sichern.