Die C# PDF-Bibliothek

HTML zu 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");

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

Install-Package IronPdf

VIDEOS

Wie man PDF-Dateien mit Passwörtern und Berechtigungen in C# schützt

Curtis Chau

Updated: 19. Juli 2026

Die Migration von Gotenbergzu IronPDF verwandelt Ihren .NET-PDF-Workflow von einer Docker-basierten Microservice-Architektur mit HTTP-API-Aufrufen in eine prozessinterne native C#-Bibliothek. Dieses Handbuch bietet einen umfassenden, schrittweisen Migrationspfad, der den Infrastruktur-Overhead, die Netzwerklatenz und die Komplexität der Container-Verwaltung für professionelle .NET-Entwickler eliminiert.

Warum von Gotenbergzu IronPDF migrieren

Das GotenbergArchitektur Problem

Gotenberg ist eine Docker-basierte Microservice-Architektur für die PDF-Erzeugung. Obwohl es leistungsstark und flexibel ist, führt es zu einer erheblichen Komplexität für C#-Anwendungen:

Infrastrukturaufwand: Erfordert Docker, Container-Orchestrierung (Kubernetes/Docker Compose), Service Discovery und Load Balancing. Jeder Einsatz wird komplexer.
Netzwerklatenz: Jeder PDF-Vorgang erfordert einen HTTP-Aufruf an einen separaten Dienst – was pro Anfrage 10–100 ms und mehr zusätzlich verursacht. Diese Latenz summiert sich bei hohem Datenaufkommen schnell.
Probleme beim Kaltstart: Der Containerstart kann die ersten Anfragen um 2-5 Sekunden verlängern. Jeder Pod-Neustart, jedes Scale-up-Ereignis und jede Bereitstellung löst Kaltstarts aus.
Operative Komplexität: Sie müssen Containerzustand, Skalierung, Protokollierung und Überwachung als separate Aufgaben von Ihrer Hauptanwendung verwalten.
Multipart-Formulardaten: Für jede Anfrage müssen multipart/form-data-Nutzdaten erstellt werden – ausführlich, fehleranfällig und mühsam zu pflegen.
Fehlerquellen: Netzwerk-Timeouts, Service-Nichtverfügbarkeit und Container-Abstürze fallen in Ihre Verantwortung.
Versionsverwaltung: Gotenberg-Images werden unabhängig von Ihrer Anwendung aktualisiert; API-Änderungen können Integrationen unerwartet unterbrechen.

Gotenbergvs IronPDF Vergleich

Aspekt	Gotenberg	IronPDF
Bereitstellung	Docker-Container + Orchestrierung	Einzelnes NuGet-Paket
Architektur	Microservice (REST API)	In Arbeit befindliche Bibliothek
Latenzzeit pro Anfrage	10-100ms+ (Netzwerk-Roundtrip)	< 1ms Overhead
Kaltstart	2-5 Sekunden (Container-Init)	1-2 Sekunden (nur erste Wiedergabe)
Infrastruktur	Docker, Kubernetes, Lastverteiler	Keine erforderlich
Misserfolgsmodi	Netzwerk, Container, Dienstausfälle	Standard .NET Ausnahmen
API-Stil	REST multipart/form-data	Native C#-Methodenaufrufe
Skalierung	Horizontal (mehr Container)	Vertikal (in Bearbeitung)
Fehlersuche	Verteiltes Tracing erforderlich	Standard-Debugger
Versionskontrolle	Container-Bild-Tags	NuGet-Paket-Versionen

Für Teams, die aktuelle .NET-Versionen anstreben, bietet IronPDF eine Grundlage ohne Infrastrukturabhängigkeiten, die sich nahtlos in moderne .NET-Muster integriert.

Migrationskomplexitätsbewertung

Geschätzter Aufwand nach Merkmalen

Feature	Komplexität der Migration
HTML zu PDF	Sehr niedrig
URL zu PDF	Sehr niedrig
Benutzerdefiniertes Papierformat	Niedrig
Margen	Niedrig
PDF-Zusammenführung	Niedrig
Kopf-/Fußzeilen	Medium
Warteschleifen	Niedrig
PDF/A-Konvertierung	Niedrig

Paradigmen-Verschiebung

Der grundlegende Shift bei dieser Gotenberger Migration besteht in der Umstellung von HTTP-API-Aufrufen mit Multipart-Formulardaten auf native C#-Methodenaufrufe:

Gotenberg:  HTTP POST multipart/form-data an Docker-Container
IronPDF:    Direkte Methodenaufrufe für C#-Objekte

Gotenberg:  HTTP POST multipart/form-data an Docker-Container
IronPDF:    Direkte Methodenaufrufe für C#-Objekte

Text

Bevor Sie beginnen

Voraussetzungen

**.NET Version:**IronPDF unterstützt .NET Framework 4.6.2+ und .NET Core 3.1+ / .NET 5/6/7/8/9+
Lizenzschlüssel: Ihren IronPDF-Lizenzschlüssel erhalten Sie unter IronPDF.
Infrastrukturentfernung planen: Gotenberg-Container für die Stilllegung nach der Migration dokumentieren.

Alle Gotenberg-Verwendung identifizieren

# Find direct HTTP calls to Gotenberg
grep -r "gotenberg\|/forms/chromium\|/forms/libreoffice\|/forms/pdfengines" --include="*.cs" .

# Find GotenbergSharpApiClient usage
grep -r "GotenbergSharpClient\|Gotenberg.Sharp\|ChromiumRequest" --include="*.cs" .

# Find Docker/Kubernetes Gotenbergconfiguration
grep -r "gotenberg/gotenberg\|gotenberg:" --include="*.yml" --include="*.yaml" .

# Find direct HTTP calls to Gotenberg
grep -r "gotenberg\|/forms/chromium\|/forms/libreoffice\|/forms/pdfengines" --include="*.cs" .

# Find GotenbergSharpApiClient usage
grep -r "GotenbergSharpClient\|Gotenberg.Sharp\|ChromiumRequest" --include="*.cs" .

# Find Docker/Kubernetes Gotenbergconfiguration
grep -r "gotenberg/gotenberg\|gotenberg:" --include="*.yml" --include="*.yaml" .

SHELL

NuGet-Paketänderungen

# Remove Gotenbergclient (if using)
dotnet remove package Gotenberg.Sharp.API.Client

# Install IronPDF
dotnet add package IronPdf

# Remove Gotenbergclient (if using)
dotnet remove package Gotenberg.Sharp.API.Client

# Install IronPDF
dotnet add package IronPdf

SHELL

Schnellstart Migration

Schritt 1: Lizenzkonfiguration aktualisieren

Vor (Gotenberg):

Gotenberg erfordert keine Lizenz, setzt aber eine Docker-Infrastruktur mit Container-URLs voraus.

private readonly string _gotenbergUrl = "http://localhost:3000";

private readonly string _gotenbergUrl = "http://localhost:3000";

Private ReadOnly _gotenbergUrl As String = "http://localhost:3000"

Private ReadOnly _gotenbergUrl As String = "http://localhost:3000"

Nach (IronPDF):

// Set once at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

// Set once at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

net

net

Schritt 2: Aktualisieren der Namensraum-Importe

// Before (Gotenberg)
using System.Net.Http;
using System.Threading.Tasks;
using System.IO;

// After (IronPDF)
using IronPdf;
using IronPdf.Rendering;

// Before (Gotenberg)
using System.Net.Http;
using System.Threading.Tasks;
using System.IO;

// After (IronPDF)
using IronPdf;
using IronPdf.Rendering;

Imports System.Net.Http
Imports System.Threading.Tasks
Imports System.IO

Imports IronPdf
Imports IronPdf.Rendering

Imports System.Net.Http
Imports System.Threading.Tasks
Imports System.IO

Imports IronPdf
Imports IronPdf.Rendering

Komplette API-Referenz

GotenbergEndpoint zu IronPDF Mapping

Gotenberg-Route	IronPDF-Äquivalent
`POST /forms/chromium/convert/html`	`ChromePdfRenderer.RenderHtmlAsPdf()`
`POST /forms/chromium/convert/url`	`ChromePdfRenderer.RenderUrlAsPdf()`
`POST /forms/pdfengines/merge`	`PdfDocument.Merge()`
`POST /forms/pdfengines/convert`	`pdf.SaveAs()` mit Einstellungen
`GET /health`	Nicht anwendbar

Zuordnung von Formularparametern zu RenderingOptions

GotenbergParameter	IronPDF Eigenschaft	Hinweise zur Konvertierung
`paperWidth` (Zoll)	`RenderingOptions.PaperSize`	Enum oder benutzerdefinierte Größe verwenden
`paperHeight` (Zoll)	`RenderingOptions.PaperSize`	Enum oder benutzerdefinierte Größe verwenden
`marginTop` (Zoll)	`RenderingOptions.MarginTop`	Multiplizieren Sie mit 25,4 für mm
`marginBottom` (Zoll)	`RenderingOptions.MarginBottom`	Multiplizieren Sie mit 25,4 für mm
`printBackground`	`RenderingOptions.PrintHtmlBackgrounds`	Boolesche
`landscape`	`RenderingOptions.PaperOrientation`	`Landscape` enum
`waitDelay` (z.B. `"3s"`)	`RenderingOptions.WaitFor.RenderDelay(ms)`	String in Millisekunden umwandeln

Beispiele für die Code-Migration

Beispiel 1: Grundlegendes HTML zu PDF

Vor (Gotenberg):

using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.IO;

class GotenbergExample
{
    static async Task Main()
    {
        var gotenbergUrl = "http://localhost:3000/forms/chromium/convert/html";
        
        using var client = new HttpClient();
        using var content = new MultipartFormDataContent();
        
        var html = "<html><body><h1>Hello from Gotenberg</h1></body></html>";
        content.Add(new StringContent(html), "files", "index.html");
        
        var response = await client.PostAsync(gotenbergUrl, content);
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        
        await File.WriteAllBytesAsync("output.pdf", pdfBytes);
        Console.WriteLine("PDF generated successfully");
    }
}

using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.IO;

class GotenbergExample
{
    static async Task Main()
    {
        var gotenbergUrl = "http://localhost:3000/forms/chromium/convert/html";
        
        using var client = new HttpClient();
        using var content = new MultipartFormDataContent();
        
        var html = "<html><body><h1>Hello from Gotenberg</h1></body></html>";
        content.Add(new StringContent(html), "files", "index.html");
        
        var response = await client.PostAsync(gotenbergUrl, content);
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        
        await File.WriteAllBytesAsync("output.pdf", pdfBytes);
        Console.WriteLine("PDF generated successfully");
    }
}

Imports System
Imports System.Net.Http
Imports System.Threading.Tasks
Imports System.IO

Module GotenbergExample
    Sub Main()
        MainAsync().GetAwaiter().GetResult()
    End Sub

    Private Async Function MainAsync() As Task
        Dim gotenbergUrl = "http://localhost:3000/forms/chromium/convert/html"

        Using client As New HttpClient()
            Using content As New MultipartFormDataContent()
                Dim html = "<html><body><h1>Hello from Gotenberg</h1></body></html>"
                content.Add(New StringContent(html), "files", "index.html")

                Dim response = Await client.PostAsync(gotenbergUrl, content)
                Dim pdfBytes = Await response.Content.ReadAsByteArrayAsync()

                Await File.WriteAllBytesAsync("output.pdf", pdfBytes)
                Console.WriteLine("PDF generated successfully")
            End Using
        End Using
    End Function
End Module

Imports System
Imports System.Net.Http
Imports System.Threading.Tasks
Imports System.IO

Module GotenbergExample
    Sub Main()
        MainAsync().GetAwaiter().GetResult()
    End Sub

    Private Async Function MainAsync() As Task
        Dim gotenbergUrl = "http://localhost:3000/forms/chromium/convert/html"

        Using client As New HttpClient()
            Using content As New MultipartFormDataContent()
                Dim html = "<html><body><h1>Hello from Gotenberg</h1></body></html>"
                content.Add(New StringContent(html), "files", "index.html")

                Dim response = Await client.PostAsync(gotenbergUrl, content)
                Dim pdfBytes = Await response.Content.ReadAsByteArrayAsync()

                Await File.WriteAllBytesAsync("output.pdf", pdfBytes)
                Console.WriteLine("PDF generated successfully")
            End Using
        End Using
    End Function
End Module

Nach (IronPDF):

// NuGet: Install-Package IronPdf
using System;
using IronPdf;

class IronPdfExample
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        
        var html = "<html><body><h1>Hello from IronPDF</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        
        pdf.SaveAs("output.pdf");
        Console.WriteLine("PDF generated successfully");
    }
}

// NuGet: Install-Package IronPdf
using System;
using IronPdf;

class IronPdfExample
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        
        var html = "<html><body><h1>Hello from IronPDF</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        
        pdf.SaveAs("output.pdf");
        Console.WriteLine("PDF generated successfully");
    }
}

' NuGet: Install-Package IronPdf
Imports System
Imports IronPdf

Module IronPdfExample
    Sub Main()
        Dim renderer = New ChromePdfRenderer()

        Dim html = "<html><body><h1>Hello from IronPDF</h1></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)

        pdf.SaveAs("output.pdf")
        Console.WriteLine("PDF generated successfully")
    End Sub
End Module

' NuGet: Install-Package IronPdf
Imports System
Imports IronPdf

Module IronPdfExample
    Sub Main()
        Dim renderer = New ChromePdfRenderer()

        Dim html = "<html><body><h1>Hello from IronPDF</h1></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)

        pdf.SaveAs("output.pdf")
        Console.WriteLine("PDF generated successfully")
    End Sub
End Module

Der Unterschied ist erheblich: Gotenbergerfordert das Erstellen eines HttpClient, den Aufbau von MultipartFormDataContent, das Ausführen eines asynchronen HTTP-POST an einen laufenden Docker-Container und das Verarbeiten der Byte-Array-Antwort.IronPDF reduziert dies auf drei Zeilen mit einem ChromePdfRenderer-Methodenaufruf – keine Netzwerküberlastung, keine Containerabhängigkeit, keine asynchrone Komplexität. Weitere Rendering-Optionen finden Sie in der HTML to PDF Dokumentation.

Beispiel 2: Konvertierung von URL in PDF

Vor (Gotenberg):

using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.IO;

class GotenbergUrlToPdf
{
    static async Task Main()
    {
        var gotenbergUrl = "http://localhost:3000/forms/chromium/convert/url";
        
        using var client = new HttpClient();
        using var content = new MultipartFormDataContent();
        
        content.Add(new StringContent("https://example.com"), "url");
        
        var response = await client.PostAsync(gotenbergUrl, content);
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        
        await File.WriteAllBytesAsync("webpage.pdf", pdfBytes);
        Console.WriteLine("PDF from URL generated successfully");
    }
}

using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.IO;

class GotenbergUrlToPdf
{
    static async Task Main()
    {
        var gotenbergUrl = "http://localhost:3000/forms/chromium/convert/url";
        
        using var client = new HttpClient();
        using var content = new MultipartFormDataContent();
        
        content.Add(new StringContent("https://example.com"), "url");
        
        var response = await client.PostAsync(gotenbergUrl, content);
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        
        await File.WriteAllBytesAsync("webpage.pdf", pdfBytes);
        Console.WriteLine("PDF from URL generated successfully");
    }
}

Imports System
Imports System.Net.Http
Imports System.Threading.Tasks
Imports System.IO

Module GotenbergUrlToPdf
    Async Function Main() As Task
        Dim gotenbergUrl = "http://localhost:3000/forms/chromium/convert/url"
        
        Using client As New HttpClient()
            Using content As New MultipartFormDataContent()
                content.Add(New StringContent("https://example.com"), "url")
                
                Dim response = Await client.PostAsync(gotenbergUrl, content)
                Dim pdfBytes = Await response.Content.ReadAsByteArrayAsync()
                
                Await File.WriteAllBytesAsync("webpage.pdf", pdfBytes)
                Console.WriteLine("PDF from URL generated successfully")
            End Using
        End Using
    End Function
End Module

Imports System
Imports System.Net.Http
Imports System.Threading.Tasks
Imports System.IO

Module GotenbergUrlToPdf
    Async Function Main() As Task
        Dim gotenbergUrl = "http://localhost:3000/forms/chromium/convert/url"
        
        Using client As New HttpClient()
            Using content As New MultipartFormDataContent()
                content.Add(New StringContent("https://example.com"), "url")
                
                Dim response = Await client.PostAsync(gotenbergUrl, content)
                Dim pdfBytes = Await response.Content.ReadAsByteArrayAsync()
                
                Await File.WriteAllBytesAsync("webpage.pdf", pdfBytes)
                Console.WriteLine("PDF from URL generated successfully")
            End Using
        End Using
    End Function
End Module

Nach (IronPDF):

// NuGet: Install-Package IronPdf
using System;
using IronPdf;

class IronPdfUrlToPdf
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        
        var pdf = renderer.RenderUrlAsPdf("https://example.com");
        
        pdf.SaveAs("webpage.pdf");
        Console.WriteLine("PDF from URL generated successfully");
    }
}

// NuGet: Install-Package IronPdf
using System;
using IronPdf;

class IronPdfUrlToPdf
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        
        var pdf = renderer.RenderUrlAsPdf("https://example.com");
        
        pdf.SaveAs("webpage.pdf");
        Console.WriteLine("PDF from URL generated successfully");
    }
}

' NuGet: Install-Package IronPdf
Imports System
Imports IronPdf

Class IronPdfUrlToPdf
    Shared Sub Main()
        Dim renderer As New ChromePdfRenderer()
        
        Dim pdf = renderer.RenderUrlAsPdf("https://example.com")
        
        pdf.SaveAs("webpage.pdf")
        Console.WriteLine("PDF from URL generated successfully")
    End Sub
End Class

' NuGet: Install-Package IronPdf
Imports System
Imports IronPdf

Class IronPdfUrlToPdf
    Shared Sub Main()
        Dim renderer As New ChromePdfRenderer()
        
        Dim pdf = renderer.RenderUrlAsPdf("https://example.com")
        
        pdf.SaveAs("webpage.pdf")
        Console.WriteLine("PDF from URL generated successfully")
    End Sub
End Class

Der Ansatz von Gotenbergerfordert einen anderen Endpunkt (/forms/chromium/convert/url), den Aufbau von Multipart-Inhalten mit der URL als Formularfeld und die Handhabung asynchroner HTTP-Antworten. Die RenderUrlAsPdf()-Methode von IronPDF akzeptiert die URL direkt und gibt ein PdfDocument-Objekt synchron zurück. Erfahren Sie mehr über die URL in PDF Konvertierung.

Beispiel 3: Benutzerdefinierte Papiergröße und Ränder

Vor (Gotenberg):

using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.IO;

class GotenbergCustomSize
{
    static async Task Main()
    {
        var gotenbergUrl = "http://localhost:3000/forms/chromium/convert/html";
        
        using var client = new HttpClient();
        using var content = new MultipartFormDataContent();
        
        var html = "<html><body><h1>Custom Size PDF</h1></body></html>";
        content.Add(new StringContent(html), "files", "index.html");
        content.Add(new StringContent("8.5"), "paperWidth");
        content.Add(new StringContent("11"), "paperHeight");
        content.Add(new StringContent("0.5"), "marginTop");
        content.Add(new StringContent("0.5"), "marginBottom");
        
        var response = await client.PostAsync(gotenbergUrl, content);
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        
        await File.WriteAllBytesAsync("custom-size.pdf", pdfBytes);
        Console.WriteLine("Custom size PDF generated successfully");
    }
}

using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.IO;

class GotenbergCustomSize
{
    static async Task Main()
    {
        var gotenbergUrl = "http://localhost:3000/forms/chromium/convert/html";
        
        using var client = new HttpClient();
        using var content = new MultipartFormDataContent();
        
        var html = "<html><body><h1>Custom Size PDF</h1></body></html>";
        content.Add(new StringContent(html), "files", "index.html");
        content.Add(new StringContent("8.5"), "paperWidth");
        content.Add(new StringContent("11"), "paperHeight");
        content.Add(new StringContent("0.5"), "marginTop");
        content.Add(new StringContent("0.5"), "marginBottom");
        
        var response = await client.PostAsync(gotenbergUrl, content);
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        
        await File.WriteAllBytesAsync("custom-size.pdf", pdfBytes);
        Console.WriteLine("Custom size PDF generated successfully");
    }
}

Imports System
Imports System.Net.Http
Imports System.Threading.Tasks
Imports System.IO

Class GotenbergCustomSize
    Shared Async Function Main() As Task
        Dim gotenbergUrl = "http://localhost:3000/forms/chromium/convert/html"

        Using client As New HttpClient()
            Using content As New MultipartFormDataContent()

                Dim html = "<html><body><h1>Custom Size PDF</h1></body></html>"
                content.Add(New StringContent(html), "files", "index.html")
                content.Add(New StringContent("8.5"), "paperWidth")
                content.Add(New StringContent("11"), "paperHeight")
                content.Add(New StringContent("0.5"), "marginTop")
                content.Add(New StringContent("0.5"), "marginBottom")

                Dim response = Await client.PostAsync(gotenbergUrl, content)
                Dim pdfBytes = Await response.Content.ReadAsByteArrayAsync()

                Await File.WriteAllBytesAsync("custom-size.pdf", pdfBytes)
                Console.WriteLine("Custom size PDF generated successfully")
            End Using
        End Using
    End Function
End Class

Imports System
Imports System.Net.Http
Imports System.Threading.Tasks
Imports System.IO

Class GotenbergCustomSize
    Shared Async Function Main() As Task
        Dim gotenbergUrl = "http://localhost:3000/forms/chromium/convert/html"

        Using client As New HttpClient()
            Using content As New MultipartFormDataContent()

                Dim html = "<html><body><h1>Custom Size PDF</h1></body></html>"
                content.Add(New StringContent(html), "files", "index.html")
                content.Add(New StringContent("8.5"), "paperWidth")
                content.Add(New StringContent("11"), "paperHeight")
                content.Add(New StringContent("0.5"), "marginTop")
                content.Add(New StringContent("0.5"), "marginBottom")

                Dim response = Await client.PostAsync(gotenbergUrl, content)
                Dim pdfBytes = Await response.Content.ReadAsByteArrayAsync()

                Await File.WriteAllBytesAsync("custom-size.pdf", pdfBytes)
                Console.WriteLine("Custom size PDF generated successfully")
            End Using
        End Using
    End Function
End Class

Nach (IronPDF):

// NuGet: Install-Package IronPdf
using System;
using IronPdf;
using IronPdf.Rendering;

class IronPdfCustomSize
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        
        renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter;
        renderer.RenderingOptions.MarginTop = 50;
        renderer.RenderingOptions.MarginBottom = 50;
        
        var html = "<html><body><h1>Custom Size PDF</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        
        pdf.SaveAs("custom-size.pdf");
        Console.WriteLine("Custom size PDF generated successfully");
    }
}

// NuGet: Install-Package IronPdf
using System;
using IronPdf;
using IronPdf.Rendering;

class IronPdfCustomSize
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        
        renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter;
        renderer.RenderingOptions.MarginTop = 50;
        renderer.RenderingOptions.MarginBottom = 50;
        
        var html = "<html><body><h1>Custom Size PDF</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        
        pdf.SaveAs("custom-size.pdf");
        Console.WriteLine("Custom size PDF generated successfully");
    }
}

' NuGet: Install-Package IronPdf
Imports System
Imports IronPdf
Imports IronPdf.Rendering

Class IronPdfCustomSize
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()

        renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter
        renderer.RenderingOptions.MarginTop = 50
        renderer.RenderingOptions.MarginBottom = 50

        Dim html = "<html><body><h1>Custom Size PDF</h1></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)

        pdf.SaveAs("custom-size.pdf")
        Console.WriteLine("Custom size PDF generated successfully")
    End Sub
End Class

' NuGet: Install-Package IronPdf
Imports System
Imports IronPdf
Imports IronPdf.Rendering

Class IronPdfCustomSize
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()

        renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter
        renderer.RenderingOptions.MarginTop = 50
        renderer.RenderingOptions.MarginBottom = 50

        Dim html = "<html><body><h1>Custom Size PDF</h1></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)

        pdf.SaveAs("custom-size.pdf")
        Console.WriteLine("Custom size PDF generated successfully")
    End Sub
End Class

Gotenberg erfordert string-basierte Parameter ("8.5", "11", "0.5"), die zu Multipart-Formulardaten hinzugefügt werden - keine Typsicherheit, kein IntelliSense, leicht zu vertippen.IronPDF bietet stark typisierte Eigenschaften mit PdfPaperSize-Enums und numerischen Randwerten. Beachten Sie, dass IronPDF die Ränder in Millimetern (50mm ≈ 2 Zoll) angibt, während GotenbergZoll verwendet.

Kritische Hinweise zur Migration

Einheitsumrechnungen

Die wichtigste Umstellung bei dieser Gotenberg-Migration sind die Randeinheiten:

// Gotenberg: margins in inches
content.Add(new StringContent("0.5"), "marginTop");    // 0.5 inches
content.Add(new StringContent("1"), "marginBottom");   // 1 inch

// IronPDF: margins in millimeters
renderer.RenderingOptions.MarginTop = 12.7;    // 0.5 inches × 25.4 = 12.7mm
renderer.RenderingOptions.MarginBottom = 25.4; // 1 inch × 25.4 = 25.4mm

// Gotenberg: margins in inches
content.Add(new StringContent("0.5"), "marginTop");    // 0.5 inches
content.Add(new StringContent("1"), "marginBottom");   // 1 inch

// IronPDF: margins in millimeters
renderer.RenderingOptions.MarginTop = 12.7;    // 0.5 inches × 25.4 = 12.7mm
renderer.RenderingOptions.MarginBottom = 25.4; // 1 inch × 25.4 = 25.4mm

' Gotenberg: margins in inches
content.Add(New StringContent("0.5"), "marginTop")    ' 0.5 inches
content.Add(New StringContent("1"), "marginBottom")   ' 1 inch

' IronPDF: margins in millimeters
renderer.RenderingOptions.MarginTop = 12.7    ' 0.5 inches × 25.4 = 12.7mm
renderer.RenderingOptions.MarginBottom = 25.4 ' 1 inch × 25.4 = 25.4mm

' Gotenberg: margins in inches
content.Add(New StringContent("0.5"), "marginTop")    ' 0.5 inches
content.Add(New StringContent("1"), "marginBottom")   ' 1 inch

' IronPDF: margins in millimeters
renderer.RenderingOptions.MarginTop = 12.7    ' 0.5 inches × 25.4 = 12.7mm
renderer.RenderingOptions.MarginBottom = 25.4 ' 1 inch × 25.4 = 25.4mm

Umrechnungsformel: millimeters = inches × 25.4

Synchron vs. Asynchron

Gotenberg erfordert asynchrone Operationen aufgrund der HTTP-Kommunikation:

// Gotenberg: Forced async due to network calls
var response = await client.PostAsync(gotenbergUrl, content);
var pdfBytes = await response.Content.ReadAsByteArrayAsync();

// IronPDF: Synchronous in-process execution
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

// IronPDF: Async wrapper if needed
var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf(html));

// Gotenberg: Forced async due to network calls
var response = await client.PostAsync(gotenbergUrl, content);
var pdfBytes = await response.Content.ReadAsByteArrayAsync();

// IronPDF: Synchronous in-process execution
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

// IronPDF: Async wrapper if needed
var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf(html));

Imports System.Net.Http

' Gotenberg: Forced async due to network calls
Dim response = Await client.PostAsync(gotenbergUrl, content)
Dim pdfBytes = Await response.Content.ReadAsByteArrayAsync()

' IronPDF: Synchronous in-process execution
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")

' IronPDF: Async wrapper if needed
Dim pdf = Await Task.Run(Function() renderer.RenderHtmlAsPdf(html))

Imports System.Net.Http

' Gotenberg: Forced async due to network calls
Dim response = Await client.PostAsync(gotenbergUrl, content)
Dim pdfBytes = Await response.Content.ReadAsByteArrayAsync()

' IronPDF: Synchronous in-process execution
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")

' IronPDF: Async wrapper if needed
Dim pdf = Await Task.Run(Function() renderer.RenderHtmlAsPdf(html))

Fehlerbehandlung

// Gotenberg: HTTP error handling
try
{
    var response = await client.PostAsync(gotenbergUrl, content);
    response.EnsureSuccessStatusCode();  // What if 500? 503? Timeout?
}
catch (HttpRequestException ex) { /* Network error */ }
catch (TaskCanceledException ex) { /* Timeout */ }

// IronPDF: Standard .NET exceptions
try
{
    var pdf = renderer.RenderHtmlAsPdf(html);
}
catch (Exception ex)
{
    Console.WriteLine($"PDF generation failed: {ex.Message}");
}

// Gotenberg: HTTP error handling
try
{
    var response = await client.PostAsync(gotenbergUrl, content);
    response.EnsureSuccessStatusCode();  // What if 500? 503? Timeout?
}
catch (HttpRequestException ex) { /* Network error */ }
catch (TaskCanceledException ex) { /* Timeout */ }

// IronPDF: Standard .NET exceptions
try
{
    var pdf = renderer.RenderHtmlAsPdf(html);
}
catch (Exception ex)
{
    Console.WriteLine($"PDF generation failed: {ex.Message}");
}

Imports System
Imports System.Net.Http
Imports System.Threading.Tasks

' Gotenberg: HTTP error handling
Try
    Dim response = Await client.PostAsync(gotenbergUrl, content)
    response.EnsureSuccessStatusCode()  ' What if 500? 503? Timeout?
Catch ex As HttpRequestException
    ' Network error
Catch ex As TaskCanceledException
    ' Timeout
End Try

' IronPDF: Standard .NET exceptions
Try
    Dim pdf = renderer.RenderHtmlAsPdf(html)
Catch ex As Exception
    Console.WriteLine($"PDF generation failed: {ex.Message}")
End Try

Imports System
Imports System.Net.Http
Imports System.Threading.Tasks

' Gotenberg: HTTP error handling
Try
    Dim response = Await client.PostAsync(gotenbergUrl, content)
    response.EnsureSuccessStatusCode()  ' What if 500? 503? Timeout?
Catch ex As HttpRequestException
    ' Network error
Catch ex As TaskCanceledException
    ' Timeout
End Try

' IronPDF: Standard .NET exceptions
Try
    Dim pdf = renderer.RenderHtmlAsPdf(html)
Catch ex As Exception
    Console.WriteLine($"PDF generation failed: {ex.Message}")
End Try

Entfernung der Infrastruktur

Nach der Migration sollten Sie Gotenbergaus Ihrer Infrastruktur entfernen:

# REMOVE from docker-compose.yml:
# services:
#   gotenberg:
#     image: gotenberg/gotenberg:8
#     ports:
#       - "3000:3000"
#     deploy:
#       resources:
#         limits:
#           memory: 2G

# REMOVE from docker-compose.yml:
# services:
#   gotenberg:
#     image: gotenberg/gotenberg:8
#     ports:
#       - "3000:3000"
#     deploy:
#       resources:
#         limits:
#           memory: 2G

Text

Erwägungen zur Leistung

Vergleich der Latenzzeiten

Betrieb	Gotenberg(Warm)	Gotenberg(Kaltstart)	IronPDF(Erstes Rendering)	IronPDF(Nachfolgend)
Einfaches HTML	150-300ms	2-5 Sekunden	1-2 Sekunden	50-150ms
Komplexes HTML	500-1500ms	3-7 Sekunden	1.5-3 Sekunden	200-800ms
URL-Rendering	1-5 Sekunden	3-10 Sekunden	1-5 Sekunden	500ms-3s

Beseitigung von Infrastrukturkosten

Ressource	Gotenberg	IronPDF
Erforderliche Container	1-N (Skalierung)	0
Speicherplatz pro Container	512MB-2GB	Nicht anwendbar
Netzwerk-Overhead pro Anfrage	10-100ms	0ms
Endpunkte des Gesundheitschecks	Erforderlich	Nicht erforderlich
Lastausgleicher	Oft benötigt	Nicht erforderlich

Fehlerbehebung

Ausgabe 1: HttpClient-Muster werden nicht benötigt

Problem: Code verwendet immer noch HttpClient und MultipartFormDataContent.

Lösung: Ersetzen Sie vollständig mit ChromePdfRenderer:

// Remove all of this:
// using var client = new HttpClient();
// using var content = new MultipartFormDataContent();
// content.Add(new StringContent(html), "files", "index.html");
// var response = await client.PostAsync(url, content);

// Replace with:
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);

// Remove all of this:
// using var client = new HttpClient();
// using var content = new MultipartFormDataContent();
// content.Add(new StringContent(html), "files", "index.html");
// var response = await client.PostAsync(url, content);

// Replace with:
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);

Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)

Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)

Problem 2: Falsche Randeinheiten

Problem: PDFs haben nach der Migration falsche Ränder.

Lösung: Zoll in Millimeter umrechnen:

// Gotenbergused inches: "0.5"
//IronPDF uses millimeters: 0.5 × 25.4 = 12.7
renderer.RenderingOptions.MarginTop = 12.7;

// Gotenbergused inches: "0.5"
//IronPDF uses millimeters: 0.5 × 25.4 = 12.7
renderer.RenderingOptions.MarginTop = 12.7;

Aufgabe 3: Container-URL-Referenzen

Problem: Code enthält http://gotenberg:3000 oder ähnliche URLs.

Lösung: Entfernen Sie alle Container-URL-Referenzen –IronPDF läuft im selben Prozess:

// Remove:
// private readonly string _gotenbergUrl = "http://gotenberg:3000";

//IronPDF needs no URL - it's in-process
var renderer = new ChromePdfRenderer();

// Remove:
// private readonly string _gotenbergUrl = "http://gotenberg:3000";

//IronPDF needs no URL - it's in-process
var renderer = new ChromePdfRenderer();

' Remove:
' Private ReadOnly _gotenbergUrl As String = "http://gotenberg:3000"

' IronPDF needs no URL - it's in-process
Dim renderer As New ChromePdfRenderer()

' Remove:
' Private ReadOnly _gotenbergUrl As String = "http://gotenberg:3000"

' IronPDF needs no URL - it's in-process
Dim renderer As New ChromePdfRenderer()

Migrations-Checkliste

Vor der Migration

Inventarisierung aller Gotenberg-HTTP-Aufrufe im Quellcode
Aktuelle Gotenberg-Konfiguration dokumentieren (Timeouts, Ränder, Papierformate)
Alle Docker/Kubernetes Gotenberg-Konfigurationen identifizieren -IronPDF-Lizenzschlüssel erhalten
Planen Sie die Stilllegung der Infrastruktur

Code-Migration

Installieren Sie das IronPDF NuGet-Paket: dotnet add package IronPdf
Gotenberg-Clientpakete entfernen
Ersetzen Sie alle HTTP-Aufrufe an Gotenbergdurch IronPDF-Methodenaufrufe
Umrechnung der Maßeinheiten von Zoll in Millimeter
Aktualisierung der Fehlerbehandlung (HTTP-Fehler → .NET -Ausnahmen)
Lizenzschlüsselinitialisierung beim Start hinzufügen

Infrastruktur-Migration

Gotenbergaus Docker Compose / Kubernetes entfernen
CI/CD-Pipelines aktualisieren (Gotenberg-Image-Pulls entfernen)
Gotenberg-Gesundheitschecks entfernen
Gotenberg-URL aus der Konfiguration entfernen

Testen

Test der Konvertierung von HTML in PDF
Test der URL-zu-PDF-Konvertierung
Überprüfen Sie die Genauigkeit von Rand und Größe.
Leistungstest unter Last
Test der Aufwärmzeit beim ersten Rendering

Nach der Migration

Gotenberg-Container-Bereitstellungen entfernen
Archiv Gotenberg-Konfigurationsdateien
Dokumentation aktualisieren
Überwachung der Anwendungsspeichernutzung
Prüfen, ob keine verwaisten Netzwerkverbindungen vorhanden sind

Hinweis:: Gotenberg ist eine eingetragene Marke ihres jeweiligen Eigentümers. Diese Seite ist nicht mit Gotenbergverbunden, unterstützt oder wird von Gotenberggesponsert. Alle Produktnamen, Logos und Marken sind Eigentum ihrer jeweiligen Inhaber. Vergleiche dienen nur zu Informationszwecken und spiegeln öffentlich zugängliche Informationen zum Zeitpunkt des Schreibens wider.

Curtis Chau

Jetzt mit dem Ingenieurteam chatten

Technischer Autor

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender Handbücher.

...