Í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 xfinium.pdf a ironpdf
GUíAS DE MIGRACIóN

Cómo migrar de XFINIUM.PDF a IronPDF en C#

Curtis Chau
Curtis Chau
Actualizado:

XFINIUM.PDF es una biblioteca PDF multiplataforma que ofrece herramientas completas para crear y editar archivos PDF mediante programación en C#. Aunque ofrece dos ediciones -Generator y Viewer-, la dependencia de la biblioteca de la programación gráfica basada en coordenadas crea retos significativos para los equipos de desarrollo que crean aplicaciones con muchos documentos. Cada elemento debe colocarse manualmente mediante coordenadas de píxeles, lo que convierte lo que deberían ser documentos sencillos en complejos ejercicios de dibujo.

Esta guía proporciona una ruta de migración completa de XFINIUM.PDF a IronPDF, con instrucciones paso a paso, comparaciones de código y ejemplos prácticos para desarrolladores profesionales de .NET que estén evaluando esta transición.

Por qué migrar de XFINIUM.PDF

XFINIUM.PDF es una biblioteca PDF de bajo nivel que se basa en la programación de gráficos por coordenadas, lo que obliga a los desarrolladores a colocar manualmente cada elemento en la página. Este enfoque se convierte en una pesadilla de mantenimiento a medida que cambian los requisitos. Entre las principales razones por las que los equipos de desarrollo se plantean la migración se incluyen:

Sin soporte HTML: XFINIUM.PDF no puede convertir HTML/CSS a PDF directamente. Se centra en la creación programática de PDF mediante primitivas de dibujo de bajo nivel, que pueden no ser suficientes para proyectos que requieren amplias capacidades de HTML a PDF.

API basada en coordenadas: se requiere posicionamiento manual con coordenadas de píxeles como DrawString("text", font, brush, 50, 100) para cada elemento de la página.

Gestión manual de fuentes: los objetos de fuente deben crearse y gestionarse explícitamente utilizando clases como PdfStandardFont y PdfBrush.

Sin estilo CSS: no es compatible con estilos web modernos. Los colores, las fuentes y los diseños deben manejarse manualmente mediante llamadas a métodos programáticos.

Sin representación de JavaScript : solo contenido estático. XFINIUM.PDF no puede mostrar contenido web dinámico ni ejecutar JavaScript.

Diseño de texto complejo: se requieren mediciones de texto manuales y cálculos de ajuste para cualquier cosa que vaya más allá de un texto de una sola línea.

Recursos comunitarios limitados: hay una falta de recursos proporcionados por la comunidad, como ejemplos y tutoriales, en comparación con las soluciones convencionales, lo que puede dificultar que los nuevos usuarios comiencen.

El problema central: API gráfica frente a HTML

XFINIUM.PDF le obliga a pensar como un programador gráfico, no como un diseñador de documentos:

// XFINIUM.PDF: Position every element manually
page.Graphics.DrawString("Invoice", titleFont, titleBrush, 50, 50);
page.Graphics.DrawString("Customer:", labelFont, brush, 50, 80);
page.Graphics.DrawString(customer.Name, valueFont, brush, 120, 80);
// ... hundreds of lines for a simple document
// XFINIUM.PDF: Position every element manually
page.Graphics.DrawString("Invoice", titleFont, titleBrush, 50, 50);
page.Graphics.DrawString("Customer:", labelFont, brush, 50, 80);
page.Graphics.DrawString(customer.Name, valueFont, brush, 120, 80);
// ... hundreds of lines for a simple document
' XFINIUM.PDF: Position every element manually
page.Graphics.DrawString("Invoice", titleFont, titleBrush, 50, 50)
page.Graphics.DrawString("Customer:", labelFont, brush, 50, 80)
page.Graphics.DrawString(customer.Name, valueFont, brush, 120, 80)
' ... hundreds of lines for a simple document
$vbLabelText   $csharpLabel

IronPDF utiliza HTML/CSS conocidos:

// IronPDF: Declarative HTML
var html = @"<h1>Invoice</h1><p><b>Customer:</b> " + customer.Name + "</p>";
var pdf = renderer.RenderHtmlAsPdf(html);
// IronPDF: Declarative HTML
var html = @"<h1>Invoice</h1><p><b>Customer:</b> " + customer.Name + "</p>";
var pdf = renderer.RenderHtmlAsPdf(html);
' IronPDF: Declarative HTML
Dim html As String = "<h1>Invoice</h1><p><b>Customer:</b> " & customer.Name & "</p>"
Dim pdf = renderer.RenderHtmlAsPdf(html)
$vbLabelText   $csharpLabel

IronPDFfrente a XFINIUM.PDF: Comparación de características

Comprender las diferencias arquitectónicas ayuda a los responsables técnicos a evaluar la inversión en migración:

Característica XFINIUM.PDF IronPDF
HTML a PDF Compatibilidad limitada con HTML, se centra en la creación programática de PDF Conversión completa de HTML a PDF con soporte integral
Comunidad y soporte Comunidad más pequeña, menos recursos en línea disponibles Amplia comunidad con extensa documentación y tutoriales
Licencia Comercial con licencia para desarrolladores Comercial
Soporte multiplataforma Gran capacidad multiplataforma También es compatible con operaciones multiplataforma
Soporte CSS No CSS3 completo
JavaScript No ES2024 completo
Flexbox/Grid No Sí
Diseño automático No Sí
Saltos de página automáticos No Sí
Posicionamiento manual Requerido Opcional (posicionamiento CSS)
Curva de aprendizaje Alto (sistema de coordenadas) Bajo (HTML/CSS)
Verbosidad del código Muy alto Bajo

Inicio rápido: Migración de XFINIUM.PDF a IronPDF

La migración puede comenzar inmediatamente con estos pasos básicos.

Paso 1: Sustituir el paquete NuGet

Eliminar XFINIUM.PDF:

# Remove XFINIUM.PDF
dotnet remove package Xfinium.Pdf
# Remove XFINIUM.PDF
dotnet remove package Xfinium.Pdf
SHELL

Instalar IronPDF:

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

Paso 2: Actualizar los espacios de nombres

Sustituya los espacios de nombres XFINIUM.PDF por el espacio de nombres IronPdf:

// Before (XFINIUM.PDF)
using Xfinium.Pdf;
using Xfinium.Pdf.Graphics;
using Xfinium.Pdf.Content;
using Xfinium.Pdf.FlowDocument;

// After (IronPDF)
using IronPdf;
// Before (XFINIUM.PDF)
using Xfinium.Pdf;
using Xfinium.Pdf.Graphics;
using Xfinium.Pdf.Content;
using Xfinium.Pdf.FlowDocument;

// After (IronPDF)
using IronPdf;
Imports IronPdf
$vbLabelText   $csharpLabel

Paso 3: Inicializar licencia

Añadir inicialización de licencia al inicio de la aplicación:

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
$vbLabelText   $csharpLabel

Ejemplos de migración de código

Convertir HTML a PDF

La operación más fundamental revela la diferencia de complejidad entre estas bibliotecas PDF .NET.

Enfoque XFINIUM.PDF:

// NuGet: Install-Package Xfinium.Pdf
using Xfinium.Pdf;
using Xfinium.Pdf.Actions;
using Xfinium.Pdf.FlowDocument;
using System.IO;

class Program
{
    static void Main()
    {
        PdfFixedDocument document = new PdfFixedDocument();
        PdfFlowDocument flowDocument = new PdfFlowDocument();

        string html = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML.</p></body></html>";

        PdfFlowContent content = new PdfFlowContent();
        content.AppendHtml(html);
        flowDocument.AddContent(content);

        flowDocument.RenderDocument(document);
        document.Save("output.pdf");
    }
}
// NuGet: Install-Package Xfinium.Pdf
using Xfinium.Pdf;
using Xfinium.Pdf.Actions;
using Xfinium.Pdf.FlowDocument;
using System.IO;

class Program
{
    static void Main()
    {
        PdfFixedDocument document = new PdfFixedDocument();
        PdfFlowDocument flowDocument = new PdfFlowDocument();

        string html = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML.</p></body></html>";

        PdfFlowContent content = new PdfFlowContent();
        content.AppendHtml(html);
        flowDocument.AddContent(content);

        flowDocument.RenderDocument(document);
        document.Save("output.pdf");
    }
}
Imports Xfinium.Pdf
Imports Xfinium.Pdf.Actions
Imports Xfinium.Pdf.FlowDocument
Imports System.IO

Module Program
    Sub Main()
        Dim document As New PdfFixedDocument()
        Dim flowDocument As New PdfFlowDocument()

        Dim html As String = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML.</p></body></html>"

        Dim content As New PdfFlowContent()
        content.AppendHtml(html)
        flowDocument.AddContent(content)

        flowDocument.RenderDocument(document)
        document.Save("output.pdf")
    End Sub
End Module
$vbLabelText   $csharpLabel

Enfoque IronPDF:

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        string html = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML.</p></body></html>";

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        string html = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML.</p></body></html>";

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}
Imports IronPdf

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim html As String = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML.</p></body></html>"

        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

XFINIUM.PDF requiere crear un objeto PdfFixedDocument, un PdfFlowDocument, un PdfFlowContent, llamar a AppendHtml(), agregar contenido al documento de flujo, renderizar al documento fijo y finalmente guardar.IronPDFlo simplifica a tres líneas: crear un renderizador, renderizar HTML y guardar.

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

Fusión de varios PDF

La fusión de PDF demuestra claramente las diferencias de complejidad de las API.

Enfoque XFINIUM.PDF:

// NuGet: Install-Package Xfinium.Pdf
using Xfinium.Pdf;
using System.IO;

class Program
{
    static void Main()
    {
        PdfFixedDocument output = new PdfFixedDocument();

        FileStream file1 = File.OpenRead("document1.pdf");
        PdfFixedDocument pdf1 = new PdfFixedDocument(file1);

        FileStream file2 = File.OpenRead("document2.pdf");
        PdfFixedDocument pdf2 = new PdfFixedDocument(file2);

        for (int i = 0; i < pdf1.Pages.Count; i++)
        {
            output.Pages.Add(pdf1.Pages[i]);
        }

        for (int i = 0; i < pdf2.Pages.Count; i++)
        {
            output.Pages.Add(pdf2.Pages[i]);
        }

        output.Save("merged.pdf");

        file1.Close();
        file2.Close();
    }
}
// NuGet: Install-Package Xfinium.Pdf
using Xfinium.Pdf;
using System.IO;

class Program
{
    static void Main()
    {
        PdfFixedDocument output = new PdfFixedDocument();

        FileStream file1 = File.OpenRead("document1.pdf");
        PdfFixedDocument pdf1 = new PdfFixedDocument(file1);

        FileStream file2 = File.OpenRead("document2.pdf");
        PdfFixedDocument pdf2 = new PdfFixedDocument(file2);

        for (int i = 0; i < pdf1.Pages.Count; i++)
        {
            output.Pages.Add(pdf1.Pages[i]);
        }

        for (int i = 0; i < pdf2.Pages.Count; i++)
        {
            output.Pages.Add(pdf2.Pages[i]);
        }

        output.Save("merged.pdf");

        file1.Close();
        file2.Close();
    }
}
Imports Xfinium.Pdf
Imports System.IO

Module Program
    Sub Main()
        Dim output As New PdfFixedDocument()

        Dim file1 As FileStream = File.OpenRead("document1.pdf")
        Dim pdf1 As New PdfFixedDocument(file1)

        Dim file2 As FileStream = File.OpenRead("document2.pdf")
        Dim pdf2 As New PdfFixedDocument(file2)

        For i As Integer = 0 To pdf1.Pages.Count - 1
            output.Pages.Add(pdf1.Pages(i))
        Next

        For i As Integer = 0 To pdf2.Pages.Count - 1
            output.Pages.Add(pdf2.Pages(i))
        Next

        output.Save("merged.pdf")

        file1.Close()
        file2.Close()
    End Sub
End Module
$vbLabelText   $csharpLabel

Enfoque IronPDF:

// NuGet: Install-Package IronPdf
using IronPdf;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        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;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var pdf1 = PdfDocument.FromFile("document1.pdf");
        var pdf2 = PdfDocument.FromFile("document2.pdf");

        var merged = PdfDocument.Merge(pdf1, pdf2);
        merged.SaveAs("merged.pdf");
    }
}
Imports IronPdf
Imports System.Collections.Generic

Class Program
    Shared Sub Main()
        Dim pdf1 = PdfDocument.FromFile("document1.pdf")
        Dim pdf2 = PdfDocument.FromFile("document2.pdf")

        Dim merged = PdfDocument.Merge(pdf1, pdf2)
        merged.SaveAs("merged.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

XFINIUM.PDF requiere crear un documento de salida, abrir flujos de archivos, cargar cada documento, iterar manualmente por las páginas y añadirlas una a una, guardar y, a continuación, cerrar los flujos.IronPDFproporciona un único método PdfDocument.Merge() que maneja toda la complejidad internamente.

Explore la documentación sobre la fusión de PDF para conocer otras opciones de fusión.

Creación de PDF con texto e imágenes

Los documentos de contenido mixto muestran la diferencia fundamental de paradigma.

Enfoque XFINIUM.PDF:

// NuGet: Install-Package Xfinium.Pdf
using Xfinium.Pdf;
using Xfinium.Pdf.Graphics;
using Xfinium.Pdf.Core;
using System.IO;

class Program
{
    static void Main()
    {
        PdfFixedDocument document = new PdfFixedDocument();
        PdfPage page = document.Pages.Add();

        PdfStandardFont font = new PdfStandardFont(PdfStandardFontFace.Helvetica, 24);
        PdfBrush brush = new PdfBrush(PdfRgbColor.Black);

        page.Graphics.DrawString("Sample PDF Document", font, brush, 50, 50);

        FileStream imageStream = File.OpenRead("image.jpg");
        PdfJpegImage image = new PdfJpegImage(imageStream);
        page.Graphics.DrawImage(image, 50, 100, 200, 150);
        imageStream.Close();

        document.Save("output.pdf");
    }
}
// NuGet: Install-Package Xfinium.Pdf
using Xfinium.Pdf;
using Xfinium.Pdf.Graphics;
using Xfinium.Pdf.Core;
using System.IO;

class Program
{
    static void Main()
    {
        PdfFixedDocument document = new PdfFixedDocument();
        PdfPage page = document.Pages.Add();

        PdfStandardFont font = new PdfStandardFont(PdfStandardFontFace.Helvetica, 24);
        PdfBrush brush = new PdfBrush(PdfRgbColor.Black);

        page.Graphics.DrawString("Sample PDF Document", font, brush, 50, 50);

        FileStream imageStream = File.OpenRead("image.jpg");
        PdfJpegImage image = new PdfJpegImage(imageStream);
        page.Graphics.DrawImage(image, 50, 100, 200, 150);
        imageStream.Close();

        document.Save("output.pdf");
    }
}
Imports Xfinium.Pdf
Imports Xfinium.Pdf.Graphics
Imports Xfinium.Pdf.Core
Imports System.IO

Class Program
    Shared Sub Main()
        Dim document As New PdfFixedDocument()
        Dim page As PdfPage = document.Pages.Add()

        Dim font As New PdfStandardFont(PdfStandardFontFace.Helvetica, 24)
        Dim brush As New PdfBrush(PdfRgbColor.Black)

        page.Graphics.DrawString("Sample PDF Document", font, brush, 50, 50)

        Dim imageStream As FileStream = File.OpenRead("image.jpg")
        Dim image As New PdfJpegImage(imageStream)
        page.Graphics.DrawImage(image, 50, 100, 200, 150)
        imageStream.Close()

        document.Save("output.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

Enfoque IronPDF:

// NuGet: Install-Package IronPdf
using IronPdf;
using System.IO;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        string imageBase64 = Convert.ToBase64String(File.ReadAllBytes("image.jpg"));
        string html = $@"
            <html>
                <body>
                    <h1>Sample PDF Document</h1>
                    <img src='data:image/jpeg;base64,{imageBase64}' width='200' height='150' />
                </body>
            </html>";

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System.IO;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        string imageBase64 = Convert.ToBase64String(File.ReadAllBytes("image.jpg"));
        string html = $@"
            <html>
                <body>
                    <h1>Sample PDF Document</h1>
                    <img src='data:image/jpeg;base64,{imageBase64}' width='200' height='150' />
                </body>
            </html>";

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}
Imports IronPdf
Imports System.IO

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()

        Dim imageBase64 As String = Convert.ToBase64String(File.ReadAllBytes("image.jpg"))
        Dim html As String = $"
            <html>
                <body>
                    <h1>Sample PDF Document</h1>
                    <img src='data:image/jpeg;base64,{imageBase64}' width='200' height='150' />
                </body>
            </html>"

        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

XFINIUM.PDF requiere crear un documento, agregar una página, crear objetos de fuente y pincel, dibujar texto en coordenadas específicas, abrir un flujo de imágenes, crear un PdfJpegImage, dibujar la imagen en coordenadas con dimensiones, cerrar el flujo y guardar.IronPDFutiliza HTML estándar con imágenes base64 incrustadas, el mismo enfoque que utilizan a diario los desarrolladores web.

Referencia de la API XFINIUM.PDF a IronPDF

Este mapeo acelera la migración al mostrar los equivalentes directos de las API:

XFINIUM.PDF IronPDF
PdfFixedDocument ChromePdfRenderer
PdfPage Automático
page.Graphics.DrawString() Elementos de texto HTML
page.Graphics.DrawImage() Etiqueta <img>
page.Graphics.DrawLine() CSS border o <hr>
page.Graphics.DrawRectangle() CSS border en <div>
PdfStandardFont CSS font-family
PdfRgbColor CSS color
PdfBrush Propiedades CSS
PdfJpegImage Etiqueta <img> con base64
document.Save(stream) pdf.SaveAs() o pdf.BinaryData
PdfFlowDocument RenderHtmlAsPdf()
PdfFlowContent.AppendHtml() RenderHtmlAsPdf()

Problemas comunes de migración y soluciones

Número 1: Diseño basado en coordenadas

XFINIUM.PDF: Todo requiere coordenadas X,Y exactas con posicionamiento manual.

Solución: Utilizar diseño de flujo HTML/CSS. Para el posicionamiento absoluto cuando sea necesario, utilice CSS:

.positioned-element {
    position: absolute;
    top: 100px;
    left: 50px;
}

Número 2: Gestión de objetos de fuentes

XFINIUM.PDF: Crea objetos PdfStandardFont o PdfUnicodeTrueTypeFont para cada fuente.

Solución: Utilizar CSS font-family-las fuentes se manejan automáticamente:

<style>
    body { font-family: Arial, sans-serif; }
    h1 { font-family: 'Times New Roman', serif; font-size: 24px; }
</style>
<style>
    body { font-family: Arial, sans-serif; }
    h1 { font-family: 'Times New Roman', serif; font-size: 24px; }
</style>
HTML

Número 3: Manejo del color

XFINIUM.PDF: Crea objetos PdfRgbColor y PdfBrush para colores.

Solución: Utilizar colores CSS estándar:

.header { color: navy; background-color: #f5f5f5; }
.warning { color: rgb(255, 0, 0); }
.info { color: rgba(0, 0, 255, 0.8); }

Edición 4: Saltos de página manuales

XFINIUM.PDF: Rastrea la posición Y y crea nuevas páginas manualmente cuando el contenido se desborde.

Solución:IronPDFgestiona los saltos de página automáticos. Para un control explícito, utilice CSS:

.section { page-break-after: always; }
.keep-together { page-break-inside: avoid; }

Número 5: Carga de imágenes

XFINIUM.PDF: Abrir secuencias de archivos, crear objetos PdfJpegImage, dibujar en coordenadas, cerrar secuencias.

Solución: utilice etiquetas HTML <img> con rutas de archivo o datos base64:

<img src="image.jpg" width="200" height="150" />

<img src="data:image/jpeg;base64,..." />
<img src="image.jpg" width="200" height="150" />

<img src="data:image/jpeg;base64,..." />
HTML

Lista de comprobación de la migración a XFINIUM.PDF

Tareas previas a la migración

Audite su código base para identificar todo el uso de XFINIUM.PDF:

grep -r "using Xfinium.Pdf" --include="*.cs" .
grep -r "Graphics.DrawString\|Graphics.DrawImage\|Graphics.DrawLine" --include="*.cs" .
grep -r "using Xfinium.Pdf" --include="*.cs" .
grep -r "Graphics.DrawString\|Graphics.DrawImage\|Graphics.DrawLine" --include="*.cs" .
SHELL

Documente los diseños basados en coordenadas y anote todos los valores de posicionamiento X,Y. Identificar objetos de fuente y color (PdfStandardFont, PdfRgbColor, PdfBrush). Mapa de flujos de trabajo de PDF fusionados usando PdfFixedDocument.Pages.Add().

Tareas de actualización de código

  1. Eliminar el paquete NuGet Xfinium.Pdf
  2. Instalación del paquete IronPdf NuGet
  3. Actualizar las importaciones de espacios de nombres de Xfinium.Pdf a IronPdf
  4. Convertir las llamadas DrawString() en elementos de texto HTML
  5. Convertir las llamadas DrawImage() a etiquetas HTML <img>
  6. Convierta DrawRectangle() y DrawLine() en bordes CSS
  7. Reemplace PdfStandardFont con CSS font-family
  8. Reemplace PdfRgbColor y PdfBrush con colores CSS
  9. Reemplace la fusión de bucles de página con PdfDocument.Merge()
  10. Añadir la inicialización de la licenciaIronPDFal inicio

Pruebas posteriores a la migración

Tras la migración, verifique estos aspectos:

  • Comparar los resultados visuales para garantizar que el aspecto coincida con las expectativas
  • Verificar la representación del texto con el nuevo enfoque HTML/CSS
  • Comprobar el posicionamiento de imágenes mediante CSS
  • Los saltos de página de prueba se producen como se espera
  • Verificar que la configuración de seguridad del PDF se aplica correctamente
  • Prueba en todas las plataformas de destino

Beneficios clave de migrar a IronPDF

El cambio de XFINIUM.PDF aIronPDFofrece varias ventajas fundamentales:

Creación de contenido basado en HTML: los desarrolladores web pueden aprovechar las habilidades existentes en HTML y CSS. No es necesario aprender API de dibujo basadas en coordenadas ni gestionar objetos de fuentes y pinceles.

Diseño automático: el ajuste de texto, la paginación y el diseño de flujo se realizan automáticamente. No es necesario calcular manualmente la posición de los elementos ni los saltos de página.

Compatibilidad con CSS moderno: CSS3 completo, incluidos diseños Flexbox y Grid. Los diseños responsivos se traducen directamente a PDF.

Operaciones PDF simplificadas: las llamadas de método único para operaciones comunes como PdfDocument.Merge() reemplazan bucles de iteración de páginas complejos.

Desarrollo activo: a medida que aumenta la adopción de .NET 10 y C# 14 hasta 2026, las actualizaciones periódicas deIronPDFgarantizan la compatibilidad con las versiones actuales y futuras de .NET .

Documentación extensa: gran comunidad con documentación completa, tutoriales y recursos de soporte en comparación con el ecosistema más pequeño de XFINIUM.PDF.

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