Ícone de mensagem
Ir para o conteúdo do rodapé
  1. IronPDF
  2. Blog do IronPDF
  3. Guias de Migração
  4. Migração do pdfmyurl para o ironpdf
GUIAS DE MIGRAçãO

Como migrar do PDFmyURL para o IronPDF em C#

Curtis Chau
Curtis Chau
Atualizado:

O PDFmyURL é 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 do PDFmyURL para 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 do PDFmyURL apresenta 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 da PDFmyURL — contratos confidenciais, relatórios financeiros e dados pessoais são todos processados ​​externamente.

Custos contínuos de assinatura: a partir de US$ 39/mês, os custos anuais ultrapassam US$ 468/ano sem aquisição do imóvel. Este modelo de assinatura implica em despesas contínuas, 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 (a partir de US$ 39) Licença perpétua disponível
Limites de taxa Sim (dependendo do plano) Nenhum
Privacidade de dados Dados enviados externamente Os dados permanecem locais.
Suporte a HTML/CSS/JS Compatível com W3C Motor totalmente cromado
Padrão Assíncrono Obrigatório (somente assíncrono) 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 do PDFmyURL para o IronPDF

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

Passo 1: Substituir pacotes NuGet

Remover pacotes PDFmyURL:

# Remove PDFmyURL packages
dotnet remove package PdfMyUrl
dotnet remove package Pdfcrowd
# Remove PDFmyURL packages
dotnet remove package PdfMyUrl
dotnet remove package Pdfcrowd
SHELL

Instale o IronPDF:

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

Etapa 2: Atualizar Namespaces

Substitua os namespaces PDFmyURL por IronPDF:

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

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 do PDFmyURL e do IronPDF.

Abordagem do PDFmyURL:

// Install PDFmyURL SDK
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 PDFmyURL SDK
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 = 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

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

O PDFmyURL exige a criação de um HtmlToPdfClient com nome de usuário e credenciais de chave de API para cada solicitação de conversão e, em seguida, a chamada de convertUrlToFile() com a URL e o caminho de saída. Toda a operação deve ser envolvida em um bloco try-catch para o tipo personalizado Error do PDFmyURL.

O IronPDF simplifica isso para três linhas: criar um ChromePdfRenderer, chamar RenderUrlAsPdf() e usar o método integrado SaveAs(). Não são necessárias credenciais por solicitação — a licença é definida uma única vez, na inicialização do aplicativo.

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:

// Install PDFmyURL SDK
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 PDFmyURL SDK
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

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

O PDFmyURL usa convertStringToFile(), que envia o conteúdo HTML para servidores externos para processamento. 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:

// Install PDFmyURL SDK
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 PDFmyURL SDK
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

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

O PDFmyURL usa métodos setter com parâmetros de string como setPageSize("A4") e setMarginTop("10mm"). IronPDF fornece propriedades fortemente tipadas através de RenderingOptions com enums como PdfPaperSize.A4 e valores inteiros para margens em milímetros.

Referência de mapeamento da API PDFmyURL para o IronPDF

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

Aulas principais

PDFmyURL IronPDF
HtmlToPdfClient ChromePdfRenderer
PdfMyUrlClient ChromePdfRenderer
Objeto de resposta da API PdfDocument

Métodos

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

Opções de configuração

PDFmyURL (métodos setXxx) IronPDF (Opções de renderização)
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

Comparação de Autenticação

PDFmyURL IronPDF
new HtmlToPdfClient("username", "apikey") IronPdf.License.LicenseKey = "LICENSE-KEY"
Chave de API por solicitaçã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: Chave de API vs. Chave de Licença

PDFmyURL: Requer credenciais para cada solicitação de conversão.

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

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

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

PDFmyURL: Usa os marcadores de posição {page_number} e {total_pages}.

Solução: Atualize para o formato de espaço reservado do 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

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

PDFmyURL: Requer padrões async/await.

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

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

Problema 4: Tratamento de erros

PDFmyURL: Usa o tipo de exceção personalizado Pdfcrowd.Error.

Solução: Atualize os blocos catch para exceções do IronPDF :

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

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

PDFmyURL: Utiliza métodos setter com valores de string.

Solução: Utilize propriedades RenderingOptions fortemente tipadas:

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

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:

# Find PDFmyURL usage
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 PDFmyURL usage
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

Documente as opções de configuração atuais em uso. Planeje o armazenamento da chave de licença usando variáveis ​​de ambiente.

Tarefas de atualização de código

  1. Remova os pacotes NuGet PDFmyURL/Pdfcrowd.
  2. Instale o pacote NuGet IronPDF
  3. Atualize todas as importações de namespace
  4. Substitua a autenticação por chave de API pela chave de licença do IronPDF.
  5. Converter métodos setter em propriedades RenderingOptions
  6. Atualizar a sintaxe dos marcadores de posição nos cabeçalhos/rodapés ({page_number} → {page}, {total_pages} → {total-pages})
  7. Atualizar o código de tratamento de erros para tipos de exceção do IronPDF
  8. 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 do PDFmyURL para 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: À medida que a adoção do .NET 10 e do C# 14 aumenta até 2026, as atualizações regulares do IronPDF garantem a compatibilidade com as versões atuais e futuras do .NET .

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

Leia mais

Artigos relacionados

Teste grátis por 30 dias → Produto completo. Sem limites. Sem cartão. Teste gratuito

Equipe de suporte de ferro

Estamos online 24 horas por dia, 5 dias por semana.
Bater papo
E-mail
Liga para mim