VIDEOS

QR-Code in PDF umwandeln in C# | IronPDF

Aktualisiert:19. Juli 2026

PDFmyURL ist ein Cloud-basierter API-Dienst zur Konvertierung von URLs und HTML-Inhalten in PDF-Dokumente. Der Dienst verarbeitet alle Konvertierungen auf externen Servern und bietet einen unkomplizierten Integrationspfad, der nur eine minimale lokale Infrastruktur erfordert. Diese von der Cloud abhängige Architektur wirft jedoch erhebliche Probleme für Produktionsanwendungen auf, die mit sensiblen Daten umgehen, Offline-Funktionen benötigen oder laufende Abonnementkosten vermeiden müssen.

Dieser Leitfaden bietet einen vollständigen Migrationspfad von PDFmyURLzu IronPDF, mit Schritt-für-Schritt-Anleitungen, Code-Vergleichen und praktischen Beispielen für professionelle .NET-Entwickler, die diesen Übergang evaluieren.

Warum von PDFmyURLmigrieren

Das Cloud-Verarbeitungsmodell von PDFmyURLbringt einige Herausforderungen mit sich, die die Entwicklerteams berücksichtigen müssen:

Datenschutz & Datensicherheit: Jedes Dokument, das Sie konvertieren, durchläuft die Server von PDFmyURL– sensible Verträge, Finanzberichte und personenbezogene Daten werden extern verarbeitet.

Laufende Abonnementkosten: Pläne beginnen bei 20 $/Monat (Starter, 500 PDFs), 40 $/Monat (Professional, 2.000 PDFs) und $70/Monat (Erweitert, 5.000 PDFs), ohne Eigentum auf keiner Stufe. Dieses Abonnementmodell bedeutet kontinuierliche Ausgaben unabhängig von den Nutzungsmustern.

Internetabhängigkeit: Jede Konvertierung erfordert eine Netzwerkverbindung. Die Anwendungen können PDFs nicht offline oder während eines Netzwerkausfalls verarbeiten.

Ratenbegrenzung und Drosselung: API-Aufrufe können während Spitzenzeiten gedrosselt werden, was unter Umständen die Anwendungsleistung beeinträchtigen kann.

Verfügbarkeit des Dienstes: Ihre Anwendung ist davon abhängig, dass ein Drittanbieterdienst online und funktionsfähig ist.

Anbieterabhängigkeit: API-Änderungen können Ihre Integration ohne Vorwarnung beeinträchtigen und reaktive Code-Aktualisierungen erforderlich machen.

IronPDF vs. PDFmyURL: Vergleich der Funktionen

Das Verständnis der architektonischen Unterschiede hilft technischen Entscheidungsträgern, die Investition in die Migration zu bewerten:

Aspekt	PDFmyURL	IronPDF
Bearbeitungsort	Externe Server	Lokal (Ihr Server)
Typ	API Wrapper	.NET-Bibliothek
Authentifizierung	API-Schlüssel pro Anfrage	Einmaliger Lizenzschlüssel
Netzwerk erforderlich	Jede Konvertierung	Nur Ersteinrichtung
Preismodell	Monatliches Abonnement ($20–$70+)	Unbefristete Lizenz verfügbar
Ratengrenzen	Ja (planabhängig)	None
Datenschutz	Extern gesendete Daten	Daten bleiben lokal
HTML/CSS/JS-Unterstützung	Serverseitiges Rendering (W3C-konform)	Vollständige Chromium-Engine
Async-Muster	HTTP-Anfrage (netzgebunden)	Sync- und async-Optionen
PDF-Bearbeitung	Beschränkt	Vollständige Suite (zusammenführen, aufteilen, bearbeiten)
Anwendungsfall	Geringfügige Anwendungen	Großes Volumen und Unternehmen

Schnellstart: PDFmyURLzu IronPDF Migration

Mit diesen grundlegenden Schritten kann die Migration sofort beginnen.

Schritt 1: Installieren Sie IronPDF

PDFmyURL hat kein NuGet-Paket — der Dienst ist eine REST API, und die optionale PDFmyURL.NET.dll Komponente wird als direkter DLL-Download ausgeliefert (nicht auf nuget.org). Die meisten Integrationen rufen die API mit WebClient / HttpClient auf, sodass die Migration hauptsächlich um den Code und nicht um Paketreferenzen geht. Wenn Sie die PDFmyURL.NET.dll Assembly verwendet haben, entfernen Sie die Referenz aus Ihrem Projekt nach der Migration.

# Install IronPDF
dotnet add package IronPdf

# Install IronPDF
dotnet add package IronPdf

SHELL

Schritt 2: Namespaces aktualisieren

Ersetzen Sie PDFmyURL-Importe durch IronPDF:

// Before: PDFmyURL— either plain HttpClient/WebClient against pdfmyurl.com/api,
// or the optional .NET component:
using PDFmyURLdotNET;          // only if you used PDFmyURL.NET.dll
using System.Net;               // WebClient / HttpClient

// After: IronPDF
using IronPdf;
using IronPdf.Rendering;

// Before: PDFmyURL— either plain HttpClient/WebClient against pdfmyurl.com/api,
// or the optional .NET component:
using PDFmyURLdotNET;          // only if you used PDFmyURL.NET.dll
using System.Net;               // WebClient / HttpClient

// After: IronPDF
using IronPdf;
using IronPdf.Rendering;

Imports PDFmyURLdotNET ' only if you used PDFmyURL.NET.dll
Imports System.Net ' WebClient / HttpClient

Imports IronPdf
Imports IronPdf.Rendering

$vbLabelText $csharpLabel

Schritt 3: Lizenz initialisieren

Hinzufügen der Lizenzinitialisierung beim Start der Anwendung:

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

$vbLabelText $csharpLabel

Beispiele für die Code-Migration

Konvertierung von URLs zu PDF

Die URL-zu-PDF-Operation demonstriert die grundlegenden API-Unterschiede zwischen PDFmyURLund IronPDF.

PDFmyURL-Ansatz:

// PDFmyURLREST API — no NuGet SDK. Docs: https://pdfmyurl.com/html-to-pdf-api
using System;
using System.Net;

class Example
{
    static void Main()
    {
        string license = "your-license-key";
        string url = "https://example.com";

        try
        {
            using (var client = new WebClient())
            {
                client.QueryString.Add("license", license);
                client.QueryString.Add("url", url);
                // PDF binary is returned in the response body
                client.DownloadFile("https://pdfmyurl.com/api", "output.pdf");
            }
        }
        catch (WebException ex)
        {
            Console.WriteLine("Error: " + ex.Message);
        }
    }
}

// PDFmyURLREST API — no NuGet SDK. Docs: https://pdfmyurl.com/html-to-pdf-api
using System;
using System.Net;

class Example
{
    static void Main()
    {
        string license = "your-license-key";
        string url = "https://example.com";

        try
        {
            using (var client = new WebClient())
            {
                client.QueryString.Add("license", license);
                client.QueryString.Add("url", url);
                // PDF binary is returned in the response body
                client.DownloadFile("https://pdfmyurl.com/api", "output.pdf");
            }
        }
        catch (WebException ex)
        {
            Console.WriteLine("Error: " + ex.Message);
        }
    }
}

Imports System
Imports System.Net

Class Example
    Shared Sub Main()
        Dim license As String = "your-license-key"
        Dim url As String = "https://example.com"

        Try
            Using client As New WebClient()
                client.QueryString.Add("license", license)
                client.QueryString.Add("url", url)
                ' PDF binary is returned in the response body
                client.DownloadFile("https://pdfmyurl.com/api", "output.pdf")
            End Using
        Catch ex As WebException
            Console.WriteLine("Error: " & ex.Message)
        End Try
    End Sub
End Class

$vbLabelText $csharpLabel

IronPDF-Ansatz:

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

class Example
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://example.com");
        pdf.SaveAs("output.pdf");
    }
}

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

class Example
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://example.com");
        pdf.SaveAs("output.pdf");
    }
}

Imports IronPdf
Imports System

Class Example
    Shared Sub Main()
        Dim renderer As New ChromePdfRenderer()
        Dim pdf = renderer.RenderUrlAsPdf("https://example.com")
        pdf.SaveAs("output.pdf")
    End Sub
End Class

$vbLabelText $csharpLabel

PDFmyURL erfordert das Öffnen einer HTTP-Verbindung zu https://pdfmyurl.com/api bei jeder Konvertierung, das Anhängen des license Tokens sowie das Ziel url als Abfrage- (oder Formular-) Parameter, und das Schreiben des Antwortkörpers auf die Festplatte. Fehler treten als WebException basierend auf dem HTTP-Statuscode auf.

IronPDF vereinfacht dies auf drei Zeilen: Erstellen Sie eine ChromePdfRenderer, rufen Sie RenderUrlAsPdf() auf und verwenden Sie die eingebaute SaveAs() Methode. Keine anfragepezifischen Anmeldeinformationen sind erforderlich – die Lizenz wird einmal beim Anwendungsstart gesetzt.

Für fortgeschrittene URL-zu-PDF-Szenarien siehe die URL-zu-PDF-Dokumentation.

Konvertierung von HTML-Strings zu PDF

Die Konvertierung von HTML-Strings zeigt die Musterunterschiede deutlich auf.

PDFmyURL-Ansatz:

// PDFmyURLREST API — no NuGet SDK. Send the raw HTML in the `html` parameter.
// Docs: https://pdfmyurl.com/html-to-pdf-api
using System;
using System.Collections.Specialized;
using System.IO;
using System.Net;

class Example
{
    static void Main()
    {
        string license = "your-license-key";
        string html = "<html><body><h1>Hello World</h1></body></html>";

        try
        {
            using (var client = new WebClient())
            {
                var values = new NameValueCollection
                {
                    { "license", license },
                    { "html", html }
                };
                // POST form-encoded; response body is the PDF binary
                byte[] pdfBytes = client.UploadValues("https://pdfmyurl.com/api", "POST", values);
                File.WriteAllBytes("output.pdf", pdfBytes);
            }
        }
        catch (WebException ex)
        {
            Console.WriteLine("Error: " + ex.Message);
        }
    }
}

// PDFmyURLREST API — no NuGet SDK. Send the raw HTML in the `html` parameter.
// Docs: https://pdfmyurl.com/html-to-pdf-api
using System;
using System.Collections.Specialized;
using System.IO;
using System.Net;

class Example
{
    static void Main()
    {
        string license = "your-license-key";
        string html = "<html><body><h1>Hello World</h1></body></html>";

        try
        {
            using (var client = new WebClient())
            {
                var values = new NameValueCollection
                {
                    { "license", license },
                    { "html", html }
                };
                // POST form-encoded; response body is the PDF binary
                byte[] pdfBytes = client.UploadValues("https://pdfmyurl.com/api", "POST", values);
                File.WriteAllBytes("output.pdf", pdfBytes);
            }
        }
        catch (WebException ex)
        {
            Console.WriteLine("Error: " + ex.Message);
        }
    }
}

Imports System
Imports System.Collections.Specialized
Imports System.IO
Imports System.Net

Class Example
    Shared Sub Main()
        Dim license As String = "your-license-key"
        Dim html As String = "<html><body><h1>Hello World</h1></body></html>"

        Try
            Using client As New WebClient()
                Dim values As New NameValueCollection From {
                    {"license", license},
                    {"html", html}
                }
                ' POST form-encoded; response body is the PDF binary
                Dim pdfBytes As Byte() = client.UploadValues("https://pdfmyurl.com/api", "POST", values)
                File.WriteAllBytes("output.pdf", pdfBytes)
            End Using
        Catch ex As WebException
            Console.WriteLine("Error: " & ex.Message)
        End Try
    End Sub
End Class

$vbLabelText $csharpLabel

IronPDF-Ansatz:

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

class Example
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        string html = "<html><body><h1>Hello World</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}

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

class Example
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        string html = "<html><body><h1>Hello World</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}

Imports IronPdf
Imports System

Class Example
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim html As String = "<html><body><h1>Hello World</h1></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Class

$vbLabelText $csharpLabel

PDFmyURL sendet das rohe HTML im html Formularparameter zu seinem API-Endpunkt und gibt das gerenderte PDF als Antwortkörper zurück. Die RenderHtmlAsPdf() von IronPDF verarbeitet alles lokal mit der Chromium-Rendering-Engine.

Im Leitfaden zur Konvertierung von HTML in PDF finden Sie weitere Optionen.

HTML-Dateikonvertierung mit Seiteneinstellungen

Die Konfiguration von Papiergröße, Ausrichtung und Rändern erfordert in jeder Bibliothek unterschiedliche Ansätze.

PDFmyURL-Ansatz:

// PDFmyURLREST API — no NuGet SDK. Page settings are sent as query/form parameters.
// Parameter reference: https://pdfmyurl.com/html-to-pdf-api
using System;
using System.Collections.Specialized;
using System.IO;
using System.Net;

class Example
{
    static void Main()
    {
        string license = "your-license-key";
        string html = File.ReadAllText("input.html");

        try
        {
            using (var client = new WebClient())
            {
                var values = new NameValueCollection
                {
                    { "license",     license },
                    { "html",        html },
                    { "page_size",   "A4" },
                    { "orientation", "landscape" },
                    { "top",         "10" },
                    { "unit",        "mm" }
                };
                byte[] pdfBytes = client.UploadValues("https://pdfmyurl.com/api", "POST", values);
                File.WriteAllBytes("output.pdf", pdfBytes);
            }
        }
        catch (WebException ex)
        {
            Console.WriteLine("Error: " + ex.Message);
        }
    }
}

// PDFmyURLREST API — no NuGet SDK. Page settings are sent as query/form parameters.
// Parameter reference: https://pdfmyurl.com/html-to-pdf-api
using System;
using System.Collections.Specialized;
using System.IO;
using System.Net;

class Example
{
    static void Main()
    {
        string license = "your-license-key";
        string html = File.ReadAllText("input.html");

        try
        {
            using (var client = new WebClient())
            {
                var values = new NameValueCollection
                {
                    { "license",     license },
                    { "html",        html },
                    { "page_size",   "A4" },
                    { "orientation", "landscape" },
                    { "top",         "10" },
                    { "unit",        "mm" }
                };
                byte[] pdfBytes = client.UploadValues("https://pdfmyurl.com/api", "POST", values);
                File.WriteAllBytes("output.pdf", pdfBytes);
            }
        }
        catch (WebException ex)
        {
            Console.WriteLine("Error: " + ex.Message);
        }
    }
}

Imports System
Imports System.Collections.Specialized
Imports System.IO
Imports System.Net

Module Example
    Sub Main()
        Dim license As String = "your-license-key"
        Dim html As String = File.ReadAllText("input.html")

        Try
            Using client As New WebClient()
                Dim values As New NameValueCollection From {
                    {"license", license},
                    {"html", html},
                    {"page_size", "A4"},
                    {"orientation", "landscape"},
                    {"top", "10"},
                    {"unit", "mm"}
                }
                Dim pdfBytes As Byte() = client.UploadValues("https://pdfmyurl.com/api", "POST", values)
                File.WriteAllBytes("output.pdf", pdfBytes)
            End Using
        Catch ex As WebException
            Console.WriteLine("Error: " & ex.Message)
        End Try
    End Sub
End Module

$vbLabelText $csharpLabel

IronPDF-Ansatz:

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

class Example
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
        renderer.RenderingOptions.MarginTop = 10;
        var pdf = renderer.RenderHtmlFileAsPdf("input.html");
        pdf.SaveAs("output.pdf");
    }
}

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

class Example
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
        renderer.RenderingOptions.MarginTop = 10;
        var pdf = renderer.RenderHtmlFileAsPdf("input.html");
        pdf.SaveAs("output.pdf");
    }
}

Imports IronPdf
Imports IronPdf.Rendering
Imports System

Class Example
    Shared Sub Main()
        Dim renderer As New ChromePdfRenderer()
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape
        renderer.RenderingOptions.MarginTop = 10
        Dim pdf = renderer.RenderHtmlFileAsPdf("input.html")
        pdf.SaveAs("output.pdf")
    End Sub
End Class

$vbLabelText $csharpLabel

PDFmyURL konfiguriert Seiten durch Hinzufügen von Formularparametern wie page_size=A4, orientation=landscape und die Randfelder (top, bottom, left, right) neben einem unit (z.B. mm, in).IronPDF bietet stark typisierte Eigenschaften durch RenderingOptions mit Enums wie PdfPaperSize.A4 und ganzzahlige Werte für Ränder in Millimetern.

PDFmyURLAPI zu IronPDF Mapping Referenz

Dieses Mapping beschleunigt die Migration, indem es direkte API-Entsprechungen aufzeigt:

Kernklassen / Einstiegspunkte

PDFmyURL	IronPDF
`WebClient` / `HttpClient` Posting zu `https://pdfmyurl.com/api`	`ChromePdfRenderer`
`PDFmyURLdotNET.PDFmyURL` (optionale .NET-Komponente von `PDFmyURL.NET.dll`)	`ChromePdfRenderer`
Formular- / Abfrageparameter	`ChromePdfRenderOptions`
HTTP-Antwortkörper-Bytes	`PdfDocument`

Methoden

PDFmyURL	IronPDF
`WebClient.DownloadFile(".../api?license=...&url=...", file)`	`renderer.RenderUrlAsPdf(url).SaveAs(file)`
POST mit `html=` Parameter	`renderer.RenderHtmlAsPdf(html)`
`File.ReadAllText("input.html")` dann POST `html=`	`renderer.RenderHtmlFileAsPdf(path)`
`pdf.ConvertURL(url, file)` (PDFmyURL.NET.dll)	`renderer.RenderUrlAsPdf(url).SaveAs(file)`
`pdf.ConvertHTML(html, file)` (PDFmyURL.NET.dll)	`renderer.RenderHtmlAsPdf(html).SaveAs(file)`
HTTP-Antwortkörper (`byte[]`)	`pdf.BinaryData`
HTTP-Antwortstrom	`new MemoryStream(pdf.BinaryData)`

Konfigurationsoptionen

PDFmyURL-Einstellungen werden als Formular/Abfrageparameter in der HTTP-Anfrage übergeben. Die folgende Tabelle ordnet reale PDFmyURL-Parameternamen IronPDFs RenderingOptions zu.

PDFmyURL-Parameter	IronPDF(RenderingOptions)
`page_size=A4`	`.PaperSize = PdfPaperSize.A4`
`page_size=Letter`	`.PaperSize = PdfPaperSize.Letter`
`orientation=landscape`	`.PaperOrientation = PdfPaperOrientation.Landscape`
`orientation=portrait`	`.PaperOrientation = PdfPaperOrientation.Portrait`
`top=10&unit=mm`	`.MarginTop = 10`
`bottom=10&unit=mm`	`.MarginBottom = 10`
`left=10&unit=mm`	`.MarginLeft = 10`
`right=10&unit=mm`	`.MarginRight = 10`
`header=<html>`	`.HtmlHeader = new HtmlHeaderFooter { HtmlFragment = html }`
`footer=<html>`	`.HtmlFooter = new HtmlHeaderFooter { HtmlFragment = html }`
`javascript_time=500`	`.RenderDelay = 500`
`no_javascript=true`	`.EnableJavaScript = false`
`css_media_type=print`	`.CssMediaType = PdfCssMediaType.Print`

Vergleich der Authentifizierung

PDFmyURL	IronPDF
`license=<key>` Abfrage-/Formularparameter bei jeder API-Anfrage	`IronPdf.License.LicenseKey = "LICENSE-KEY"`
Lizenz-Token pro Anfrage	Einmalig bei Startup
Für jeden Aufruf erforderlich	Einmal global eingestellt

Gängige Migrationsprobleme und Lösungen

Problem 1: Lizenz-Token vs. Lizenzschlüssel

PDFmyURL: Erfordert das license Token bei jeder API-Anfrage.

Lösung: Setzen Sie die IronPDF-Lizenz einmalig beim Start der Anwendung:

// PDFmyURL: license token per request
client.QueryString.Add("license", "your-license-key");

// IronPDF: One-time license at startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
// Set once, typically in Program.cs or Startup.cs

// PDFmyURL: license token per request
client.QueryString.Add("license", "your-license-key");

// IronPDF: One-time license at startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
// Set once, typically in Program.cs or Startup.cs

' PDFmyURL: license token per request
client.QueryString.Add("license", "your-license-key")

' IronPDF: One-time license at startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
' Set once, typically in Program.vb or Startup.vb

$vbLabelText $csharpLabel

Aufgabe 2: Platzhalter-Syntax in Kopf-/Fußzeilen

PDFmyURL: Verwendet Tokens wie [page] und [topage] innerhalb der header / footer Formularparameter (sehen Sie in der Live-API-Referenz für die kanonische Tokenliste nach).

Lösung: Aktualisieren Sie das Platzhalterformat von IronPDF innerhalb HtmlHeaderFooter.HtmlFragment:

// PDFmyURL: "Page [page] of [topage]"
// IronPDF: "Page {page} of {total-pages}"

// PDFmyURL: "Page [page] of [topage]"
// IronPDF: "Page {page} of {total-pages}"

' PDFmyURL: "Page [page] of [topage]"
' IronPDF: "Page {page} of {total-pages}"

$vbLabelText $csharpLabel

Ausgabe 3: Async-Muster

PDFmyURL: Ist ein entfernter HTTP-Anruf; typischerweise mit HttpClient.PostAsync gegen pdfmyurl.com/api aufgerufen.

Lösung:IronPDF ist standardmäßig in-prozess und synchron; bei Bedarf für async einpacken:

// PDFmyURL: HTTP request to the public endpoint
var response = await http.PostAsync("https://pdfmyurl.com/api", form);

// IronPDF: Sync by default, wrap for async
var pdf = await Task.Run(() => renderer.RenderUrlAsPdf(url));

// PDFmyURL: HTTP request to the public endpoint
var response = await http.PostAsync("https://pdfmyurl.com/api", form);

// IronPDF: Sync by default, wrap for async
var pdf = await Task.Run(() => renderer.RenderUrlAsPdf(url));

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

' PDFmyURL: HTTP request to the public endpoint
Dim response = Await http.PostAsync("https://pdfmyurl.com/api", form)

' IronPDF: Sync by default, wrap for async
Dim pdf = Await Task.Run(Function() renderer.RenderUrlAsPdf(url))

$vbLabelText $csharpLabel

Ausgabe 4: Fehlerbehandlung

PDFmyURL: HTTP-Ebene Fehler (ungültige Lizenz, Ratenbegrenzung, Netzwerkfehler, Dienst nicht verfügbar) treten als WebException / Nicht-Erfolgsstatuscodes auf.

Lösung: Aktualisieren Sie die catch-Blöcke für IronPDFs typisierte Ausnahmen:

// PDFmyURL: WebException from the HTTP call
catch (WebException e) { ... }

// IronPDF: Typed exceptions
catch (IronPdf.Exceptions.IronPdfRenderingException e) { ... }

// PDFmyURL: WebException from the HTTP call
catch (WebException e) { ... }

// IronPDF: Typed exceptions
catch (IronPdf.Exceptions.IronPdfRenderingException e) { ... }

$vbLabelText $csharpLabel

Ausgabe 5: Konfigurationsmuster

PDFmyURL: Konfiguration wird als Formular-/Abfrageparametern bei der HTTP-Anfrage übergeben.

Lösung: Verwenden Sie stark typisierte RenderingOptions-Eigenschaften:

// PDFmyURL: form/query parameters
values.Add("page_size", "A4");
values.Add("orientation", "landscape");

// IronPDF: Properties with enums
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;

// PDFmyURL: form/query parameters
values.Add("page_size", "A4");
values.Add("orientation", "landscape");

// IronPDF: Properties with enums
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;

' PDFmyURL: form/query parameters
values.Add("page_size", "A4")
values.Add("orientation", "landscape")

' IronPDF: Properties with enums
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape

$vbLabelText $csharpLabel

PDFmyURL-Migrations-Checkliste

Vor der Migration anfallende Aufgaben

Überprüfen Sie Ihre Codebasis, um die Verwendung von PDFmyURLzu identifizieren:

# Find PDFmyURLendpoint and component usage
grep -r "pdfmyurl.com/api\|PDFmyURLdotNET\|new PDFmyURL(" --include="*.cs" .

# Find license-token references
grep -r "license=\|licensekey" --include="*.cs" --include="*.json" --include="*.config" .

# Find placeholder patterns to migrate
grep -r "\[page\]\|\[topage\]" --include="*.cs" .

# Find PDFmyURLendpoint and component usage
grep -r "pdfmyurl.com/api\|PDFmyURLdotNET\|new PDFmyURL(" --include="*.cs" .

# Find license-token references
grep -r "license=\|licensekey" --include="*.cs" --include="*.json" --include="*.config" .

# Find placeholder patterns to migrate
grep -r "\[page\]\|\[topage\]" --include="*.cs" .

SHELL

Dokumentieren Sie aktuelle Konfigurationsparameter, die verwendet werden (page_size, orientation, margins, header/footer usw.). Planen Sie die Speicherung von Lizenzschlüsseln mithilfe von Umgebungsvariablen.

Aufgaben der Code-Aktualisierung

Entfernen Sie die optionale PDFmyURL.NET.dll Referenz, wenn Sie sie verwendet haben (kein NuGet-Paket zum Deinstallieren vorhanden)
Installieren Sie das IronPDF NuGet-Paket
Aktualisieren aller Namensraumimporte
Ersetzen Sie das pro Anfrage verwendete license Token durch IronPdf.License.LicenseKey
Konvertieren Sie Formular-/Abfrageparameter zu RenderingOptions Eigenschaften
Aktualisieren Sie die Platzhaltersyntax in Kopf- und Fußzeilen (z.B. [page] → {page}, [topage] → {total-pages})
Aktualisieren Sie den Fehlerbehandlungscode (WebException → typisierte IronPDF-Ausnahmen)
IronPDF-Lizenzinitialisierung beim Start hinzufügen

Post-Migrationstests

Überprüfen Sie diese Aspekte nach der Migration:

Testen Sie, ob die Qualität der PDF-Ausgabe den Erwartungen entspricht
Überprüfen, ob async-Muster korrekt funktionieren
Vergleich der Wiedergabetreue mit früheren Ausgaben
Testen Sie die korrekte Wiedergabe aller Vorlagenvarianten
Validierung der Seiteneinstellungen (Größe, Ausrichtung, Ränder)
Installieren Sie Linux-Abhängigkeiten, wenn Sie die Software auf Linux-Servern einsetzen

Die wichtigsten Vorteile der Migration zu IronPDF

Der Wechsel von PDFmyURLzu IronPDF bietet mehrere entscheidende Vorteile:

Absolute Vertraulichkeit: Ihre Dokumente verlassen niemals Ihren Server. Die gesamte Verarbeitung erfolgt lokal, wodurch Bedenken hinsichtlich der Datensicherheit für sensible Inhalte ausgeräumt werden.

Einmalige Kosten: Mit der Option einer unbefristeten Lizenz entfallen wiederkehrende Abonnementgebühren. Keine monatlichen Zahlungen mehr, unabhängig vom Nutzungsvolumen.

Offline-Funktionalität: Funktioniert nach der Ersteinrichtung auch ohne Internetverbindung. Netzwerkausfälle beeinträchtigen die PDF-Erstellung nicht.

Keine Ratenbegrenzung: Verarbeiten Sie unbegrenzt viele Dokumente ohne Drosselungsbedenken.

Geringere Latenz: Kein Netzwerk-Overhead bedeutet schnellere Konvertierungen, insbesondere bei Anwendungen mit hohem Datenaufkommen.

Volle Kontrolle: Sie kontrollieren die Verarbeitungsumgebung, nicht ein Drittanbieterdienst.

Moderne Chromium-Engine: Volle CSS3- und JavaScript Unterstützung mit derselben Rendering-Engine, die auch den Chrome-Browser antreibt.

Aktive Entwicklung: Regelmäßige Updates von IronPDF sorgen für Kompatibilität mit aktuellen modernen .NET-Versionen.

Hinweis:PDFmyURL ist eine eingetragene Marke des jeweiligen Eigentümers. Diese Website ist nicht mit, nicht autorisiert oder gesponsert von PDFmyURLassoziiert. Alle Produktnamen, Logos und Marken sind Eigentum ihrer jeweiligen Eigentümer. 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 ...

Kunden-Highlight:

Entwickler im Rampenlicht:

Webinare:

Starten Sie jetzt Ihre kostenlose 30-Tage-Testphase

QR-Code in PDF umwandeln in C# | IronPDF

Warum von PDFmyURLmigrieren

IronPDF vs. PDFmyURL: Vergleich der Funktionen

Schnellstart: PDFmyURLzu IronPDF Migration

Schritt 1: Installieren Sie IronPDF

Schritt 2: Namespaces aktualisieren

Schritt 3: Lizenz initialisieren

Beispiele für die Code-Migration

Konvertierung von URLs zu PDF

Konvertierung von HTML-Strings zu PDF

HTML-Dateikonvertierung mit Seiteneinstellungen

PDFmyURLAPI zu IronPDF Mapping Referenz

Kernklassen / Einstiegspunkte

Methoden

Konfigurationsoptionen

Vergleich der Authentifizierung

Gängige Migrationsprobleme und Lösungen

Problem 1: Lizenz-Token vs. Lizenzschlüssel

Aufgabe 2: Platzhalter-Syntax in Kopf-/Fußzeilen

Ausgabe 3: Async-Muster

Ausgabe 4: Fehlerbehandlung

Ausgabe 5: Konfigurationsmuster

PDFmyURL-Migrations-Checkliste

Vor der Migration anfallende Aufgaben

Aufgaben der Code-Aktualisierung

Post-Migrationstests

Die wichtigsten Vorteile der Migration zu IronPDF

Ihr Lizenzschlüssel wurde in Ihren Posteingang geliefert

Ihre Demo-Anfrage ist eingegangen.

Iron-Support-Team

Starten Sie jetzt Ihre kostenlose 30-Tage-Testphase

QR-Code in PDF umwandeln in C# | IronPDF

Warum von PDFmyURLmigrieren

IronPDF vs. PDFmyURL: Vergleich der Funktionen

Schnellstart: PDFmyURLzu IronPDF Migration

Schritt 1: Installieren Sie IronPDF

Schritt 2: Namespaces aktualisieren

Schritt 3: Lizenz initialisieren

Beispiele für die Code-Migration

Konvertierung von URLs zu PDF

Konvertierung von HTML-Strings zu PDF

HTML-Dateikonvertierung mit Seiteneinstellungen

PDFmyURLAPI zu IronPDF Mapping Referenz

Kernklassen / Einstiegspunkte

Methoden

Konfigurationsoptionen

Vergleich der Authentifizierung

Gängige Migrationsprobleme und Lösungen

Problem 1: Lizenz-Token vs. Lizenzschlüssel

Aufgabe 2: Platzhalter-Syntax in Kopf-/Fußzeilen

Ausgabe 3: Async-Muster

Ausgabe 4: Fehlerbehandlung

Ausgabe 5: Konfigurationsmuster

PDFmyURL-Migrations-Checkliste

Vor der Migration anfallende Aufgaben

Aufgaben der Code-Aktualisierung

Post-Migrationstests

Die wichtigsten Vorteile der Migration zu IronPDF

Verwandte Artikel

Konvertieren von HTML in PDF mit C# in .NET 10 | IronPDF

Wie man benutzerdefinierte Papierformate für PDFs mit C# setzt | IronPDF

PDF-Seiten umwandeln mit IronPDF in C# | IronPDF

Nächster Schritt: Kostenlosen 30-Tage-Test starten

Thank You

Nächster Schritt: Kostenlosen 30-Tage-Test starten

Möchten Sie IronSuite KOSTENLOS in einem Live-Projekt einsetzen?

DLL-Download

Ihr Lizenzschlüssel wurde in Ihren Posteingang geliefert

Ihre Demo-Anfrage ist eingegangen.

Von Millionen von Ingenieur*innen weltweit vertraut

Iron-Support-Team