Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. Guides de migration
  4. migration de pdfmyurl vers IronPDF
GUIDES DE MIGRATION

Comment migrer de PDFmyURL vers IronPDF en C#

Curtis Chau
Curtis Chau
Mis à jour:

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.

Frais d'abonnement récurrents : à partir de 39 $/mois, les frais annuels dépassent 468 $/an sans acquisition. Ce modèle d'abonnement implique des dépenses continues, indépendamment de votre consommation.

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 (39 $+) Licence perpétuelle disponible
Limites de tarifs Oui (en fonction du plan) Aucun
Confidentialité des données Données envoyées à l'extérieur Les données restent locales
Support HTML/CSS/JS Conforme au W3C Moteur Chromium complet
Async Pattern Obligatoire (asynchrone uniquement) 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 : Remplacer les paquets NuGet

Supprimer les paquets PDFmyURL:

# Remove PDFmyURLpackages
dotnet remove package PdfMyUrl
dotnet remove package Pdfcrowd
# Remove PDFmyURLpackages
dotnet remove package PdfMyUrl
dotnet remove package Pdfcrowd
SHELL

InstallezIronPDF:

# Install IronPDF
dotnet add package IronPdf
# Install IronPDF
dotnet add package IronPdf
SHELL

Étape 2 : Mise à jour des espaces de noms

Remplacez les espaces de noms PDFmyURLparIronPDF:

// Before: PDFmyURL
using PdfMyUrl;
using Pdfcrowd;

// After: IronPDF
using IronPdf;
using IronPdf.Rendering;
// Before: PDFmyURL
using PdfMyUrl;
using Pdfcrowd;

// After: IronPDF
using IronPdf;
using IronPdf.Rendering;
' Before: PDFmyURL
Imports PdfMyUrl
Imports Pdfcrowd

' After: IronPDF
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:

// Install PDFmyURLSDK
using System;
using Pdfcrowd;

class Example
{
    static void Main()
    {
        try
        {
            var client = new HtmlToPdfClient("username", "apikey");
            client.convertUrlToFile("https://example.com", "output.pdf");
        }
        catch(Error why)
        {
            Console.WriteLine("Error: " + why);
        }
    }
}
// Install PDFmyURLSDK
using System;
using Pdfcrowd;

class Example
{
    static void Main()
    {
        try
        {
            var client = new HtmlToPdfClient("username", "apikey");
            client.convertUrlToFile("https://example.com", "output.pdf");
        }
        catch(Error why)
        {
            Console.WriteLine("Error: " + why);
        }
    }
}
Imports System
Imports Pdfcrowd

Class Example
    Shared Sub Main()
        Try
            Dim client As New HtmlToPdfClient("username", "apikey")
            client.convertUrlToFile("https://example.com", "output.pdf")
        Catch why As [Error]
            Console.WriteLine("Error: " & why.ToString())
        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 la création d'un HtmlToPdfClient avec un nom d'utilisateur et des informations d'identification de clé API pour chaque demande de conversion, puis l'appel de convertUrlToFile() avec l'URL et le chemin de sortie. L'opération entière doit être enveloppée dans un bloc try-catch pour le type personnalisé Error de PDFmyURL.

IronPDF simplifie cela en trois lignes : créer un ChromePdfRenderer, appeler RenderUrlAsPdf() et utiliser la méthode intégrée SaveAs(). Il n'est pas nécessaire de fournir des informations d'identification par demande : 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:

// Install PDFmyURLSDK
using System;
using Pdfcrowd;

class Example
{
    static void Main()
    {
        try
        {
            var client = new HtmlToPdfClient("username", "apikey");
            string html = "<html><body><h1>Hello World</h1></body></html>";
            client.convertStringToFile(html, "output.pdf");
        }
        catch(Error why)
        {
            Console.WriteLine("Error: " + why);
        }
    }
}
// Install PDFmyURLSDK
using System;
using Pdfcrowd;

class Example
{
    static void Main()
    {
        try
        {
            var client = new HtmlToPdfClient("username", "apikey");
            string html = "<html><body><h1>Hello World</h1></body></html>";
            client.convertStringToFile(html, "output.pdf");
        }
        catch(Error why)
        {
            Console.WriteLine("Error: " + why);
        }
    }
}
Imports System
Imports Pdfcrowd

Class Example
    Shared Sub Main()
        Try
            Dim client = New HtmlToPdfClient("username", "apikey")
            Dim html As String = "<html><body><h1>Hello World</h1></body></html>"
            client.convertStringToFile(html, "output.pdf")
        Catch why As Error
            Console.WriteLine("Error: " & why.ToString())
        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 utilise convertStringToFile() qui envoie le contenu HTML à des serveurs externes pour traitement.IronPDFtraite tout localement à l'aide du 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:

// Install PDFmyURLSDK
using System;
using Pdfcrowd;

class Example
{
    static void Main()
    {
        try
        {
            var client = new HtmlToPdfClient("username", "apikey");
            client.setPageSize("A4");
            client.setOrientation("landscape");
            client.setMarginTop("10mm");
            client.convertFileToFile("input.html", "output.pdf");
        }
        catch(Error why)
        {
            Console.WriteLine("Error: " + why);
        }
    }
}
// Install PDFmyURLSDK
using System;
using Pdfcrowd;

class Example
{
    static void Main()
    {
        try
        {
            var client = new HtmlToPdfClient("username", "apikey");
            client.setPageSize("A4");
            client.setOrientation("landscape");
            client.setMarginTop("10mm");
            client.convertFileToFile("input.html", "output.pdf");
        }
        catch(Error why)
        {
            Console.WriteLine("Error: " + why);
        }
    }
}
Imports System
Imports Pdfcrowd

Class Example
    Shared Sub Main()
        Try
            Dim client = New HtmlToPdfClient("username", "apikey")
            client.setPageSize("A4")
            client.setOrientation("landscape")
            client.setMarginTop("10mm")
            client.convertFileToFile("input.html", "output.pdf")
        Catch why As Error
            Console.WriteLine("Error: " & why.ToString())
        End Try
    End Sub
End Class
$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 utilise des méthodes setter avec des paramètres de chaîne comme setPageSize("A4") et setMarginTop("10mm").IronPDFfournit 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

PDFmyURL IronPDF
HtmlToPdfClient ChromePdfRenderer
PdfMyUrlClient ChromePdfRenderer
Objet de réponse API PdfDocument

Méthodes

PDFmyURL IronPDF
client.convertUrlToFile(url, file) renderer.RenderUrlAsPdf(url).SaveAs(file)
client.convertStringToFile(html, file) renderer.RenderHtmlAsPdf(html).SaveAs(file)
client.convertFileToFile(input, output) renderer.RenderHtmlFileAsPdf(input).SaveAs(output)
response.GetBytes() pdf.BinaryData
response.GetStream() pdf.Stream

Options de configuration

PDFmyURL(méthodes setXxx) IronPDF(RenderingOptions)
setPageSize("A4") .PaperSize = PdfPaperSize.A4
setPageSize("Letter") .PaperSize = PdfPaperSize.Letter
setOrientation("landscape") .PaperOrientation = PdfPaperOrientation.Landscape
setOrientation("portrait") .PaperOrientation = PdfPaperOrientation.Portrait
setMarginTop("10mm") .MarginTop = 10
setMarginBottom("10mm") .MarginBottom = 10
setMarginLeft("10mm") .MarginLeft = 10
setMarginRight("10mm") .MarginRight = 10
setHeaderHtml(html) .HtmlHeader = new HtmlHeaderFooter { HtmlFragment = html }
setFooterHtml(html) .HtmlFooter = new HtmlHeaderFooter { HtmlFragment = html }
setJavaScriptDelay(500) .RenderDelay = 500
setDisableJavaScript(true) .EnableJavaScript = false
setUsePrintMedia(true) .CssMediaType = PdfCssMediaType.Print

Comparaison de l'authentification

PDFmyURL IronPDF
new HtmlToPdfClient("username", "apikey") IronPdf.License.LicenseKey = "LICENSE-KEY"
Clé API par demande 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

Enjeu 1 : Clé API vs clé de licence

PDFmyURL: Requiert des informations d'identification pour chaque demande de conversion.

Solution: Définir la licenceIronPDFune fois au démarrage de l'application :

// PDFmyURL: API key per request
var client = new HtmlToPdfClient("username", "apikey");

// IronPDF: One-time license at startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
// Set once, typically in Program.cs or Startup.cs
// PDFmyURL: API key per request
var client = new HtmlToPdfClient("username", "apikey");

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

' PDFmyURL: API key per request
Dim client As New HtmlToPdfClient("username", "apikey")

' IronPDF: One-time license at startup
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 les espaces réservés {page_number} et {total_pages}.

Solution:Mise à jour du format de remplacement d'IronPDF :

// PDFmyURL: "Page {page_number} of {total_pages}"
// IronPDF: "Page {page} of {total-pages}"
// PDFmyURL: "Page {page_number} of {total_pages}"
// IronPDF: "Page {page} of {total-pages}"
' PDFmyURL: "Page {page_number} of {total_pages}"
' IronPDF: "Page {page} of {total-pages}"
$vbLabelText   $csharpLabel

Numéro 3 : Async Patterns (en anglais)

PDFmyURL: Requiert des modèles async/await.

Solution:IronPDFest synchrone par défaut ; enveloppez pour async si nécessaire :

// PDFmyURL: Native async
var response = await client.ConvertUrlAsync(url);

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

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

' PDFmyURL: Native async
Dim response = Await client.ConvertUrlAsync(url)

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

Edition 4 : Gestion des erreurs

PDFmyURL : Utilise un type d'exception personnalisé Pdfcrowd.Error.

Solution:Mettre à jour les blocs de capture pour les exceptionsIronPDF:

// PDFmyURL: Pdfcrowd.Error
catch (Pdfcrowd.Error e) { ... }

// IronPDF: Standard exceptions
catch (IronPdf.Exceptions.IronPdfRenderingException e) { ... }
// PDFmyURL: Pdfcrowd.Error
catch (Pdfcrowd.Error e) { ... }

// IronPDF: Standard exceptions
catch (IronPdf.Exceptions.IronPdfRenderingException e) { ... }
$vbLabelText   $csharpLabel

Numéro 5 : Modèle de configuration

PDFmyURL: Utilise des méthodes setter avec des valeurs de chaîne.

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

// PDFmyURL: Setter methods
client.setPageSize("A4");
client.setOrientation("landscape");

// IronPDF: Properties with enums
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
// PDFmyURL: Setter methods
client.setPageSize("A4");
client.setOrientation("landscape");

// IronPDF: Properties with enums
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
' PDFmyURL: Setter methods
client.setPageSize("A4")
client.setOrientation("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 PDFmyURLusage
grep -r "PdfMyUrl\|Pdfcrowd\|HtmlToPdfClient" --include="*.cs" .

# Find API key references
grep -r "apikey\|api-key\|api_key" --include="*.cs" --include="*.json" --include="*.config" .

# Find placeholder patterns to migrate
grep -r "{page_number}\|{total_pages}" --include="*.cs" .
# Find PDFmyURLusage
grep -r "PdfMyUrl\|Pdfcrowd\|HtmlToPdfClient" --include="*.cs" .

# Find API key references
grep -r "apikey\|api-key\|api_key" --include="*.cs" --include="*.json" --include="*.config" .

# Find placeholder patterns to migrate
grep -r "{page_number}\|{total_pages}" --include="*.cs" .
SHELL

Documenter les options de configuration actuelles utilisées. Planifier le stockage des clés de licence à l'aide de variables d'environnement.

Tâches de mise à jour du code

  1. Supprimer les paquets NuGet PDFmyURL/Pdfcrowd
  2. Installer le paquet NuGet IronPDF
  3. Mise à jour de toutes les importations d'espaces de noms
  4. Remplacer l'authentification par clé API par une clé de licence IronPDF
  5. Convertir les méthodes setter en propriétés RenderingOptions
  6. Mettre à jour la syntaxe des espaces réservés dans les en-têtes/pieds de page ({page_number} → {page}, {total_pages} → {total-pages})
  7. Mise à jour du code de gestion des erreurs pour les types d'exception IronPDF
  8. Ajouter l'initialisation de la licenceIronPDFau 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àIronPDFpré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 : Avec l'adoption croissante de .NET 10 et C# 14 jusqu'en 2026, les mises à jour régulières d'IronPDF garantissent la compatibilité avec les versions actuelles et futures de .NET .

Curtis Chau
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 ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Essai gratuit

Équipe de soutien Iron

Nous sommes en ligne 24 heures sur 24, 5 jours sur 7.
Chat
Email
Appelez-moi