O Processamento de documentos Telerik é fornecido como parte das suites de UI do Telerik e pacotes do DevCraft, oferecendo aos desenvolvedores capacidades de geração de PDFs ao lado do processamento de Word, Excel e PowerPoint. No entanto, à medida que os padrões modernos da web evoluem e os projetos exigem suporte completo a CSS3, Flexbox e Bootstrap, as equipes de desenvolvimento expressaram preocupações sobre as limitações na arquitetura de renderização HTML-para-PDF da Telerik.
Este guia fornece um caminho completo de migração do Processamento de documentos Telerik para o IronPDF, com instruções passo a passo, comparações de código e exemplos práticos extraídos diretamente de cenários reais de migração.
A decisão de migrar do Processamento de documentos Telerik geralmente surge de limitações técnicas que se tornam evidentes ao trabalhar com conteúdo web moderno. Compreender essas limitações ajuda a justificar o esforço de migração e a definir expectativas sobre o que o IronPDF resolve.
Desenvolvedores relataram problemas com o Processamento de documentos Telerik ao lidar com HTML e CSS modernos:
| Emitir | Impacto | Solução IronPDF |
|---|---|---|
| limitações de análise de CSS | Frameworks CSS modernos como o Bootstrap falham | Suporte completo ao CSS do Chromium |
| Conversão de div para parágrafo | Estrutura HTML achatada, quebra de layouts | Renderização direta de HTML |
| Modelo de documento de fluxo | Forças conversão intermediária | Conversão nativa de HTML para PDF |
| Problemas externos de CSS | Seletores complexos ignorados | Suporte completo a arquivos CSS |
| Problemas de memória | OutOfMemoryException relatado em arquivos grandes | Streaming eficiente |
O Processamento de documentos Telerik converte HTML em um modelo intermediário de "Documento de Fluxo" antes de gerar o PDF. Essa decisão arquitetônica cria problemas em cascata:
<div> tornam-se parágrafosConsidere este HTML moderno que utiliza layouts CSS padrão:
<!-- This modern HTML/CSS BREAKS in Processamento de documentos Telerik -->
<div class="container">
<div class="row">
<div class="col-md-6">Column 1</div>
<div class="col-md-6">Column 2</div>
</div>
</div>
<div style="display: flex; gap: 20px;">
<div style="flex: 1;">Flex Item 1</div>
<div style="flex: 1;">Flex Item 2</div>
</div>
<div style="display: grid; grid-template-columns: repeat(3, 1fr);">
<div>Grid Item 1</div>
<div>Grid Item 2</div>
<div>Grid Item 3</div>
</div>No Telerik Document Processing, todos esses layouts são renderizados como parágrafos sequenciais. O layout Bootstrap de duas colunas se transforma em duas linhas de texto. Os itens flexbox se empilham verticalmente. Os itens do CSS Grid aparecem um após o outro.
Os desenvolvedores documentaram diversos problemas de compatibilidade com CSS:
/* ❌ These CSS features DON'T WORK in Processamento de documentos Telerik */
/* Flexbox - Não suportado */
.container { display: flex; }
.item { flex: 1; }
/* CSS Grid - Não suportado */
.grid { display: grid; grid-template-columns: repeat(3, 1fr); }
/* Bootstrap columns - Converted to paragraphs */
.col-md-6 { /* Ignored, becomes linear text */ }
/* CSS Variables - Não suportado */
:root { --primary: #007bff; }
.btn { color: var(--primary); }
/* Complex selectors - Often ignored */
.container > .row:first-child { }
.item:hover { }
.content::before { }
/* Modern units - Limited support */
.box { width: calc(100% - 20px); }
.text { font-size: 1.2rem; }Além das limitações do CSS, desenvolvedores relataram erros OutOfMemoryException ao processar arquivos grandes com o Telerik Document Processing, junto com espaços de cor não suportados e falhas durante a mesclagem de PDFs em alguns cenários. Equipes que trabalham com geração de documentos de alto volume notaram preocupações de estabilidade, valendo a pena avaliar antes de se comprometer com o uso a longo prazo.
Compreender as diferenças entre as funcionalidades ajuda os responsáveis pela tomada de decisões técnicas a avaliar o investimento na migração:
| Recurso | Processamento de documentos Telerik | IronPDF |
|---|---|---|
| Renderização HTML | Conversão de documentos de fluxo | Renderização direta do Chromium |
| Suporte a CSS3 | Limitado, muitas funcionalidades falham | CSS3 completo |
| Flexbox | Não suportado | Apoiado |
| Grade CSS | Não suportado | Apoiado |
| Bootstrap | Quebrado (achatamento de div) | Compatível com Bootstrap 5 |
| CSS externo | Parcial | Apoiado |
| JavaScript | Não suportado | Suporte total |
| Documentos grandes | Foram relatados problemas de memória | Streaming eficiente |
| Complexidade da API | Complexo (provedores, modelos) | Simples (uma classe) |
| Modelo de Licença | Comercial, parte do DevCraft | Licenciamento independente simples |
A migração do Processamento de documentos Telerik para o IronPDF pode começar imediatamente. Aqui está o caminho mais rápido para gerar seu primeiro PDF com o IronPDF.
Remova todos os pacotes de processamento de documentos da Telerik:
# Remove Telerik packages
dotnet remove package Telerik.Documents.Core
dotnet remove package Telerik.Documents.Flow
dotnet remove package Telerik.Documents.Flow.FormatProviders.Pdf
dotnet remove package Telerik.Documents.FixedInstale o IronPDF:
# Install IronPDF
dotnet add package IronPdfSubstitua namespaces da Telerik pelo namespace IronPDF:
// Before (Telerik Document Processing)
using Telerik.Windows.Documents.Flow.FormatProviders.Html;
using Telerik.Windows.Documents.Flow.FormatProviders.Pdf;
using Telerik.Windows.Documents.Flow.Model;
using Telerik.Documents.Primitives;
// After (IronPDF)
using IronPdf;Imports Telerik.Windows.Documents.Flow.FormatProviders.Html
Imports Telerik.Windows.Documents.Flow.FormatProviders.Pdf
Imports Telerik.Windows.Documents.Flow.Model
Imports Telerik.Documents.Primitives
' After (IronPDF)
Imports IronPdfInicialize sua licença ao iniciar o aplicativo:
// Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";' Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"A transição do processamento de documentos Telerik para o IronPDF simplifica drasticamente sua base de código.
Antes (Processamento de Documentos Telerik):
using Telerik.Windows.Documents.Flow.FormatProviders.Html;
using Telerik.Windows.Documents.Flow.FormatProviders.Pdf;
using Telerik.Windows.Documents.Flow.Model;
HtmlFormatProvider htmlProvider = new HtmlFormatProvider();
RadFlowDocument document = htmlProvider.Import(htmlContent);
PdfFormatProvider pdfProvider = new PdfFormatProvider();
byte[] pdfBytes = pdfProvider.Export(document);
File.WriteAllBytes("output.pdf", pdfBytes);Imports Telerik.Windows.Documents.Flow.FormatProviders.Html
Imports Telerik.Windows.Documents.Flow.FormatProviders.Pdf
Imports Telerik.Windows.Documents.Flow.Model
Dim htmlProvider As New HtmlFormatProvider()
Dim document As RadFlowDocument = htmlProvider.Import(htmlContent)
Dim pdfProvider As New PdfFormatProvider()
Dim pdfBytes As Byte() = pdfProvider.Export(document)
File.WriteAllBytes("output.pdf", pdfBytes)Após (IronPDF):
using IronPdf;
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs("output.pdf");Imports IronPdf
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
pdf.SaveAs("output.pdf")A diferença é imediatamente aparente: 3 linhas de código IronPDF substituem mais de 15 linhas de código Telerik Document Processing. Mais importante ainda, a versão IronPDF renderizará corretamente o CSS moderno que o modelo Flow Document da Telerik não consegue processar.
Este é o caso de uso mais comum para a geração de PDFs. As diferenças arquitetônicas entre o Processamento de documentos Telerik e o IronPDF ficam claras nesta comparação.
Abordagem de processamento de documentos da Telerik:
// NuGet: Install-Package Telerik.Documents.Flow
// NuGet: Install-Package Telerik.Documents.Flow.FormatProviders.Pdf
using Telerik.Windows.Documents.Flow.FormatProviders.Html;
using Telerik.Windows.Documents.Flow.FormatProviders.Pdf;
using Telerik.Windows.Documents.Flow.Model;
using System.IO;
string html = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";
HtmlFormatProvider htmlProvider = new HtmlFormatProvider();
RadFlowDocument document = htmlProvider.Import(html);
PdfFormatProvider pdfProvider = new PdfFormatProvider();
using (FileStream output = File.OpenWrite("output.pdf"))
{
pdfProvider.Export(document, output);
}Imports Telerik.Windows.Documents.Flow.FormatProviders.Html
Imports Telerik.Windows.Documents.Flow.FormatProviders.Pdf
Imports Telerik.Windows.Documents.Flow.Model
Imports System.IO
Dim html As String = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>"
Dim htmlProvider As New HtmlFormatProvider()
Dim document As RadFlowDocument = htmlProvider.Import(html)
Dim pdfProvider As New PdfFormatProvider()
Using output As FileStream = File.OpenWrite("output.pdf")
pdfProvider.Export(document, output)
End UsingAbordagem IronPDF:
// NuGet: Install-Package IronPdf
using IronPdf;
string html = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");Imports IronPdf
Dim html As String = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>"
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")A versão Telerik requer a criação de um HtmlFormatProvider, importação para um RadFlowDocument, criação de um PdfFormatProvider e gerenciamento de fluxos de arquivos manualmente. O ChromePdfRenderer do IronPDF lida com todo o processo com uma única chamada de método.
Para cenários mais avançados de conversão de HTML para PDF, consulte o guia de conversão de HTML para PDF .
A captura de páginas da web em formato PDF revela outra diferença significativa entre as bibliotecas.
Abordagem de processamento de documentos da Telerik:
// NuGet: Install-Package Telerik.Documents.Flow
// NuGet: Install-Package Telerik.Documents.Flow.FormatProviders.Pdf
using Telerik.Windows.Documents.Flow.FormatProviders.Html;
using Telerik.Windows.Documents.Flow.FormatProviders.Pdf;
using Telerik.Windows.Documents.Flow.Model;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;
string url = "https://example.com";
using HttpClient client = new HttpClient();
string html = await client.GetStringAsync(url);
HtmlFormatProvider htmlProvider = new HtmlFormatProvider();
RadFlowDocument document = htmlProvider.Import(html);
PdfFormatProvider pdfProvider = new PdfFormatProvider();
using (FileStream output = File.OpenWrite("webpage.pdf"))
{
pdfProvider.Export(document, output);
}Imports Telerik.Windows.Documents.Flow.FormatProviders.Html
Imports Telerik.Windows.Documents.Flow.FormatProviders.Pdf
Imports Telerik.Windows.Documents.Flow.Model
Imports System.IO
Imports System.Net.Http
Imports System.Threading.Tasks
Module Module1
Sub Main()
Dim url As String = "https://example.com"
Using client As New HttpClient()
Dim html As String = Await client.GetStringAsync(url)
Dim htmlProvider As New HtmlFormatProvider()
Dim document As RadFlowDocument = htmlProvider.Import(html)
Dim pdfProvider As New PdfFormatProvider()
Using output As FileStream = File.OpenWrite("webpage.pdf")
pdfProvider.Export(document, output)
End Using
End Using
End Sub
End ModuleAbordagem IronPDF:
// NuGet: Install-Package IronPdf
using IronPdf;
string url = "https://example.com";
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderUrlAsPdf(url);
pdf.SaveAs("webpage.pdf");Imports IronPdf
Dim url As String = "https://example.com"
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderUrlAsPdf(url)
pdf.SaveAs("webpage.pdf")O Processamento de documentos Telerik não possui uma funcionalidade nativa de conversão de URL para PDF. Você deve buscar manualmente o conteúdo HTML usando HttpClient, perdendo CSS externo, execução de JavaScript e conteúdo dinâmico no processo. O método RenderUrlAsPdf do IronPDF captura a página renderizada completa exatamente como aparece em um navegador.
Explore a URL para documentação em PDF para opções adicionais, incluindo autenticação e cabeçalhos personalizados.
A fusão de PDFs demonstra a diferença de verbosidade entre essas bibliotecas PDF do .NET .
Abordagem de processamento de documentos da Telerik:
// NuGet: Install-Package Telerik.Documents.Fixed
using Telerik.Windows.Documents.Fixed.FormatProviders.Pdf;
using Telerik.Windows.Documents.Fixed.Model;
using System.IO;
PdfFormatProvider provider = new PdfFormatProvider();
RadFixedDocument document1;
using (FileStream input = File.OpenRead("document1.pdf"))
{
document1 = provider.Import(input);
}
RadFixedDocument document2;
using (FileStream input = File.OpenRead("document2.pdf"))
{
document2 = provider.Import(input);
}
RadFixedDocument mergedDocument = new RadFixedDocument();
foreach (var page in document1.Pages)
{
mergedDocument.Pages.Add(page);
}
foreach (var page in document2.Pages)
{
mergedDocument.Pages.Add(page);
}
using (FileStream output = File.OpenWrite("merged.pdf"))
{
provider.Export(mergedDocument, output);
}Imports Telerik.Windows.Documents.Fixed.FormatProviders.Pdf
Imports Telerik.Windows.Documents.Fixed.Model
Imports System.IO
Dim provider As New PdfFormatProvider()
Dim document1 As RadFixedDocument
Using input As FileStream = File.OpenRead("document1.pdf")
document1 = provider.Import(input)
End Using
Dim document2 As RadFixedDocument
Using input As FileStream = File.OpenRead("document2.pdf")
document2 = provider.Import(input)
End Using
Dim mergedDocument As New RadFixedDocument()
For Each page In document1.Pages
mergedDocument.Pages.Add(page)
Next
For Each page In document2.Pages
mergedDocument.Pages.Add(page)
Next
Using output As FileStream = File.OpenWrite("merged.pdf")
provider.Export(mergedDocument, output)
End UsingAbordagem IronPDF:
// NuGet: Install-Package IronPdf
using IronPdf;
var pdf1 = PdfDocument.FromFile("document1.pdf");
var pdf2 = PdfDocument.FromFile("document2.pdf");
var merged = PdfDocument.Merge(pdf1, pdf2);
merged.SaveAs("merged.pdf");Imports IronPdf
Dim pdf1 = PdfDocument.FromFile("document1.pdf")
Dim pdf2 = PdfDocument.FromFile("document2.pdf")
Dim merged = PdfDocument.Merge(pdf1, pdf2)
merged.SaveAs("merged.pdf")A versão da Telerik exige a importação de cada documento separadamente, a iteração manual pelas páginas, a adição delas a um novo documento e o gerenciamento de vários fluxos de arquivos. O método PdfDocument.Merge() do IronPDF lida com tudo em uma única chamada.
Para cenários avançados de mesclagem, incluindo extração seletiva de páginas, consulte o guia de mesclagem e divisão de PDFs .
Esta tabela de referência acelera a migração, mostrando equivalentes diretos da API:
| Processamento de documentos Telerik | IronPDF |
|---|---|
HtmlFormatProvider | ChromePdfRenderer |
RadFlowDocument | Não é necessário |
PdfFormatProvider | pdf.SaveAs() |
RadFlowDocumentEditor | Manipulação de HTML |
Section | HTML <section> |
Paragraph | HTML <p> |
PdfExportSettings | RenderingOptions |
RadFixedDocument | PdfDocument |
| Iteração da página do manual | PdfDocument.Merge() |
O Processamento de documentos Telerik utiliza um modelo programático para cabeçalhos e rodapés. O IronPDF fornece cabeçalhos baseados em HTML com espaços reservados dinâmicos.
Processamento de documentos Telerik:
section.Headers.Default.Blocks.AddParagraph().Inlines.AddRun("Header Text");
section.Footers.Default.Blocks.AddParagraph().Inlines.AddRun("Footer Text");section.Headers.Default.Blocks.AddParagraph().Inlines.AddRun("Header Text")
section.Footers.Default.Blocks.AddParagraph().Inlines.AddRun("Footer Text")IronPDF:
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter()
{
HtmlFragment = "<div style='text-align:center;'>Header Text</div>",
MaxHeight = 25
};
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter()
{
HtmlFragment = "<div style='text-align:center;'>Footer Text</div>",
MaxHeight = 25
};Imports System
renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter() With {
.HtmlFragment = "<div style='text-align:center;'>Header Text</div>",
.MaxHeight = 25
}
renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter() With {
.HtmlFragment = "<div style='text-align:center;'>Footer Text</div>",
.MaxHeight = 25
}A abordagem do IronPDF, baseada em HTML, permite estilização CSS completa em cabeçalhos e rodapés, além de espaços reservados dinâmicos para números de página e datas. Saiba mais na documentação sobre cabeçalhos e rodapés .
O sistema de processamento de documentos da Telerik utiliza pixels independentes de dispositivo (DIPs) para medições. O IronPDF usa milímetros. Isso requer conversão durante a migração:
// Telerik uses DIPs (device-independent pixels)
//IronPDF uses millimeters
// 1 inch = 25.4mm
renderer.RenderingOptions.MarginTop = 25.4; // 1 inch
renderer.RenderingOptions.MarginBottom = 25.4;
// Or use the helper method for paper size
renderer.RenderingOptions.SetCustomPaperSizeInInches(8.5, 11);' Telerik uses DIPs (device-independent pixels)
' IronPDF uses millimeters
' 1 inch = 25.4mm
renderer.RenderingOptions.MarginTop = 25.4 ' 1 inch
renderer.RenderingOptions.MarginBottom = 25.4
' Or use the helper method for paper size
renderer.RenderingOptions.SetCustomPaperSizeInInches(8.5, 11)Audite seu código-fonte para identificar todos os usos do Telerik Document Processing:
grep -r "using Telerik.Windows.Documents" --include="*.cs" .
grep -r "RadFlowDocument\|HtmlFormatProvider\|PdfFormatProvider" --include="*.cs" .Documente as implementações existentes, incluindo os provedores de formato utilizados, as configurações de cabeçalho/rodapé, as configurações de página personalizadas e quaisquer modificações no modelo de documento do Flow.
Telerik.Windows.Documents para IronPdfHtmlFormatProvider por ChromePdfRendererRadFlowDocumentPdfFormatProvider por chamadas diretas SaveAs()HtmlHeaderFooterRenderingOptionsApós a migração, verifique estas melhorias:
A migração do processamento de documentos Telerik para o IronPDF oferece vantagens imediatas:
Mecanismo de renderização Chromium moderno: O IronPDF usa o mesmo mecanismo de renderização do Google Chrome, garantindo que os PDFs sejam exibidos exatamente como o conteúdo aparece nos navegadores modernos. Isso elimina os problemas de compatibilidade com CSS inerentes ao modelo de documento Flow da Telerik.
Suporte completo a CSS3 e JavaScript: Flexbox, Grid, Bootstrap 5, variáveis de CSS e JavaScript moderno funcionam corretamente, garantindo a compatibilidade com padrões contemporâneos da web.
API mais simples: Menos linhas de código, sem modelos de documentos intermediários e nomes de métodos intuitivos reduzem o tempo de desenvolvimento e a carga de manutenção.
Licenciamento independente: O IronPDF oferece licenciamento descomplicado sem a necessidade de adquirir um pacote completo, proporcionando uma solução econômica para equipes que precisam apenas de recursos de PDF.
Desenvolvimento ativo: atualizações regulares garantem a compatibilidade com as versões atuais e futuras do .NET , correções de segurança e melhorias de recursos.
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 bem estruturados e visualmente atraentes.
IronPDF faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
Quando você precisa que seu PDF tenha a aparência de HTML, rapidamente.
