VIDéOS

Comment convertir un code QR en PDF en C# | IronPDF

Mis à jour:19 juillet 2026

PDFmyURL est un service API basé sur le cloud conçu pour convertir des URL et du contenu HTML en documents PDF. Le service traite toutes les conversions sur des serveurs externes, offrant ainsi un chemin d'intégration direct qui ne nécessite qu'une infrastructure locale minimale. Cependant, cette architecture dépendante du nuage crée des problèmes importants pour les applications de production qui traitent des données sensibles, nécessitent une capacité hors ligne ou doivent éviter les coûts d'abonnement permanents.

Ce guide fournit un chemin de migration complet de PDFmyURLvers IronPDF, avec des instructions étape par étape, des comparaisons de code et des exemples pratiques pour les développeurs .NET professionnels qui évaluent cette transition.

Pourquoi migrer de PDFmyURL

Le modèle de traitement en nuage de PDFmyURLprésente plusieurs défis que les équipes de développement doivent prendre en compte :

Confidentialité et sécurité des données : Chaque document que vous convertissez transite par les serveurs de PDFmyURL— les contrats sensibles, les rapports financiers et les données personnelles sont tous traités en externe.

Coûts d'abonnement en cours : Les plans commencent à 20 $/mois (Starter, 500 PDFs), 40 $/mois (Professional, 2 000 PDFs), et 70 $/mois (Advanced, 5 000 PDFs), sans propriété à aucun niveau. Ce modèle d'abonnement signifie une dépense continue indépendamment des schémas d'utilisation.

Dépendance à Internet : Chaque conversion nécessite une connexion réseau. Les applications ne peuvent pas traiter les PDF hors ligne ou pendant les pannes de réseau.

Limites de débit et limitation de bande passante : les appels d'API peuvent être limités pendant les périodes de forte utilisation, ce qui peut impacter les performances de l'application.

Disponibilité du service : Votre application dépend de la disponibilité et du bon fonctionnement d'un service tiers.

Dépendance vis-à-vis du fournisseur : les modifications d'API peuvent interrompre votre intégration sans préavis, nécessitant des mises à jour de code réactives.

IronPDF vs PDFmyURL: Comparaison des fonctionnalités

La compréhension des différences architecturales aide les décideurs techniques à évaluer l'investissement dans la migration :

Aspect	PDFmyURL	IronPDF
Lieu de traitement	Serveurs externes	Local (votre serveur)
Type	API Wrapper	bibliothèque .NET
Authentication	Clé API par demande	Clé de licence unique
Réseau requis	Chaque conversion	Seule la configuration initiale
Modèle de tarification	Abonnement mensuel (20-70 $+)	Licence perpétuelle disponible
Limites de tarifs	Oui (en fonction du plan)	None
Confidentialité des données	Données envoyées à l'extérieur	Les données restent locales
Support HTML/CSS/JS	Rendu côté serveur (conforme W3C)	Moteur Chromium complet
Async Pattern	Requête HTTP (lié au réseau)	Options de synchronisation et d'asynchronisation
Manipulation de PDF	Limité	Suite complète (fusion, division, édition)
Cas d'utilisation	Applications à faible volume	Volume important et entreprise

Démarrage rapide : Migration de PDFmyURLvers IronPDF

La migration peut commencer immédiatement grâce à ces étapes fondamentales.

Étape 1 : Installez IronPDF

PDFmyURL n'a pas de package NuGet — le service est une API REST, et le composant optionnel PDFmyURL.NET.dll est fourni sous forme de téléchargement direct de DLL (pas sur nuget.org). La plupart des intégrations appellent l'API avec WebClient / HttpClient, donc la migration concerne principalement le code, pas les références de package. Si vous avez utilisé l'assembly PDFmyURL.NET.dll, retirez la référence de votre projet après la migration.

# Install IronPDF
dotnet add package IronPdf

# Install IronPDF
dotnet add package IronPdf

SHELL

Étape 2 : Mise à jour des espaces de noms

Remplacez les imports de PDFmyURLpar 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

Étape 3 : initialisation de la licence

Ajouter l'initialisation de la licence au démarrage de l'application :

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

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

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

$vbLabelText $csharpLabel

Exemples de migration de code

Conversion des URL en PDF

L'opération URL-to-PDF démontre les différences fondamentales d'API entre PDFmyURLet IronPDF.

Approche PDFmyURL:

// 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

Approche IronPDF:

// 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 nécessite l'ouverture d'une connexion HTTP à https://pdfmyurl.com/api à chaque conversion, en joignant le jeton license plus le url cible en tant que paramètres de requête (ou formulaire), et écrit le corps de réponse sur le disque. Les erreurs apparaissent sous la forme de WebException basées sur le code de statut HTTP.

IronPDF simplifie cela en trois lignes : créer un ChromePdfRenderer, appeler RenderUrlAsPdf() et utiliser la méthode intégrée SaveAs(). Aucun identifiant par requête n'est nécessaire — la licence est définie une fois au démarrage de l'application.

Pour les scénarios avancés de conversion d'URL en PDF, voir la documentation sur la conversion d'URL en PDF.

La conversion de chaînes HTML en PDF

La conversion de la chaîne HTML montre clairement les différences de modèle.

Approche PDFmyURL:

// 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

Approche IronPDF:

// 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 envoie le HTML brut dans le paramètre de formulaire html à son point de terminaison API et renvoie le PDF rendu comme corps de réponse. Le RenderHtmlAsPdf() d'IronPDF traite tout localement en utilisant le moteur de rendu Chromium.

Explorez le guide de conversion du HTML en PDF pour des options supplémentaires.

Conversion de fichiers HTML avec paramètres de page

La configuration de la taille, de l'orientation et des marges du papier nécessite des approches différentes dans chaque bibliothèque.

Approche PDFmyURL:

// 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

Approche IronPDF:

// 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 configure les pages en ajoutant des paramètres de formulaire comme page_size=A4, orientation=landscape, et les champs de marge (top, bottom, left, right) ainsi qu'un unit (par exemple mm, in).IronPDF fournit des propriétés fortement typées via RenderingOptions avec des énumérations comme PdfPaperSize.A4 et des valeurs entières pour les marges en millimètres.

Référence de mappage de l'API PDFmyURLvers IronPDF

Cette cartographie accélère la migration en indiquant les équivalents directs des API :

Classes de base / Points d'entrée

PDFmyURL	IronPDF
`WebClient` / `HttpClient` envoi à `https://pdfmyurl.com/api`	`ChromePdfRenderer`
`PDFmyURLdotNET.PDFmyURL` (composant .NET optionnel de `PDFmyURL.NET.dll`)	`ChromePdfRenderer`
Paramètres de formulaire / requête	`ChromePdfRenderOptions`
Octets du corps de la réponse HTTP	`PdfDocument`

Méthodes

PDFmyURL	IronPDF
`WebClient.DownloadFile(".../api?license=...&url=...", file)`	`renderer.RenderUrlAsPdf(url).SaveAs(file)`
POST avec le paramètre `html=`	`renderer.RenderHtmlAsPdf(html)`
`File.ReadAllText("input.html")` puis 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)`
Corps de réponse HTTP (`byte[]`)	`pdf.BinaryData`
Flux de réponse HTTP	`new MemoryStream(pdf.BinaryData)`

Options de configuration

Les paramètres de configuration PDFmyURLsont transmis comme des paramètres de formulaire/requête sur la requête HTTP. Le tableau ci-dessous met en correspondance les noms de paramètres réels de PDFmyURLavec le RenderingOptions d'IronPDF.

Paramètre PDFmyURL	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`

Comparaison de l'authentification

PDFmyURL	IronPDF
`license=<key>` paramètre de requête/formulaire sur chaque requête API	`IronPdf.License.LicenseKey = "LICENSE-KEY"`
Jeton de licence par requête	Une seule fois au démarrage
Nécessaire pour chaque appel	Définir une fois au niveau mondial

Problèmes de migration courants et solutions

Problème 1 : Jeton de licence vs Clé de licence

PDFmyURL : Nécessite le jeton license sur chaque requête API.

Solution: Définir la licence IronPDF une fois au démarrage de l'application :

// 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

Sujet 2 : Syntaxe des espaces réservés dans les en-têtes et pieds de page

PDFmyURL : Utilise des jetons comme [page] et [topage] à l'intérieur des paramètres de formulaire header / footer (consultez la référence API en direct pour la liste canonique des jetons).

Solution : Mettez à jour le format des espaces réservés d'IronPDF à l'intérieur 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

Numéro 3 : Async Patterns (en anglais)

PDFmyURL : Est un appel HTTP à distance ; typiquement invoqué avec HttpClient.PostAsync contre pdfmyurl.com/api.

Solution :IronPDF est en cours d'exécution et synchrone par défaut ; enveloppez pour async si nécessaire :

// 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

Edition 4 : Gestion des erreurs

PDFmyURL : Les échecs au niveau HTTP (licence invalide, limite de débit, erreur réseau, service indisponible) apparaissent sous forme de WebException / codes de statut de non-réussite.

Solution : Mettre à jour les blocs try-catch pour les exceptions typées de IronPDF:

// 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

Numéro 5 : Modèle de configuration

PDFmyURL : La configuration est passée comme paramètres de formulaire/de requête sur la requête HTTP.

Solution: Utiliser des propriétés RenderingOptions fortement typées :

// 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

Liste de contrôle pour la migration vers PDFmyURL

Tâches préalables à la migration

Auditez votre base de code pour identifier toute utilisation de PDFmyURL:

# 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

Documenter les paramètres de configuration actuels utilisés (taille de page, orientation, marges, en-tête/pied de page, etc.). Planifier le stockage des clés de licence à l'aide de variables d'environnement.

Tâches de mise à jour du code

Retirez la référence optionnelle PDFmyURL.NET.dll si vous l'avez utilisée (aucun package NuGet n'existe à désinstaller)
Installer le package NuGet IronPDF
Mise à jour de toutes les importations d'espaces de noms
Remplacez le jeton license par requête par IronPdf.License.LicenseKey
Convertissez les paramètres de formulaire/requête en propriétés RenderingOptions
Mettez à jour la syntaxe des espaces réservés dans les en-têtes/pieds de page (par exemple, [page] → {page}, [topage] → {total-pages})
Mettez à jour le code de gestion des erreurs (WebException → exceptions typées IronPDF)
Ajouter l'initialisation de la licence IronPDF au démarrage

Test de post-migration

Après la migration, vérifiez ces aspects :

Testez la qualité de la sortie PDF en fonction des attentes
Vérifier que les modèles asynchrones fonctionnent correctement
Comparer la fidélité du rendu avec le résultat précédent
Testez le bon rendu de toutes les variantes du modèle
Valider les paramètres de la page (taille, orientation, marges)
Installer les dépendances Linux en cas de déploiement sur des serveurs Linux

Avantages clés de la migration vers IronPDF

Le passage de PDFmyURLà IronPDF présente plusieurs avantages décisifs :

Confidentialité totale : vos documents ne quittent jamais votre serveur. Tous les traitements sont effectués localement, ce qui élimine les problèmes de sécurité des données pour les contenus sensibles.

Coût unique : l'option de licence perpétuelle élimine les frais d'abonnement récurrents. Fini les paiements mensuels quel que soit le volume d'utilisation.

Fonctionnement hors ligne : fonctionne sans connexion Internet après la configuration initiale. Les pannes de réseau n'ont aucun impact sur la génération de PDF.

Aucune limite de débit : Traitez un nombre illimité de documents sans vous soucier des limitations de débit.

Latence réduite : l'absence de surcharge réseau se traduit par des conversions plus rapides, notamment pour les applications à volume élevé.

Contrôle total : vous contrôlez l'environnement de traitement, et non un service tiers.

Moteur Chromium moderne : prise en charge complète de CSS3 et JavaScript avec le même moteur de rendu que celui du navigateur Chrome.

Développement Actif : Les mises à jour régulières de IronPDF assurent la compatibilité avec les versions modernes actuelles de .NET.

Veuillez noterPDFmyURL est une marque déposée de son propriétaire respectif. Ce site n'est pas affilié, soutenu ou sponsorisé par PDFmyURL. Tous les noms de produits, logos et marques sont la propriété de leurs propriétaires respectifs. Les comparaisons sont à titre informatif uniquement et reflètent les informations publiquement disponibles au moment de l'écriture.

Curtis Chau

Discutez maintenant avec l'équipe d'ingénierie

Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Articles connexes

Mis à jour19 juillet 2026

Comment convertir HTML en PDF avec C# en .NET 10 | IronPDF

Ce tutoriel vidéo vous guide tout au long du processus de génération de documents PDF de haute qualité directement à partir de HTML à l'aide d'IronPDF for .NET. Vous apprendrez comment IronPDF rend efficacement le HTML, le CSS et les images pour produire des PDF professionnels avec facilité et efficacité.

Mis à jour19 juillet 2026

Comment définir des tailles de papier personnalisées pour les PDF en utilisant C# | IronPDF

Découvrez comment rendre des fichiers PDF avec des tailles de papier personnalisées en utilisant C# et IronPDF. Cette vidéo vous guide à travers la génération de PDF adaptés à des modèles non standards, idéale pour créer des documents personnalisés tels que des invitations, des affiches ou des rapports personnalisés. Améliorez votre processus de création de documents avec facilité.

Mis à jour19 juillet 2026

Comment transformer des pages PDF avec IronPDF en C# | IronPDF

Ce tutoriel vidéo fournit un guide complet sur l'utilisation d'IronPDF for .NET pour manipuler des pages PDF. Apprenez des techniques essentielles telles que la rotation, la mise à l'échelle et le repositionnement de pages dans des documents PDF existants, afin d'améliorer vos capacités de gestion et d'édition de documents.

Comment utiliser le moteur IronPDF dans Docker | IronPDF

Comment ajouter une signature numé...

Mise en avant du client :

Projecteur sur les Développeurs:

Webinaires:

Essai gratuit de 30 jours

Comment convertir un code QR en PDF en C# | IronPDF

Pourquoi migrer de PDFmyURL

IronPDF vs PDFmyURL: Comparaison des fonctionnalités

Démarrage rapide : Migration de PDFmyURLvers IronPDF

Étape 1 : Installez IronPDF

Étape 2 : Mise à jour des espaces de noms

Étape 3 : initialisation de la licence

Exemples de migration de code

Conversion des URL en PDF

La conversion de chaînes HTML en PDF

Conversion de fichiers HTML avec paramètres de page

Référence de mappage de l'API PDFmyURLvers IronPDF

Classes de base / Points d'entrée

Méthodes

Options de configuration

Comparaison de l'authentification

Problèmes de migration courants et solutions

Problème 1 : Jeton de licence vs Clé de licence

Sujet 2 : Syntaxe des espaces réservés dans les en-têtes et pieds de page

Numéro 3 : Async Patterns (en anglais)

Edition 4 : Gestion des erreurs

Numéro 5 : Modèle de configuration

Liste de contrôle pour la migration vers PDFmyURL

Tâches préalables à la migration

Tâches de mise à jour du code

Test de post-migration

Avantages clés de la migration vers IronPDF

Votre clé de licence a été livrée dans votre boîte de réception

Votre demande de démo est en cours.

Équipe de soutien Iron

Essai gratuit de 30 jours

Comment convertir un code QR en PDF en C# | IronPDF

Pourquoi migrer de PDFmyURL

IronPDF vs PDFmyURL: Comparaison des fonctionnalités

Démarrage rapide : Migration de PDFmyURLvers IronPDF

Étape 1 : Installez IronPDF

Étape 2 : Mise à jour des espaces de noms

Étape 3 : initialisation de la licence

Exemples de migration de code

Conversion des URL en PDF

La conversion de chaînes HTML en PDF

Conversion de fichiers HTML avec paramètres de page

Référence de mappage de l'API PDFmyURLvers IronPDF

Classes de base / Points d'entrée

Méthodes

Options de configuration

Comparaison de l'authentification

Problèmes de migration courants et solutions

Problème 1 : Jeton de licence vs Clé de licence

Sujet 2 : Syntaxe des espaces réservés dans les en-têtes et pieds de page

Numéro 3 : Async Patterns (en anglais)

Edition 4 : Gestion des erreurs

Numéro 5 : Modèle de configuration

Liste de contrôle pour la migration vers PDFmyURL

Tâches préalables à la migration

Tâches de mise à jour du code

Test de post-migration

Avantages clés de la migration vers IronPDF

Articles connexes

Comment convertir HTML en PDF avec C# en .NET 10 | IronPDF

Comment définir des tailles de papier personnalisées pour les PDF en utilisant C# | IronPDF

Comment transformer des pages PDF avec IronPDF en C# | IronPDF

Étape suivante : Commencer l'essai gratuit de 30 jours

Thank You

Étape suivante : Commencer l'essai gratuit de 30 jours

Vous souhaitez déployer IronSuite GRATUITEMENT sur un projet en production ?

Qu'est-ce qui est inclus ?

Votre clé de licence a été livrée dans votre boîte de réception

Votre demande de démo est en cours.

De confiance par des millions d'ingénieurs dans le monde entier

Équipe de soutien Iron