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

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

Delegate in C#35 verstehen

Delegaten sind eine Programmierstruktur, die als Referenzen auf Methoden wirkt, die durch eine bestimmte Menge von Parametern und einen Rückgabetyp definiert werden und Funktionen wie vordefinierte Delegattypen einkapseln, die es erlauben, Methoden Rückgabewerte zu erhalten.

Dies erlaubt es, Methoden als Argumente zu übergeben. Im Wesentlichen dient ein Delegat als Funktionszeiger, der auf die Methode zeigt, die er repräsentiert. In C# gibt es zwei vordefinierte Delegattypen, die weit verbreitet sind: Func und Action.

Was ist ein Func-Delegate?

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

Ein Beispiel ist ein Func<int, int, string>, der zwei Integer-Parameter nimmt und eine Zeichenfolgennachricht zurückgibt.

Delegate in der Praxis: Beispiele

Werfen wir einen Blick auf einige Beispiele, um zu verstehen, wie Func- und Action-Delegaten in C# funktionieren.

Beispiel für einen Aktionsdelegaten

Ein Action-Delegat, ein vordefinierter Delegattyp, wird verwendet, wenn Sie eine Methode ausführen möchten, die keinen spezifischen Rückgabewert zurückgibt, sondern 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!")

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

Dieser Code definiert einen Action-Delegat, der die Verwendung einer anonymen Methode veranschaulicht, die einen einzigen Zeichenfolgenparameter nimmt und ihn auf der Konsole ausgibt. Das =>-Symbol wird verwendet, um einen Lambda-Ausdruck zu definieren, der eine prägnante Art ist, 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)

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-Delegat, der zwei Integer-Parameter nimmt und deren Summe zurückgibt. Die Summe wird auf der Konsole wie folgt angezeigt:

Schlüsselkonzepte

Anonyme Methoden

Anonyme Methoden in C# bieten eine Möglichkeit, Inline-Methoden ohne Namen zu definieren. Sie werden oft mit Delegaten verwendet, um Delegatinstanzen direkt zu erstellen.

Lambda-Ausdrücke

Lambda-Ausdrücke sind eine Kurzform zum Schreiben anonymer Methoden. Sie ermöglichen es, weniger Code zu schreiben und dennoch dasselbe Ergebnis zu erzielen.

Generischer Delegat

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 Ihnen erlauben, Eingabe- und Ausgabetypen zur Laufzeit zu spezifizieren.

Instanz delegieren

Eine Delegatinstanz wird mit dem new-Schlüsselwort erstellt oder indem einfach eine Methode zugewiesen wird, die dem Signatur des Delegaten entspricht.

System-Namensraum

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

Asynchrone Programmierung mit Delegaten

Delegaten, einschließlich Action und Func, sind integraler Bestandteil der Verwaltung asynchroner Aufgaben in C#. Sie ermöglichen Entwicklern, eine Referenz auf eine Methode einzukapseln, die dann asynchron ausgeführt werden kann. Das bedeutet, dass der Hauptanwendungs-Thread eine Aufgabe initiieren und dann mit anderen Arbeiten fortfahren kann, bis die Aufgabe abgeschlossen ist.

Eine Callback-Methode, die durch einen Delegaten referenziert wird, verarbeitet das Ergebnis. Dieses Muster ist entscheidend für die Erstellung reaktionsfähiger Benutzeroberflächen, die auch bei Durchführung langlaufender Operationen 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(filePath As String, 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
    onComplete?.Invoke("File processing completed successfully.")
End Function

Public Async Function ProcessFileAsync(filePath As String, 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
    onComplete?.Invoke("File processing completed successfully.")
End Function

In diesem Beispiel wird File.ReadAllTextAsync verwendet, um den Dateiinhalt 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, was weitere Aktionen wie das Aktualisieren der Benutzeroberfläche oder das Protokollieren von Ergebnissen ermöglicht.

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

IronPDF ist eine umfassende C# PDF-Bibliothek, die für .NET-Entwickler entwickelt wurde, um PDF-Dateien einfach zu erstellen, zu bearbeiten und zu manipulieren. Es zeichnet sich durch eine Chrome-basierte Render-Engine aus und sorgt für pixelgenaue PDFs aus HTML-Inhalten, CSS, JavaScript und Bildern.

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

Installation von IronPDF

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

Install-Package IronPdf

Dieser Befehl ruft das IronPDF-Paket ab und installiert es und richtet Ihr Projekt ein, um mit der PDF-Erstellung und -Bearbeitung mit IronPDF zu beginnen.

Codebeispiel mit Action Delegate

Hier ist ein einfaches Beispiel, das zeigt, wie man IronPDF in Verbindung mit einem Action-Delegat verwendet, um eine PDF-Erstellung durchzuführen:

using IronPdf;
using System;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        
        // Define an Action delegate that takes HTML content as a string
        Action<string> generatePdf = html =>
        {
            // Render the HTML as a PDF
            var pdf = renderer.RenderHtmlAsPdf(html);
            
            // Save the PDF to a file
            pdf.SaveAs("example.pdf");
        };
        
        // Generate the PDF with the provided HTML
        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();
        
        // Define an Action delegate that takes HTML content as a string
        Action<string> generatePdf = html =>
        {
            // Render the HTML as a PDF
            var pdf = renderer.RenderHtmlAsPdf(html);
            
            // Save the PDF to a file
            pdf.SaveAs("example.pdf");
        };
        
        // Generate the PDF with the provided HTML
        generatePdf("<p>Hello, world!</p>");
        Console.WriteLine("PDF generated successfully.");
    }
}

Imports IronPdf
Imports System

Module Program
    Sub Main(args As String())
        Dim renderer = New ChromePdfRenderer()

        ' Define an Action delegate that takes HTML content as a string
        Dim generatePdf As Action(Of String) = Sub(html)
                                                   ' Render the HTML as a PDF
                                                   Dim pdf = renderer.RenderHtmlAsPdf(html)

                                                   ' Save the PDF to a file
                                                   pdf.SaveAs("example.pdf")
                                               End Sub

        ' Generate the PDF with the provided HTML
        generatePdf("<p>Hello, world!</p>")
        Console.WriteLine("PDF generated successfully.")
    End Sub
End Module

Imports IronPdf
Imports System

Module Program
    Sub Main(args As String())
        Dim renderer = New ChromePdfRenderer()

        ' Define an Action delegate that takes HTML content as a string
        Dim generatePdf As Action(Of String) = Sub(html)
                                                   ' Render the HTML as a PDF
                                                   Dim pdf = renderer.RenderHtmlAsPdf(html)

                                                   ' Save the PDF to a file
                                                   pdf.SaveAs("example.pdf")
                                               End Sub

        ' Generate the PDF with the provided HTML
        generatePdf("<p>Hello, world!</p>")
        Console.WriteLine("PDF generated successfully.")
    End Sub
End Module

Dieses Beispiel definiert einen Action-Delegat, der eine Zeichenfolge von HTML nimmt und IronPDF verwendet, um daraus ein PDF-Dokument zu rendern. Das generierte PDF wird dann im Dateisystem gespeichert. Dieser Ansatz zeigt, wie Delegaten verwendet werden können, um Logik für die PDF-Erstellung zu kapseln, was Ihren Code modularer und flexibler macht.

Lizenzierung

IronPDF bietet verschiedene Lizenzierungsoptionen für Entwickler, angefangen von Entwicklerlizenzen für Einzelpersonen bis hin zu Unternehmensvereinbarungen. Die Preise für diese Lizenzen beginnen bei $999.

Abschluss

Bis jetzt sollten Sie ein grundlegendes Verständnis von Action- und Func-Delegaten in C# sowie davon haben, wie man anonyme Methoden und Lambda-Ausdrücke verwendet. Übung ist der Schlüssel, um die Delegatenkonzepte zu beherrschen. Erstellen Sie Ihre eigenen Beispiele zum Definieren, Zuweisen und Ausführen von Delegaten.

Sie können die Funktionen von IronPDF mit seiner kostenlosen Testversion nach Belieben erkunden. Sollte es Ihren Projektanforderungen entsprechen, können Sie eine Lizenz sichern, wobei die Preise bei $999 beginnen.