Wie kann ich HTML in PDF in C# konvertieren?

Sie können die RenderHtmlAsPdf -Methode von IronPDF verwenden, um HTML-Strings in PDFs zu konvertieren. Sie können auch HTML-Dateien mit RenderHtmlFileAsPdf in PDFs konvertieren.

Warum ist ereignisgesteuerte Programmierung in .NET-Anwendungen wichtig?

Ereignisgesteuerte Programmierung ist in .NET-Anwendungen entscheidend, um die Reaktionsfähigkeit zu verbessern und reibungslose Benutzererfahrungen zu gewährleisten, indem Aufgaben asynchron ohne Blockierung des Hauptthreads ausgeführt werden können.

Wie installiert man das notwendige PDF-Erstellungstool in einem .NET-Projekt?

Sie können IronPDF über NuGet installieren, indem Sie den Befehl 'Install-Package IronPDF' in der Paket-Manager-Konsole von Visual Studio ausführen.

Wie deklariert man ein Ereignis in C#?

In C# werden Ereignisse mit dem Schlüsselwort 'event' deklariert, oft mit einem Delegatentyp wie 'EventHandler'. Zum Beispiel: public event EventHandler PdfGenerated; .

Was ist ein Delegat in der C#-Ereignisbehandlung?

Ein Delegat in C# ist ein typsicherer Funktionszeiger, der es ermöglicht, Methoden zu definieren, die als Reaktion auf ein Ereignis aufgerufen werden können.

Wie kann man Methoden zu Ereignissen in C# hinzufügen?

Sie können Methoden zu Ereignissen in C# dynamisch zur Laufzeit mit der '+=' Syntax hinzufügen, um sich bei Ereignissen anzumelden.

Was ist der Zweck einer benutzerdefinierten EventArgs-Klasse?

Eine benutzerdefinierte EventArgs-Klasse wird verwendet, um ereignisspezifische Daten, wie z. B. einen Dateipfad, in einer strukturierten und typensicheren Weise an Ereignishandler zu übergeben.

Warum sollte man einen BackgroundWorker für die Erstellung großer PDFs verwenden?

Der Einsatz eines BackgroundWorkers ermöglicht es, PDF-Erstellungsaufgaben asynchron auszuführen, wodurch das Blockieren der Benutzeroberfläche verhindert und die Benutzererfahrung verbessert wird.

Was sind einige Tipps zum Arbeiten mit Ereignissen in .NET?

Wichtige Tipps sind, das Blockieren des UI-Threads zu vermeiden, indem die UI erst nach Abschluss von Hintergrundaufgaben aktualisiert wird, Ausnahmen elegant zu behandeln und sich von Ereignissen abzumelden, wenn sie nicht mehr benötigt werden, um Speicherlecks zu verhindern.

Was sind Alternativen zur Verwendung von Ereignishandlern in .NET?

Alternativen sind die Verwendung von async/await und Task.Run für neuere Workflows sowie IProgress für Echtzeit-Updates während langer Vorgänge.

Die C# PDF-Bibliothek

Explore IronPDF Gratis testen

HTML zu PDF

Online Demo Alle Codebeispiele anzeigen

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >

Install-Package IronPdf

ENTWICKLER-UPDATES

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

Jacob Mellor

Updated: 21. April 2026

In modernen .NET-Anwendungen spielt ereignisgesteuertes Programmieren eine wichtige Rolle bei der Verbesserung der Reaktionsfähigkeit und der Sicherstellung reibungsloser Benutzererfahrungen. Wenn Aufgaben wie die PDF-Erzeugung Zeit in Anspruch nehmen, sollten Sie den Haupt-Thread nicht blockieren. Stattdessen können Sie Ereignishandler verwenden, um Aufgaben asynchron auszuführen und zu reagieren, sobald ein Ereignis eintritt – was Ihre Anwendung interaktiver und reaktionsschneller macht.

In diesem Leitfaden zeigen wir Ihnen, wie Sie C#-Ereignisbehandlungsmethoden mit IronPDF für nahtlose PDF-Workflows in Desktop- und Webumgebungen integrieren können. Egal, ob Sie WinForms, WPF oder eine andere auf der C#-Programmiersprache basierende Plattform verwenden, dieser Leitfaden hat alles, was Sie brauchen.

Einrichten Ihres IronPDF-Projekts

Bevor wir uns mit der Ereignisbehandlung beschäftigen, richten wir IronPDF schnell in Ihrem .NET-Projekt ein.

IronPDF über NuGet installieren

Führen Sie in der Paket-Manager-Konsole von Visual Studio Folgendes aus:

PM > Install-Package IronPdf

Install-Package IronPdf

Dadurch wird alles installiert, was Sie benötigen, um mit der PDF-Erzeugung mit IronPDF zu beginnen.

Grundlegende PDF-Erzeugung mit IronPDF

Hier ist ein kurzes Beispiel, um sicherzustellen, dass IronPDF funktioniert:

using IronPdf;
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello from IronPDF!</h1>");
pdf.SaveAs("example.pdf");

using IronPdf;
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello from IronPDF!</h1>");
pdf.SaveAs("example.pdf");

Imports IronPdf
Private renderer = New ChromePdfRenderer()
Private pdf = renderer.RenderHtmlAsPdf("<h1>Hello from IronPDF!</h1>")
pdf.SaveAs("example.pdf")

Imports IronPdf
Private renderer = New ChromePdfRenderer()
Private pdf = renderer.RenderHtmlAsPdf("<h1>Hello from IronPDF!</h1>")
pdf.SaveAs("example.pdf")

Sobald dies funktioniert, sind Sie bereit, Ereignisfelder hinzuzufügen, registrierte Delegaten anzuschließen und Delegattypen zu verwenden, um ereignisgesteuerte Workflows zu erstellen.

Grundlagen von C# Event Handlern for .NET Entwickler

Grundlagen der ereignisgesteuerten Programmierung

Beim ereignisgesteuerten Programmieren reagiert Ihre App, wenn ein Ereignis eintritt, beispielsweise das Abschließen der PDF-Erzeugung. C# verwendet Delegaten als typsichere Funktionszeiger, mit denen Sie definieren können, wie Ihre App reagieren soll.

Normalerweise deklarieren Sie Ereignisse mit dem Schlüsselwort 'event', verbinden sie mit Ereignisbehandlungsmethoden und übergeben Daten mithilfe benutzerdefinierter EventArgs-Subklassen.

Ereignis mit dem Schlüsselwort event deklarieren

C# nutzt das Schlüsselwort 'event' zur Deklaration von Ereignismitgliedern. Zum Beispiel:

public event EventHandler PdfGenerated;

public event EventHandler PdfGenerated;

Public Event PdfGenerated As EventHandler

Public Event PdfGenerated As EventHandler

Diese Zeile deklariert ein Ereignisfeld namens PdfGenerated. Es verwendet EventHandler, einen eingebauten Delegaten mit der folgenden Parameterliste: (object sender, EventArgs e) – oft als Namensmuster für Ereignisse in .NET bezeichnet.

Definieren und Abonnieren von Ereignissen in C#

Methoden zu Ereignissen hinzufügen mit Delegaten

C#-Ereignisse unterstützen das dynamische Hinzufügen von Methoden zur Laufzeit mit der +=-Syntax. So geht's:

pdfService.PdfGenerated += (s, e) =>
{
    Console.WriteLine("PDF was generated!");
};

pdfService.PdfGenerated += (s, e) =>
{
    Console.WriteLine("PDF was generated!");
};

AddHandler pdfService.PdfGenerated, Sub(s, e)
	Console.WriteLine("PDF was generated!")
End Sub

AddHandler pdfService.PdfGenerated, Sub(s, e)
	Console.WriteLine("PDF was generated!")
End Sub

Diese Abonnentenklasse hört auf das PdfGenerated-Ereignis und führt einen Methodenaufruf aus, wenn es ausgelöst wird.

Benutzerdefinierte Ereignisdaten

Um Ereignisdaten wie den generierten Dateipfad zu übergeben, definieren Sie eine abgeleitete Klasse von EventArgs:

public class PdfGeneratedEventArgs : EventArgs
{
    public string FilePath { get; set; } // returned value
}

public class PdfGeneratedEventArgs : EventArgs
{
    public string FilePath { get; set; } // returned value
}

Public Class PdfGeneratedEventArgs
	Inherits EventArgs

	Public Property FilePath() As String ' -  returned value
End Class

Public Class PdfGeneratedEventArgs
	Inherits EventArgs

	Public Property FilePath() As String ' -  returned value
End Class

Definieren Sie das Ereignis anschließend mithilfe eines generischen Delegatentyps neu:

public event EventHandler<PdfGeneratedEventArgs> PdfGenerated;

public event EventHandler<PdfGeneratedEventArgs> PdfGenerated;

Public Event PdfGenerated As EventHandler(Of PdfGeneratedEventArgs)

Public Event PdfGenerated As EventHandler(Of PdfGeneratedEventArgs)

Dadurch erhalten Sie strukturierte, typsichere Daten, wenn das Ereignis ausgelöst wird, wodurch Ihre Reaktionslogik leistungsfähiger wird.

Behandlung mehrerer Ereignisse

Sie können mehrere Ereignisse definieren:

public event EventHandler PdfGenerationStarted;
public event EventHandler<PdfGeneratedEventArgs> PdfGenerationCompleted;

public event EventHandler PdfGenerationStarted;
public event EventHandler<PdfGeneratedEventArgs> PdfGenerationCompleted;

Public Event PdfGenerationStarted As EventHandler
Public Event PdfGenerationCompleted As EventHandler(Of PdfGeneratedEventArgs)

Public Event PdfGenerationStarted As EventHandler
Public Event PdfGenerationCompleted As EventHandler(Of PdfGeneratedEventArgs)

Jedes Ereignisfeld wird von einer Abonnentenklasse behandelt, sodass bei jedem Schritt unterschiedliche Ereignisbehandlungsmethoden ermöglicht werden. Diese Trennung der Verantwortlichkeiten macht in komplexen Workflows Sinn.

Verwendung von Event-Handlern mit IronPDF

Beim Erzeugen großer PDFs empfiehlt es sich, IronPDF in einem Hintergrund-Thread laufen zu lassen und die UI zu benachrichtigen. So kann Ihnen das ereignisgesteuerte Design helfen:

Verwenden Sie einen BackgroundWorker, um PDFs asynchron zu erstellen
Lösen Sie Ereignisse aus, wenn jede Phase abgeschlossen ist
Übergeben Sie Ergebnisdaten mithilfe von Ereignisdaten-Objekten

Codebeispiel - PDFs asynchron generieren

Das folgende Beispiel zeigt den vollständigen Code für die Verwendung der Ereignisbehandlung mit IronPDF:

using System;
using System.ComponentModel;
using IronPdf;
namespace IronPdfEventHandlerExample
{
    // 1. Define custom EventArgs to carry event data
    public class PdfGeneratedEventArgs : EventArgs
    {
        public string FilePath { get; set; }
    }
    // 2. Main class with event, BackgroundWorker, and logic
    public class PdfGenerator
    {
        // Declare the public event using EventHandler<t>
        public event EventHandler<PdfGeneratedEventArgs> PdfGenerated;
        private readonly BackgroundWorker _worker;
        public PdfGenerator()
        {
            _worker = new BackgroundWorker();
            _worker.DoWork += OnDoWork;
            _worker.RunWorkerCompleted += OnRunWorkerCompleted;
        }
        // Start the async operation
        public void GenerateAsync(string html, string outputPath)
        {
            _worker.RunWorkerAsync(new Tuple<string, string>(html, outputPath));
        }
        // Perform PDF generation in background
        private void OnDoWork(object sender, DoWorkEventArgs e)
        {
            var (html, path) = (Tuple<string, string>)e.Argument;
            var renderer = new HtmlToPdf();
            var pdf = renderer.RenderHtmlAsPdf(html);
            pdf.SaveAs(path);
            e.Result = path;
        }
        // Notify subscribers when the PDF is ready
        private void OnRunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            var path = e.Result as string;
            PdfGenerated?.Invoke(this, new PdfGeneratedEventArgs { FilePath = path });
        }
    }
    // 3. Program to wire it all together
    class Program
    {
        public static void Main(string[] args)
        {
            var generator = new PdfGenerator();
            // Subscribe to the PdfGenerated event
            generator.PdfGenerated += OnPdfGenerated;
            Console.WriteLine("Generating PDF asynchronously...");
            generator.GenerateAsync("<h1>Hello, IronPDF!</h1>", "output.pdf");
            Console.WriteLine("Press any key to exit after generation.");
            Console.ReadKey();
        }
        // Event handler for when the PDF is ready
        static void OnPdfGenerated(object sender, PdfGeneratedEventArgs e)
        {
            Console.WriteLine($"PDF generated at: {e.FilePath}");
        }
    }
}

using System;
using System.ComponentModel;
using IronPdf;
namespace IronPdfEventHandlerExample
{
    // 1. Define custom EventArgs to carry event data
    public class PdfGeneratedEventArgs : EventArgs
    {
        public string FilePath { get; set; }
    }
    // 2. Main class with event, BackgroundWorker, and logic
    public class PdfGenerator
    {
        // Declare the public event using EventHandler<t>
        public event EventHandler<PdfGeneratedEventArgs> PdfGenerated;
        private readonly BackgroundWorker _worker;
        public PdfGenerator()
        {
            _worker = new BackgroundWorker();
            _worker.DoWork += OnDoWork;
            _worker.RunWorkerCompleted += OnRunWorkerCompleted;
        }
        // Start the async operation
        public void GenerateAsync(string html, string outputPath)
        {
            _worker.RunWorkerAsync(new Tuple<string, string>(html, outputPath));
        }
        // Perform PDF generation in background
        private void OnDoWork(object sender, DoWorkEventArgs e)
        {
            var (html, path) = (Tuple<string, string>)e.Argument;
            var renderer = new HtmlToPdf();
            var pdf = renderer.RenderHtmlAsPdf(html);
            pdf.SaveAs(path);
            e.Result = path;
        }
        // Notify subscribers when the PDF is ready
        private void OnRunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            var path = e.Result as string;
            PdfGenerated?.Invoke(this, new PdfGeneratedEventArgs { FilePath = path });
        }
    }
    // 3. Program to wire it all together
    class Program
    {
        public static void Main(string[] args)
        {
            var generator = new PdfGenerator();
            // Subscribe to the PdfGenerated event
            generator.PdfGenerated += OnPdfGenerated;
            Console.WriteLine("Generating PDF asynchronously...");
            generator.GenerateAsync("<h1>Hello, IronPDF!</h1>", "output.pdf");
            Console.WriteLine("Press any key to exit after generation.");
            Console.ReadKey();
        }
        // Event handler for when the PDF is ready
        static void OnPdfGenerated(object sender, PdfGeneratedEventArgs e)
        {
            Console.WriteLine($"PDF generated at: {e.FilePath}");
        }
    }
}

Imports System
Imports System.ComponentModel
Imports IronPdf

Namespace IronPdfEventHandlerExample

    ' 1. Define custom EventArgs to carry event data
    Public Class PdfGeneratedEventArgs
        Inherits EventArgs

        Public Property FilePath As String
    End Class

    ' 2. Main class with event, BackgroundWorker, and logic
    Public Class PdfGenerator

        ' Declare the public event using EventHandler(Of T)
        Public Event PdfGenerated As EventHandler(Of PdfGeneratedEventArgs)
        Private ReadOnly _worker As BackgroundWorker

        Public Sub New()
            _worker = New BackgroundWorker()
            AddHandler _worker.DoWork, AddressOf OnDoWork
            AddHandler _worker.RunWorkerCompleted, AddressOf OnRunWorkerCompleted
        End Sub

        ' Start the async operation
        Public Sub GenerateAsync(html As String, outputPath As String)
            _worker.RunWorkerAsync(Tuple.Create(html, outputPath))
        End Sub

        ' Perform PDF generation in background
        Private Sub OnDoWork(sender As Object, e As DoWorkEventArgs)
            Dim args = DirectCast(e.Argument, Tuple(Of String, String))
            Dim html = args.Item1
            Dim path = args.Item2
            Dim renderer = New HtmlToPdf()
            Dim pdf = renderer.RenderHtmlAsPdf(html)
            pdf.SaveAs(path)
            e.Result = path
        End Sub

        ' Notify subscribers when the PDF is ready
        Private Sub OnRunWorkerCompleted(sender As Object, e As RunWorkerCompletedEventArgs)
            Dim path = TryCast(e.Result, String)
            RaiseEvent PdfGenerated(Me, New PdfGeneratedEventArgs With {.FilePath = path})
        End Sub
    End Class

    ' 3. Program to wire it all together
    Module Program

        Sub Main(args As String())
            Dim generator = New PdfGenerator()
            ' Subscribe to the PdfGenerated event
            AddHandler generator.PdfGenerated, AddressOf OnPdfGenerated
            Console.WriteLine("Generating PDF asynchronously...")
            generator.GenerateAsync("<h1>Hello, IronPDF!</h1>", "output.pdf")
            Console.WriteLine("Press any key to exit after generation.")
            Console.ReadKey()
        End Sub

        ' Event handler for when the PDF is ready
        Private Sub OnPdfGenerated(sender As Object, e As PdfGeneratedEventArgs)
            Console.WriteLine($"PDF generated at: {e.FilePath}")
        End Sub
    End Module

End Namespace

Imports System
Imports System.ComponentModel
Imports IronPdf

Namespace IronPdfEventHandlerExample

    ' 1. Define custom EventArgs to carry event data
    Public Class PdfGeneratedEventArgs
        Inherits EventArgs

        Public Property FilePath As String
    End Class

    ' 2. Main class with event, BackgroundWorker, and logic
    Public Class PdfGenerator

        ' Declare the public event using EventHandler(Of T)
        Public Event PdfGenerated As EventHandler(Of PdfGeneratedEventArgs)
        Private ReadOnly _worker As BackgroundWorker

        Public Sub New()
            _worker = New BackgroundWorker()
            AddHandler _worker.DoWork, AddressOf OnDoWork
            AddHandler _worker.RunWorkerCompleted, AddressOf OnRunWorkerCompleted
        End Sub

        ' Start the async operation
        Public Sub GenerateAsync(html As String, outputPath As String)
            _worker.RunWorkerAsync(Tuple.Create(html, outputPath))
        End Sub

        ' Perform PDF generation in background
        Private Sub OnDoWork(sender As Object, e As DoWorkEventArgs)
            Dim args = DirectCast(e.Argument, Tuple(Of String, String))
            Dim html = args.Item1
            Dim path = args.Item2
            Dim renderer = New HtmlToPdf()
            Dim pdf = renderer.RenderHtmlAsPdf(html)
            pdf.SaveAs(path)
            e.Result = path
        End Sub

        ' Notify subscribers when the PDF is ready
        Private Sub OnRunWorkerCompleted(sender As Object, e As RunWorkerCompletedEventArgs)
            Dim path = TryCast(e.Result, String)
            RaiseEvent PdfGenerated(Me, New PdfGeneratedEventArgs With {.FilePath = path})
        End Sub
    End Class

    ' 3. Program to wire it all together
    Module Program

        Sub Main(args As String())
            Dim generator = New PdfGenerator()
            ' Subscribe to the PdfGenerated event
            AddHandler generator.PdfGenerated, AddressOf OnPdfGenerated
            Console.WriteLine("Generating PDF asynchronously...")
            generator.GenerateAsync("<h1>Hello, IronPDF!</h1>", "output.pdf")
            Console.WriteLine("Press any key to exit after generation.")
            Console.ReadKey()
        End Sub

        ' Event handler for when the PDF is ready
        Private Sub OnPdfGenerated(sender As Object, e As PdfGeneratedEventArgs)
            Console.WriteLine($"PDF generated at: {e.FilePath}")
        End Sub
    End Module

End Namespace

Konsolenausgabe

C#-Ereignishandler (Wie es für Entwickler funktioniert): Abbildung 1 - Konsolenausgabe

PDF-Ausgabe

C#-Ereignishandler (Wie es für Entwickler funktioniert): Abbildung 2 - PDF-Ausgabe

Wichtige Funktionen in diesem Code

public event EventHandler<PdfGeneratedEventArgs>: Deklariert ein stark typisiertes Ereignis
PdfGeneratedEventArgs: Benutzerdefinierte Klasse für Ereignisdaten
BackgroundWorker: Ermöglicht asynchrone Ausführung, um UI-Blockierung zu vermeiden
?.Invoke(...): Sichere Ereignisauslösung
Tuple<string, string>: Überträgt HTML und Ausgabepfad an den Hintergrundthread

Tipps für die Arbeit mit Ereignissen in .NET

1. Vermeiden Sie das Blockieren von UI-Threads

Verwenden Sie Ereignishandler wie RunWorkerCompleted, um UI-Updates nur nach Abschluss von Hintergrundaufgaben durchzuführen.

2. Ausnahmen angemessen behandeln

Umschließen Sie Ihre Arbeitslogik in try-catch-Blöcke innerhalb von DoWork und übergeben Sie Ausnahmen über e.Error an RunWorkerCompleted.

if (e.Error != null)
{
    MessageBox.Show("Error: " + e.Error.Message);
}

if (e.Error != null)
{
    MessageBox.Show("Error: " + e.Error.Message);
}

If e.Error IsNot Nothing Then
	MessageBox.Show("Error: " & e.Error.Message)
End If

If e.Error IsNot Nothing Then
	MessageBox.Show("Error: " & e.Error.Message)
End If

3. Bei Bedarf abbestellen

In lang laufenden Apps sollten Sie sich von Ereignissen abmelden, wenn sie nicht mehr benötigt werden, um Speicherlecks zu vermeiden:

pdfWorker.DoWork -= PdfWorker_DoWork;

pdfWorker.DoWork -= PdfWorker_DoWork;

pdfWorker.DoWork -= PdfWorker_DoWork

pdfWorker.DoWork -= PdfWorker_DoWork

Abschließende Gedanken

Die Verwendung von Ereignishandlern, Delegattypen und Ereignisfeldern mit IronPDF verleiht .NET-Anwendungen eine reaktionsfähige, moderne Note. Egal, ob Sie Dokumente in einer Basisklasse generieren, wiederverwendbare Logik in abgeleiteten Klassen erstellen oder einfach das Ereignismodell von .NET erkunden, dieses Muster ist skalierbar und sauber.

Wann sollte man diesen Ansatz verwenden

Sie möchten ein Ereignis auslösen, wenn eine Aufgabe abgeschlossen ist
Sie benötigen eine klare Trennung zwischen Logik und UI
Sie arbeiten mit BackgroundWorker, Ereignissen und Delegaten
Sie bevorzugen die typsichere Funktionszeiger Mechanik von C#

Alternativen zum Erforschen

async/await und Task.Run für neuere Arbeitsabläufe
IProgress<t> für Echtzeit-Updates während langer Operationen. IronPDF kombiniert mit C#-Ereignissen macht es einfach, leistungsstarke, reaktionsfähige PDF-erzeugende Apps mit praxisgerechter Nutzbarkeit zu erstellen. Bereit, die ereignisgesteuerte PDF-Erzeugung in Ihrer .NET-App zu implementieren? Probieren Sie es mit dem IronPDF free trial und halten Sie Ihre Benutzer mit reibungslosen, nicht blockierenden Erlebnissen glücklich!

Jacob Mellor

Jetzt mit dem Ingenieurteam chatten

Chief Technology Officer

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.

...