GUIAS DE MIGRAçãO

Como migrar do PDFmyURL para o IronPDF em C#

Atualizado:maio 18, 2026

OPDFmyURLé um serviço de API baseado na nuvem, projetado para converter URLs e conteúdo HTML em documentos PDF. O serviço processa todas as conversões em servidores externos, proporcionando um caminho de integração simples que requer infraestrutura local mínima. No entanto, essa arquitetura dependente da nuvem gera preocupações significativas para aplicações de produção que lidam com dados sensíveis, exigem capacidade offline ou precisam evitar custos contínuos de assinatura.

Este guia fornece um caminho completo de migração doPDFmyURLpara o IronPDF, com instruções passo a passo, comparações de código e exemplos práticos para desenvolvedores .NET profissionais que estejam avaliando essa transição.

Por que migrar do PDFmyURL?

O modelo de processamento em nuvem doPDFmyURLapresenta diversos desafios que as equipes de desenvolvimento devem considerar:

Privacidade e segurança de dados: Todos os documentos que você converte são enviados e processados pelos servidores daPDFmyURL— contratos confidenciais, relatórios financeiros e dados pessoais são todos processados externamente.

Custos de Assinatura Continuada: Planos começam em $20/mês (Starter, 500 PDFs), $40/mês (Professional, 2.000 PDFs), e $70/mês (Advanced, 5.000 PDFs), sem propriedade em qualquer nível. Este modelo de assinatura significa despesa contínua independentemente dos padrões de uso.

Dependência da Internet: Toda conversão requer conectividade de rede. Os aplicativos não conseguem processar PDFs offline ou durante interrupções de rede.

Limites de taxa e restrição: as chamadas de API podem ser limitadas durante períodos de pico de uso, o que pode afetar o desempenho do aplicativo.

Disponibilidade do serviço: Sua aplicação depende de um serviço de terceiros estar online e funcionando.

Dependência de fornecedor: alterações na API podem interromper sua integração sem aviso prévio, exigindo atualizações reativas de código.

IronPDF vs PDFmyURL: Comparação de Recursos

Compreender as diferenças arquitetônicas ajuda os responsáveis pelas decisões técnicas a avaliar o investimento em migração:

Aspecto	PDFmyURL	IronPDF
Local de processamento	Servidores externos	Local (seu servidor)
Tipo	Wrapper de API	Biblioteca .NET
Autenticação	Chave de API por solicitação	Chave de licença única
É necessária conexão de rede.	Cada conversão	Apenas configuração inicial
Modelo de Preços	Assinatura mensal ($20–$70+)	Licença perpétua disponível
Limites de taxa	Sim (dependendo do plano)	None
Privacidade de dados	Dados enviados externamente	Os dados permanecem locais.
Suporte a HTML/CSS/JS	Renderização do lado do servidor (conforme W3C)	Motor totalmente cromado
Padrão Assíncrono	Requisição HTTP (limitada à rede)	Opções síncronas e assíncronas
Manipulação de PDF	Limitado	Conjunto completo (mesclar, dividir, editar)
Caso de uso	Aplicações de baixo volume	Alto volume e empresarial

Guia rápido: Migração doPDFmyURLpara o IronPDF

A migração pode começar imediatamente com esses passos fundamentais.

Passo 1: Instale o IronPDF

PDFmyURL não possui pacote NuGet — o serviço é uma API REST, e o componente opcional PDFmyURL.NET.dll é fornecido como download direto de DLL (não em nuget.org). A maioria das integrações chama a API com WebClient / HttpClient, então a migração é principalmente sobre o código, não sobre referências de pacote. Se você usou o assembly PDFmyURL.NET.dll, remova a referência do seu projeto após a migração.

# Install IronPDF
dotnet add package IronPdf

# Install IronPDF
dotnet add package IronPdf

SHELL

Etapa 2: Atualizar Namespaces

Substituir importaçõesPDFmyURLpor 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

' After: IronPDF
Imports IronPdf
Imports IronPdf.Rendering

$vbLabelText $csharpLabel

Etapa 3: Inicializar a licença

Adicionar inicialização de licença na inicialização do aplicativo:

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

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

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

$vbLabelText $csharpLabel

Exemplos de migração de código

Converter URLs em PDF

A operação de conversão de URL para PDF demonstra as diferenças fundamentais entre as APIs doPDFmyURLe do IronPDF.

Abordagem do 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

Module Example

    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 Module

$vbLabelText $csharpLabel

Abordagem 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 exige a abertura de uma conexão HTTP para https://pdfmyurl.com/api em toda conversão, anexando o token license mais o alvo url como parâmetros da consulta (ou formulário), e escrevendo o corpo da resposta em disco. Os erros surgem como WebException com base no código de status HTTP.

IronPDF simplifica isso em três linhas: criar um ChromePdfRenderer, chamar RenderUrlAsPdf(), e usar o método embutido SaveAs(). Nenhuma credencial por requisição é necessária — a licença é configurada uma vez no início da aplicação.

Para cenários avançados de URL para PDF, consulte a documentação de URL para PDF .

Convertendo strings HTML em PDF

A conversão de strings HTML mostra claramente as diferenças de padrão.

Abordagem do 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

Abordagem 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 envia o HTML bruto no parâmetro de formulário html para seu endpoint API e retorna o PDF renderizado como o corpo da resposta. O RenderHtmlAsPdf() do IronPDF processa tudo localmente usando o mecanismo de renderização Chromium.

Consulte o guia de conversão de HTML para PDF para obter opções adicionais.

Conversão de arquivos HTML com configurações de página

A configuração do tamanho, orientação e margens do papel requer abordagens diferentes em cada biblioteca.

Abordagem do 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

Class Example
    Shared 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 Class

$vbLabelText $csharpLabel

Abordagem 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 configura páginas adicionando parâmetros de formulário como page_size=A4, orientation=landscape, e os campos de margem (top, bottom, left, right) junto com um unit (por exemplo, mm, in).IronPDF fornece propriedades fortemente tipadas por meio de RenderingOptions com enums como PdfPaperSize.A4 e valores inteiros para margens em milímetros.

Referência de mapeamento da APIPDFmyURLpara o IronPDF

Este mapeamento acelera a migração ao mostrar equivalentes diretos da API:

Classes Centrais / Pontos de Entrada

PDFmyURL	IronPDF
`WebClient` / `HttpClient` postagem para `https://pdfmyurl.com/api`	`ChromePdfRenderer`
`PDFmyURLdotNET.PDFmyURL` (componente opcional .NET de `PDFmyURL.NET.dll`)	`ChromePdfRenderer`
Parâmetros de formulário / query	`ChromePdfRenderOptions`
Bytes de corpo de resposta HTTP	`PdfDocument`

Métodos

PDFmyURL	IronPDF
`WebClient.DownloadFile(".../api?license=...&url=...", file)`	`renderer.RenderUrlAsPdf(url).SaveAs(file)`
POST com parâmetro `html=`	`renderer.RenderHtmlAsPdf(html)`
`File.ReadAllText("input.html")` então 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)`
Corpo de resposta HTTP (`byte[]`)	`pdf.BinaryData`
Fluxo de resposta HTTP	`new MemoryStream(pdf.BinaryData)`

Opções de configuração

As configurações doPDFmyURLsão passadas como parâmetros de formulário/consulta na solicitação HTTP. A tabela abaixo mapeia nomes reais de parâmetrosPDFmyURLpara RenderingOptions do IronPDF.

ParâmetroPDFmyURL	IronPDF(Opções de renderização)
`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`

Comparação de Autenticação

PDFmyURL	IronPDF
`license=<key>` parâmetro de consulta/formulário em toda solicitação de API	`IronPdf.License.LicenseKey = "LICENSE-KEY"`
Token de licença por requisição	Uma vez na startup
Obrigatório para todas as chamadas	Definido uma vez globalmente

Problemas e soluções comuns em migrações

Questão 1: Token de Licença vs Chave de Licença

PDFmyURL: Requer o token license em toda solicitação de API.

Solução: Defina a licença do IronPDF uma única vez na inicialização do aplicativo:

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

Problema 2: Sintaxe de espaço reservado em cabeçalhos/rodapés

PDFmyURL: Usa tokens como [page] e [topage] dentro dos parâmetros de formulário header / footer (consulte a referência de API ao vivo para a lista canônica de tokens).

Solução: Atualize para o formato placeholder do IronPDF dentro de 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

Edição 3: Padrões Assíncronos

PDFmyURL: É uma chamada HTTP remota; normalmente invocado com HttpClient.PostAsync contra pdfmyurl.com/api.

Solução:IronPDF é in-processo e síncrono por padrão; Se necessário, encapsule para async:

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

Problema 4: Tratamento de erros

PDFmyURL: Falhas de nível HTTP (licença inválida, limite de taxa, erro de rede, serviço indisponível) surgem como WebException / códigos de status de não-sucesso.

Solução: Atualizar blocos de captura para exceções tipadas do 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

Questão 5: Padrão de Configuração

PDFmyURL: A configuração é passada como parâmetros de formulário/query na requisição HTTP.

Solução: Utilize propriedades RenderingOptions fortemente tipadas:

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

Lista de verificação para migração do PDFmyURL

Tarefas pré-migração

Faça uma auditoria em seu código-fonte para identificar todos os usos do PDFmyURL:

# FindPDFmyURLendpoint 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" .

# FindPDFmyURLendpoint 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

Documentar parâmetros de configuração atuais usados (tamanho_da_página, orientação, margens, cabeçalho/rodapé, etc.). Planeje o armazenamento da chave de licença usando variáveis de ambiente.

Tarefas de atualização de código

Remova a referência opcional PDFmyURL.NET.dll se você a usou (não existe pacote NuGet para desinstalar)
Instalar o pacote NuGet do IronPDF
Atualize todas as importações de namespace
Substitua o token license por IronPdf.License.LicenseKey em cada solicitação
Converta parâmetros de formulário/consulta para propriedades RenderingOptions
Atualize a sintaxe do placeholder em cabeçalhos/rodapés (por exemplo, [page] → {page}, [topage] → {total-pages})
Atualize o código de tratamento de erro (WebException → excepciones tipadas de IronPDF)
Adicionar inicialização da licença do IronPDF na inicialização do sistema.

Testes pós-migração

Após a migração, verifique os seguintes aspectos:

A qualidade de saída do PDF de teste corresponde às expectativas.
Verificar se os padrões assíncronos funcionam corretamente.
Comparar a fidelidade da renderização com a saída anterior.
Teste se todas as variações do modelo são renderizadas corretamente.
Validar configurações da página (tamanho, orientação, margens)
Instale as dependências do Linux se estiver implantando em servidores Linux.

Principais benefícios da migração para o IronPDF

A migração doPDFmyURLpara o IronPDF oferece diversas vantagens importantes:

Privacidade total: os documentos nunca saem do seu servidor. Todo o processamento ocorre localmente, eliminando preocupações com a segurança de dados para conteúdo sensível.

Custo único: A opção de licença perpétua elimina as taxas de assinatura recorrentes. Chega de pagamentos mensais, independentemente do volume de uso.

Funcionamento offline: Funciona sem internet após a configuração inicial. Interrupções de rede não afetam a geração de PDFs.

Sem limites de taxa: processe um número ilimitado de documentos sem se preocupar com limitações de velocidade.

Menor latência: Sem sobrecarga de rede, as conversões ficam mais rápidas, especialmente para aplicações de alto volume.

Controle total: você controla o ambiente de processamento, não um serviço de terceiros.

Mecanismo Chromium moderno: suporte completo a CSS3 e JavaScript com o mesmo mecanismo de renderização que alimenta o navegador Chrome.

Desenvolvimento Ativo: As atualizações regulares do IronPDF garantem compatibilidade com versões modernas do .NET.

ObservePDFmyURL é uma marca registrada de seu respectivo proprietário. Este site não é afiliado, endossado ou patrocinado pelo PDFmyURL. Todos os nomes de produtos, logotipos e marcas são propriedade de seus respectivos proprietários. As comparações são apenas para fins informativos e refletem informações disponíveis publicamente no momento da redação.

Curtis Chau

Converse agora mesmo com a equipe de engenharia.

Redator Técnico

Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais ...

Destaque do cliente:

Destaque do desenvolvedor:

Webinários:

Experimente gratuitamente por 30 dias.

Como migrar do PDFmyURL para o IronPDF em C#

Por que migrar do PDFmyURL?

IronPDF vs PDFmyURL: Comparação de Recursos

Guia rápido: Migração doPDFmyURLpara o IronPDF

Passo 1: Instale o IronPDF

Etapa 2: Atualizar Namespaces

Etapa 3: Inicializar a licença

Exemplos de migração de código

Converter URLs em PDF

Convertendo strings HTML em PDF

Conversão de arquivos HTML com configurações de página

Referência de mapeamento da APIPDFmyURLpara o IronPDF

Classes Centrais / Pontos de Entrada

Métodos

Opções de configuração

Comparação de Autenticação

Problemas e soluções comuns em migrações

Questão 1: Token de Licença vs Chave de Licença

Problema 2: Sintaxe de espaço reservado em cabeçalhos/rodapés

Edição 3: Padrões Assíncronos

Problema 4: Tratamento de erros

Questão 5: Padrão de Configuração

Lista de verificação para migração do PDFmyURL

Tarefas pré-migração

Tarefas de atualização de código

Testes pós-migração

Principais benefícios da migração para o IronPDF

Sua chave de licença foi entregue à sua caixa de entrada

Sua solicitação de demonstração está em andamento.

Equipe de Suporte Iron

Experimente gratuitamente por 30 dias.

Como migrar do PDFmyURL para o IronPDF em C#

Por que migrar do PDFmyURL?

IronPDF vs PDFmyURL: Comparação de Recursos

Guia rápido: Migração doPDFmyURLpara o IronPDF

Passo 1: Instale o IronPDF

Etapa 2: Atualizar Namespaces

Etapa 3: Inicializar a licença

Exemplos de migração de código

Converter URLs em PDF

Convertendo strings HTML em PDF

Conversão de arquivos HTML com configurações de página

Referência de mapeamento da APIPDFmyURLpara o IronPDF

Classes Centrais / Pontos de Entrada

Métodos

Opções de configuração

Comparação de Autenticação

Problemas e soluções comuns em migrações

Questão 1: Token de Licença vs Chave de Licença

Problema 2: Sintaxe de espaço reservado em cabeçalhos/rodapés

Edição 3: Padrões Assíncronos

Problema 4: Tratamento de erros

Questão 5: Padrão de Configuração

Lista de verificação para migração do PDFmyURL

Tarefas pré-migração

Tarefas de atualização de código

Testes pós-migração

Principais benefícios da migração para o IronPDF

Artigos relacionados

Como migrar do ZetPDF para o IronPDF em C#

Como migrar do Scryber.Core para o IronPDF em C#

Como migrar do XFINIUM.PDF para o IronPDF em C#

Próximo passo: Inicie o teste gratuito de 30 dias.

Thank You

Próximo passo: Inicie o teste gratuito de 30 dias.

Quer implantar o IronSuite em um projeto real de graça?

O que está incluído?

Sua chave de licença foi entregue à sua caixa de entrada

Sua solicitação de demonstração está em andamento.

Aprovado por milhões de engenheiros em todo o mundo.

Equipe de Suporte Iron