Ícono de mensaje
Saltar al pie de página
  1. IronPDF
  2. Blog de IronPDF
  3. Guías de migración
  4. migración de telerik document processing a ironpdf
GUíAS DE MIGRACIóN

Cómo migrar de Telerik Document Processing a IronPDF en C#

Curtis Chau
Curtis Chau
Actualizado:

Telerik Document Processing ha servido al ecosistema .NET como parte de la suite DevCraft, ofreciendo a los desarrolladores capacidades de generación de PDF junto con el procesamiento de Word, Excel y PowerPoint. Sin embargo, a medida que evolucionan los estándares web modernos y los proyectos exigen compatibilidad total con CSS3, Flexbox y Bootstrap, muchos equipos de desarrollo están descubriendo limitaciones fundamentales en la arquitectura de renderización de HTML a PDF de Telerik.

Esta guía proporciona una ruta de migración completa de Telerik Document Processinga IronPDF, con instrucciones paso a paso, comparaciones de código y ejemplos prácticos extraídos directamente de escenarios de migración reales.

Por qué migrar de Telerik Document Processing

La decisión de migrar de Telerik Document Processingsuele deberse a limitaciones técnicas que se hacen evidentes al trabajar con contenido web moderno. Comprender estas limitaciones ayuda a justificar el esfuerzo de migración y establece las expectativas de lo queIronPDFresuelve.

Limitaciones técnicas críticas

El Telerik Document Processing tiene problemas fundamentales a la hora de manejar HTML y CSS modernos:

Problema Impacto Solución IronPDF
Limitaciones del análisis sintáctico de CSS Los marcos CSS modernos como Bootstrap fallan Compatibilidad total con CSS de Chromium
Conversión de div a párrafo Estructura HTML aplanada, diseños rotos Representación directa en HTML
Modelo de documento de flujo Obliga a una conversión intermedia HTML nativo a PDF
Aspectos externos de CSS Se ignoran los selectores complejos Compatibilidad total con archivos CSS
Temas de memoria OutOfMemoryException en documentos grandes Transmisión eficiente

El problema principal: el HTML no se renderiza correctamente

Telerik Document Processing convierte HTML a un modelo intermedio de "documento de flujo" antes de generar PDF. Esta decisión arquitectónica crea problemas en cascada:

  1. Aplana la estructura HTML : los elementos <div> se convierten en párrafos
  2. Ignora CSS moderno - Los diseños Flexbox y Grid fallan por completo
  3. Rompe Bootstrap - Los sistemas de columnas no se muestran como columnas
  4. Pierde el formato - Se ignoran los selectores CSS complejos

Considere este HTML moderno que utiliza diseños CSS estándar:


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

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

En Telerik Document Processing, todos estos diseños se representan como párrafos secuenciales. El diseño Bootstrap de dos columnas se convierte en dos líneas de texto. Los elementos flexbox se apilan verticalmente. Los elementos de CSS Grid aparecen uno tras otro.

Características CSS que fallan en el Telerik Document Processing

Los desarrolladores han documentado amplios problemas de compatibilidad con CSS:

/* ❌ These CSS features DON'T WORK in Telerik Document Processing*/

/* Flexbox - No soportado */
.container { display: flex; }
.item { flex: 1; }

/* CSS Grid - No soportado */
.grid { display: grid; grid-template-columns: repeat(3, 1fr); }

/* Bootstrap columns - Converted to paragraphs */
.col-md-6 { /* Ignored, becomes linear text */ }

/* CSS Variables - No soportado */
: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; }

Problemas de rendimiento con documentos de gran tamaño

Más allá de las limitaciones de CSS, Telerik Document Processingha documentado errores OutOfMemoryException al procesar archivos grandes. Los equipos de desarrollo que trabajan con la generación de grandes volúmenes de documentos se han encontrado con problemas de estabilidad que otras bibliotecas gestionan de forma más eficiente.

IronPDFfrente a Telerik Document Processing: Comparación de características

La comprensión de las diferencias de características ayuda a los responsables técnicos a evaluar la inversión en migración:

Característica Telerik Document Processing IronPDF
Representación HTML Conversión de documentos de flujo Renderizado directo en Chromium
Soporte CSS3 Limitadas, muchas características fallan CSS3 completo
Flexbox No soportado Se admite
CSS Grid No soportado Se admite
Bootstrap Broken (div flattening) Compatible con Bootstrap 5
CSS externo Parcial Se admite
JavaScript No soportado Compatibilidad total con ES2024
Documentos grandes Problemas de memoria Transmisión eficiente
Complejidad de la API Complejo (proveedores, modelos) Simple (una clase)
Modelo de licencia Comercial, parte de DevCraft Licencias independientes sencillas

Inicio rápido de la migración: 5 minutos para su primer PDF

La migración de Telerik Document ProcessingaIronPDFpuede comenzar inmediatamente. Este es el camino más rápido para generar su primer PDF con IronPDF.

Paso 1: Actualizar paquetes NuGet

Elimine todos los paquetes de Telerik Document Processing:

# 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.Fixed
# 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.Fixed
SHELL

Instalar IronPDF:

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

Paso 2: Actualizar usando sentencias

Sustituya los espacios de nombres Telerik por el espacio de nombres 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;
// 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 IronPdf
$vbLabelText   $csharpLabel

Paso 3: Añadir clave de licencia

Inicialice su licencia al iniciar la aplicación:

// Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
// Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
' Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
$vbLabelText   $csharpLabel

Paso 4: Actualice su código de generación de PDF

La transformación de Telerik Document ProcessingaIronPDFsimplifica drásticamente su código base.

Antes (Telerik Document Processing):

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);
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)
$vbLabelText   $csharpLabel

Después (IronPDF):

using IronPdf;

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs("output.pdf");
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")
$vbLabelText   $csharpLabel

La diferencia es evidente de inmediato: 3 líneas de códigoIronPDFsustituyen a más de 15 líneas de código de Telerik Document Processing. Y lo que es más importante, la versiónIronPDFrenderizará correctamente CSS moderno que el modelo Flow Document de Telerik no puede manejar.

Ejemplos de migración de código

Convertir HTML a PDF

Este es el caso de uso más común para la generación de PDF. Las diferencias arquitectónicas entre Telerik Document ProcessingeIronPDFquedan claras en esta comparación.

Enfoque de Telerik Document Processing:

// 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);
}
// 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 Using
$vbLabelText   $csharpLabel

Enfoque 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");
// 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")
$vbLabelText   $csharpLabel

La versión de Telerik requiere crear un HtmlFormatProvider, importar a un RadFlowDocument, crear un PdfFormatProvider y administrar los flujos de archivos manualmente. ChromePdfRenderer deIronPDFmaneja todo el proceso con una única llamada de método.

Para situaciones más avanzadas de conversión de HTML a PDF, consulte la Guía de conversión de HTML a PDF.

Convertir URL en PDF

La captura de páginas web como PDF revela otra diferencia significativa entre las bibliotecas.

Enfoque de Telerik Document Processing:

// 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);
}
// 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 Module
$vbLabelText   $csharpLabel

Enfoque 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");
// 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")
$vbLabelText   $csharpLabel

Telerik Document Processing no tiene capacidad nativa de URL a PDF. Debes obtener manualmente el contenido HTML usando HttpClient, perdiendo CSS externo, ejecución de JavaScript y contenido dinámico en el proceso. El método RenderUrlAsPdf deIronPDFcaptura la página completa renderizada exactamente como aparece en un navegador.

Explore la URL a la documentación PDF para obtener opciones adicionales, incluida la autenticación y las cabeceras personalizadas.

Fusión de varios PDF

La fusión de PDF demuestra la diferencia de verbosidad entre estas bibliotecas PDF .NET.

Enfoque de Telerik Document Processing:

// 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);
}
// 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 Using
$vbLabelText   $csharpLabel

Enfoque 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");
// 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")
$vbLabelText   $csharpLabel

La versión de Telerik requiere importar cada documento por separado, iterar manualmente por las páginas, añadirlas a un nuevo documento y gestionar múltiples flujos de archivos. El método PdfDocument.Merge() deIronPDFmaneja todo en una sola llamada.

Para situaciones de fusión avanzadas, incluida la extracción selectiva de páginas, consulte la guía de fusión y división de PDF.

Aplicación de la API de Telerik Document Processing a IronPDF

Esta tabla de referencia acelera la migración mostrando los equivalentes directos de las API:

Telerik Document Processing IronPDF
HtmlFormatProvider ChromePdfRenderer
RadFlowDocument No es necesario
PdfFormatProvider pdf.SaveAs()
RadFlowDocumentEditor Manipulación de HTML
Section HTML <section>
Paragraph HTML <p>
PdfExportSettings RenderingOptions
RadFixedDocument PdfDocument
Repetición manual de páginas PdfDocument.Merge()

Cabeceras y pies de página

Telerik Document Processing utiliza un modelo programático para encabezados y pies de página.IronPDFproporciona encabezados basados en HTML con marcadores de posición dinámicos.

Telerik Document Processing:

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");
section.Headers.Default.Blocks.AddParagraph().Inlines.AddRun("Header Text")
section.Footers.Default.Blocks.AddParagraph().Inlines.AddRun("Footer Text")
$vbLabelText   $csharpLabel

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
};
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
}
$vbLabelText   $csharpLabel

El enfoque basado en HTML deIronPDFpermite un estilo CSS completo en encabezados y pies de página, además de marcadores de posición dinámicos para números de página y fechas. Más información en la documentación sobre encabezados y pies de página.

Conversión de unidades: DIP a milímetros

Telerik Document Processing utiliza píxeles independientes del dispositivo (DIP) para las mediciones.IronPDFutiliza milímetros. Esto requiere una conversión durante la migración:

// Telerik uses DIPs (device-independent pixels)
//IronPDFuses 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)
//IronPDFuses 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)
$vbLabelText   $csharpLabel

Lista de comprobación de migración de Telerik Document Processing

Tareas previas a la migración

Audite su código base para identificar todo el uso de Telerik Document Processing:

grep -r "using Telerik.Windows.Documents" --include="*.cs" .
grep -r "RadFlowDocument\|HtmlFormatProvider\|PdfFormatProvider" --include="*.cs" .
grep -r "using Telerik.Windows.Documents" --include="*.cs" .
grep -r "RadFlowDocument\|HtmlFormatProvider\|PdfFormatProvider" --include="*.cs" .
SHELL

Documente las implementaciones existentes, incluidos los proveedores de formato utilizados, las configuraciones de encabezado/pie de página, los ajustes de página personalizados y cualquier modificación del modelo de documento de flujo.

Durante la migración

  1. Eliminar paquetes NuGet de Telerik
  2. Instalación del paquete IronPdf NuGet
  3. Actualizar las declaraciones de uso de Telerik.Windows.Documents a IronPdf
  4. Añadir la inicialización de la clave de licencia al inicio
  5. Reemplace HtmlFormatProvider con ChromePdfRenderer
  6. Eliminar RadFlowDocument pasos intermedios
  7. Reemplace las exportaciones PdfFormatProvider con llamadas directas SaveAs()
  8. Actualice los encabezados y pies de página para usar HtmlHeaderFooter
  9. Convertir la configuración de la página a RenderingOptions
  10. Actualizar las unidades de margen de DIP a milímetros

Verificación posterior a la migración

Tras la migración, verifique estas mejoras:

  • La renderización de CSS debe mejorar significativamente
  • Los diseños de Bootstrap deben mostrarse correctamente (no lo hacen en Telerik)
  • Los diseños Flexbox y Grid deben funcionar (no lo hacen en Telerik)
  • La ejecución de JavaScript debe funcionar para contenido dinámico
  • La generación de documentos grandes debe completarse sin excepciones de memoria

Beneficios clave de migrar a IronPDF

El cambio de Telerik Document ProcessingaIronPDFofrece ventajas inmediatas:

Motor de renderizado moderno de Chromium:IronPDFutiliza el mismo motor de renderizado que Google Chrome, lo que garantiza que los archivos PDF se representen exactamente como aparece el contenido en los navegadores modernos. Esto elimina los problemas de compatibilidad con CSS inherentes al modelo de documento de flujo de Telerik.

Compatibilidad completa con CSS3 y JavaScript : Flexbox, Grid, Bootstrap 5, variables CSS y JavaScript moderno funcionan correctamente. A medida que aumenta la adopción de .NET 10 y C# 14 hasta 2026, la moderna renderización deIronPDFgarantiza la compatibilidad con los estándares web contemporáneos.

API más simple: menos líneas de código, sin modelos de documentos intermedios y nombres de métodos intuitivos reducen el tiempo de desarrollo y la carga de mantenimiento.

Licencias independientes:IronPDFofrece licencias sencillas sin necesidad de comprar una suite completa, lo que proporciona una solución rentable para equipos que solo necesitan capacidades de PDF.

Desarrollo activo: las actualizaciones periódicas garantizan la compatibilidad con versiones actuales y futuras de .NET , parches de seguridad y mejoras de funciones.

Curtis Chau
Curtis Chau
  Chatea con el equipo de ingeniería ahora
Escritor Técnico

Curtis Chau tiene una licenciatura en Ciencias de la Computación (Carleton University) y se especializa en el desarrollo front-end con experiencia en Node.js, TypeScript, JavaScript y React. Apasionado por crear interfaces de usuario intuitivas y estéticamente agradables, disfruta trabajando con frameworks modernos y creando manuales bien ...

Leer más

Artículos Relacionados

Prueba de 30 días → Producto completo. Sin límites. Sin tarjeta. Prueba gratis

Equipo de soporte de Iron

Estamos disponibles online las 24 horas, 5 días a la semana.
Chat
Email
Llámame