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

1. Verleger-Klasse

Die Herausgeberklasse ist die Quelle des Ereignisses. Sie ist verantwortlich für die Deklaration des Ereignisses und der Auslösung, wenn eine bestimmte Aktion oder Bedingung eintritt. Dieser Prozess beinhaltet typischerweise eine ereignishandhabende Methode, um festzustellen, wann das Ereignis auftritt. Der Herausgeber verwendet auch einen Ereignisdelegaten, um die Signatur der Methoden zu definieren, die das Ereignis behandeln können. Zum Beispiel agiert in einer grafischen Benutzeroberfläche (GUI) ein Schaltflächensteuerungselement als Herausgeber, wenn es ein "Klick"-Ereignis auslöst.

2. abonnierte Klasse

Die Abonnentenklasse hört auf Ereignisse und reagiert auf sie. Ein Abonnent registriert sein Interesse an einem Ereignis, indem er eine ereignishandhabende Methode an das Ereignis anhängt. Wenn der Herausgeber das Ereignis auslöst, wird die ereignishandhabende Methode des Abonnenten ausgeführt. Ein einzelnes Ereignis kann mehrere Abonnenten haben, die jeweils unterschiedlich reagieren, wenn das Ereignis eintritt.

3. delegiert

Delegaten sind das Fundament von Ereignissen in C#. Sie sind typsichere Zeiger auf Methoden und definieren den Vertrag, dem alle Ereignishandler folgen müssen. Delegaten stellen sicher, dass nur Methoden mit einer spezifischen Signatur das Ereignis behandeln können, und bieten so einen konsistenten und fehlerfreien Mechanismus zur Ereignisbehandlung.

4. ereignishandler

Ereignishandler sind Methoden in der Abonnentenklasse, die ausgeführt werden, wenn ein Ereignis ausgelöst wird. Sie enthalten die Logik zur Handhabung des Ereignisses, wie UI-Aktualisierung, Datenprotokollierung oder Berechnungen. Die Signatur eines Ereignishandlers muss dem Delegattyp entsprechen, der mit dem Ereignis verknüpft ist. Darüber hinaus können andere Klassen Ereignishandler verwenden, um auf gemeinsam genutzte Ereignisse zu reagieren. Es erleichtert die Implementierung von Ereignissen auf eine modulare und wiederverwendbare Weise.

5. Ereignisdaten

In vielen Fällen müssen Ereignisse zusätzliche Informationen an Abonnenten übermitteln. Dies wird durch Ereignisdatenklassen erreicht, die von der Basisklasse EventArgs abgeleitet sind. Die Ereignisdaten enthalten spezifische Details über das Ereignis, wie eine Nachricht, den Status oder andere relevante Informationen.

Schritt 1: Einen Delegaten deklarieren

Delegaten definieren die Methodensignatur für Ereignishandler. In diesem Beispiel erstellen wir einen Delegaten, um den Ereignishandler mit zwei Parametern zu repräsentieren: object sender und EventArgs e.

public delegate void MyEventHandler(object sender, EventArgs e);

public delegate void MyEventHandler(object sender, EventArgs e);

Public Delegate Sub MyEventHandler(ByVal sender As Object, ByVal e As EventArgs)

Schritt 2: Ein Ereignis deklarieren

Ereignisse werden mit dem event-Schlüsselwort deklariert und basieren auf dem Delegattyp. Hier ist ein Beispiel:

public class Publisher
{
    public event MyEventHandler Notify; // Declare the event.
}

public class Publisher
{
    public event MyEventHandler Notify; // Declare the event.
}

Public Class Publisher
	Public Event Notify As MyEventHandler ' Declare the event.
End Class

Schritt 3: Das Ereignis auslösen

Das Ereignis wird ausgelöst, indem der Delegat aufgerufen und die notwendigen Parameter übergeben werden.

public void TriggerEvent()
{
    if (Notify != null) // Check if there are subscribers.
    {
        Notify(this, EventArgs.Empty); // Raise the event.
    }
}

public void TriggerEvent()
{
    if (Notify != null) // Check if there are subscribers.
    {
        Notify(this, EventArgs.Empty); // Raise the event.
    }
}

Public Sub TriggerEvent()
	If Notify IsNot Nothing Then ' Check if there are subscribers.
		Notify(Me, EventArgs.Empty) ' Raise the event.
	End If
End Sub

Schritt 4: Abonnieren Sie die Veranstaltung

Abonnenten registrieren Ereignishandler mit dem Operator +=:

Publisher publisher = new Publisher();
Subscriber subscriber = new Subscriber();
publisher.Notify += subscriber.OnNotify; // Subscribe to the event.

Publisher publisher = new Publisher();
Subscriber subscriber = new Subscriber();
publisher.Notify += subscriber.OnNotify; // Subscribe to the event.

Dim publisher As New Publisher()
Dim subscriber As New Subscriber()
publisher.Notify += subscriber.OnNotify ' Subscribe to the event.

Schritt 5: Behandeln Sie das Ereignis

Ein Ereignishandler ist eine Methode in der Abonnentenklasse, die mit der Delegatsignatur übereinstimmt:

public void OnNotify(object sender, EventArgs e)
{
    Console.WriteLine("Event received!");
}

public void OnNotify(object sender, EventArgs e)
{
    Console.WriteLine("Event received!");
}

Public Sub OnNotify(ByVal sender As Object, ByVal e As EventArgs)
	Console.WriteLine("Event received!")
End Sub

Wie passt IronPDF dazu?

IronPDF ermöglicht das Erstellen, Bearbeiten und Sichern von PDFs, und die Integration mit Ereignissen kann Ihre Anwendung interaktiver machen. Zum Beispiel:

• Fortschrittsverfolgung: Benachrichtigen Sie Abonnenten über den Prozentsatz der Fertigstellung bei der Erstellung eines großen PDF-Berichts.
• Fehlerbehandlung: Lösen Sie ein Ereignis aus, wenn während der PDF-Darstellung oder -Speicherung ein Problem auftritt.
• Benutzerdefinierte Aktionen: Führen Sie benutzerdefinierte Logik wie Protokollierung oder UI-Aktualisierungen nach bestimmten PDF-Operationen aus.

Beispiel: Generierung einer PDF-Datei mit Ereignisbenachrichtigungen

Hier ist ein einfaches Beispiel, um die Verwendung von IronPDF mit Ereignissen zu demonstrieren:

using IronPdf;
using System;

// Program class
class Program
{
    // Define a custom event for progress updates
    public static event Action<int> ProgressUpdated;

    public static void Main()
    {
        License.LicenseKey = "License-Key";
        // Subscribe to the ProgressUpdated event
        ProgressUpdated += DisplayProgress;

        Console.WriteLine("Generating PDF...");
        GeneratePdf(); // Generate the PDF
    }

    // Method to generate PDF and trigger progress updates
    static void GeneratePdf()
    {
        try
        {
            var Renderer = new ChromePdfRenderer();
            for (int i = 0; i <= 100; i += 20)
            {
                // Simulate progress
                System.Threading.Thread.Sleep(500);
                ProgressUpdated?.Invoke(i); // Trigger event with progress value
            }
            // Generate a PDF
            var PdfDocument = Renderer.RenderHtmlAsPdf("<h1>Hello, IronPDF with Events!</h1>");
            PdfDocument.SaveAs("IronPDF/example.pdf");
            ProgressUpdated?.Invoke(100); // Final update
            Console.WriteLine("PDF generated successfully!");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }

    // Event handler to display progress
    static void DisplayProgress(int progress)
    {
        Console.WriteLine($"Progress: {progress}%");
    }
}

using IronPdf;
using System;

// Program class
class Program
{
    // Define a custom event for progress updates
    public static event Action<int> ProgressUpdated;

    public static void Main()
    {
        License.LicenseKey = "License-Key";
        // Subscribe to the ProgressUpdated event
        ProgressUpdated += DisplayProgress;

        Console.WriteLine("Generating PDF...");
        GeneratePdf(); // Generate the PDF
    }

    // Method to generate PDF and trigger progress updates
    static void GeneratePdf()
    {
        try
        {
            var Renderer = new ChromePdfRenderer();
            for (int i = 0; i <= 100; i += 20)
            {
                // Simulate progress
                System.Threading.Thread.Sleep(500);
                ProgressUpdated?.Invoke(i); // Trigger event with progress value
            }
            // Generate a PDF
            var PdfDocument = Renderer.RenderHtmlAsPdf("<h1>Hello, IronPDF with Events!</h1>");
            PdfDocument.SaveAs("IronPDF/example.pdf");
            ProgressUpdated?.Invoke(100); // Final update
            Console.WriteLine("PDF generated successfully!");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }

    // Event handler to display progress
    static void DisplayProgress(int progress)
    {
        Console.WriteLine($"Progress: {progress}%");
    }
}

Imports IronPdf
Imports System

' Program class
Friend Class Program
	' Define a custom event for progress updates
	Public Shared Event ProgressUpdated As Action(Of Integer)

	Public Shared Sub Main()
		License.LicenseKey = "License-Key"
		' Subscribe to the ProgressUpdated event
		AddHandler Me.ProgressUpdated, AddressOf DisplayProgress

		Console.WriteLine("Generating PDF...")
		GeneratePdf() ' Generate the PDF
	End Sub

	' Method to generate PDF and trigger progress updates
	Private Shared Sub GeneratePdf()
		Try
			Dim Renderer = New ChromePdfRenderer()
			For i As Integer = 0 To 100 Step 20
				' Simulate progress
				System.Threading.Thread.Sleep(500)
				RaiseEvent ProgressUpdated(i)
			Next i
			' Generate a PDF
			Dim PdfDocument = Renderer.RenderHtmlAsPdf("<h1>Hello, IronPDF with Events!</h1>")
			PdfDocument.SaveAs("IronPDF/example.pdf")
			RaiseEvent ProgressUpdated(100)
			Console.WriteLine("PDF generated successfully!")
		Catch ex As Exception
			Console.WriteLine($"Error: {ex.Message}")
		End Try
	End Sub

	' Event handler to display progress
	Private Shared Sub DisplayProgress(ByVal progress As Integer)
		Console.WriteLine($"Progress: {progress}%")
	End Sub
End Class