COMPARACIóN DE PRODUCTOS

Comparación entre IronPDF y PDFSharpCore

Actualizado 6 de marzo, 2024
Compartir:

La creación y gestión de archivos PDF es un requisito habitual en el desarrollo de software. Los desarrolladores a menudo necesitan bibliotecas, disponibles como paquetes NuGet, que puedan generar, editar y manipular PDF sin esfuerzo. IronPDF y PDFSharpCore son dos bibliotecas destacadas en el ecosistema del lenguaje .NET que sirven para este propósito. Este artículo, relevante para los usuarios de Visual Studio, se sumerge en ambos, destacando sus características, diferencias y cómo pueden utilizarse en proyectos .NET.

Introducción a IronPDF y PDFSharpCore

IronPDF es una completa biblioteca .NET diseñada para que los desarrolladores puedan crear, editar y convertir documentos PDF sin esfuerzo. Ofrece una amplia gama de funcionalidades para crear, editar y convertir este tipo de documentos. IronPDF es compatible con .NET Core y frameworks, lo que lo hace versátil para diversas aplicaciones, incluidas las web y de escritorio.

La biblioteca PDFSharpCore es una adaptación parcial de la biblioteca PDFsharp original. Está orientado a .NET Core, además de la base MigraDoc, y se centra en la creación y el procesamiento de documentos PDF sin depender de las bibliotecas de Windows. Esto lo hace adecuado para proyectos multiplataforma, que funcionan en Linux, MacOS y Windows.

Instalación de IronPDF y PDFSharpCore

Instalación de IronPDF

Para empezar a utilizar IronPDF en su proyecto, puede instalarlo fácilmente a través de NuGet Package Manager. Siga estos pasos para instalar IronPDF:

  1. Abra su proyecto en Visual Studio.
  2. Vaya a Herramientas > Administrador de paquetes NuGet > Administrar paquetes NuGet para la solución.
  3. Busque IronPdf en el Gestor NuGet.

    1. Seleccione su proyecto y haga clic en Instalar para añadir IronPDF a su proyecto.

    Comparación entre IronPDF y PDFSharpCore: Figura 1 - IronPDF

    Alternativamente, puede utilizar la consola del gestor de paquetes para instalar IronPDF con el siguiente comando:

Install-Package IronPdf

Instalación de PDFSharpCore

Para instalar PDFSharpCore utilizando NuGet, siga estas instrucciones:

  1. Asegúrese de que el proyecto de Visual Studio está abierto.
  2. Vaya a Herramientas > Administrador de paquetes NuGet > Administrar paquetes NuGet para la solución.
  3. En el gestor de paquetes NuGet, busque PDFSharpCore.

    1. Seleccione su proyecto y haga clic en Install para incorporar PDFSharpCore.

    Comparación entre IronPDF y PDFSharpCore: Figura 2 - PDFSharpCore

    Para los desarrolladores que prefieren la consola del gestor de paquetes, PDFSharpCore se puede instalar con este comando:

Install-Package PdfSharpCore

Creación de archivos PDF: IronPDF vs. PDFSharpCore

IronPDF: Creación y manipulación sencillas

IronPDF simplifica el proceso de generación de nuevos documentos PDF para los desarrolladores. Proporciona una forma intuitiva de crear PDF directamente a partir de contenidos HTML o páginas web, agilizando la conversión de contenidos web en archivos con formato de documento portátil.

Cadena HTML a PDF

IronPDF permite creación de documentos PDF a partir de cadenas HTML utilizando su clase ChromePdfRenderer. Esta función es especialmente útil cuando necesita generar PDF dinámicamente a partir de plantillas HTML o contenidos generados dentro de su aplicación. A continuación se explica cómo convertir una cadena HTML en un documento PDF con IronPDF:

using IronPdf;
class Program
{
    static void Main(string [] args)
    {
        License.LicenseKey = "License-Key";
        //  Crear una nueva instancia de IronPdf.ChromePdfRenderer
        var Renderer = new ChromePdfRenderer();
        //  Contenido HTML con sentido
        string htmlContent = @"
                <h1>Report on Sales Performance</h1>
                <p>This report analyzes the sales performance for the first quarter of 2024.</p>
                <table>
                    <thead>
                        <tr>
                            <th>Month</th>
                            <th>Sales Revenue</th>
                        </tr>
                    </thead>
                    <tbody>
                        <tr>
                            <td>January</td>
                            <td>$50,000</td>
                        </tr>
                        <tr>
                            <td>February</td>
                            <td>$55,000</td>
                        </tr>
                        <tr>
                            <td>March</td>
                            <td>$60,000</td>
                        </tr>
                    </tbody>
                </table>
                <p>This report highlights the positive growth in sales revenue over the quarter.</p>";
        //  Convertir contenido HTML en PDF
        var PDF = Renderer.RenderHtmlAsPdf(htmlContent);
        //  Guarde el PDF como example.pdf
        PDF.SaveAs("example.pdf");
        Console.WriteLine("PDF saved successfully.");
    }
}
using IronPdf;
class Program
{
    static void Main(string [] args)
    {
        License.LicenseKey = "License-Key";
        //  Crear una nueva instancia de IronPdf.ChromePdfRenderer
        var Renderer = new ChromePdfRenderer();
        //  Contenido HTML con sentido
        string htmlContent = @"
                <h1>Report on Sales Performance</h1>
                <p>This report analyzes the sales performance for the first quarter of 2024.</p>
                <table>
                    <thead>
                        <tr>
                            <th>Month</th>
                            <th>Sales Revenue</th>
                        </tr>
                    </thead>
                    <tbody>
                        <tr>
                            <td>January</td>
                            <td>$50,000</td>
                        </tr>
                        <tr>
                            <td>February</td>
                            <td>$55,000</td>
                        </tr>
                        <tr>
                            <td>March</td>
                            <td>$60,000</td>
                        </tr>
                    </tbody>
                </table>
                <p>This report highlights the positive growth in sales revenue over the quarter.</p>";
        //  Convertir contenido HTML en PDF
        var PDF = Renderer.RenderHtmlAsPdf(htmlContent);
        //  Guarde el PDF como example.pdf
        PDF.SaveAs("example.pdf");
        Console.WriteLine("PDF saved successfully.");
    }
}
Imports IronPdf
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		License.LicenseKey = "License-Key"
		'  Crear una nueva instancia de IronPdf.ChromePdfRenderer
		Dim Renderer = New ChromePdfRenderer()
		'  Contenido HTML con sentido
		Dim htmlContent As String = "
                <h1>Report on Sales Performance</h1>
                <p>This report analyzes the sales performance for the first quarter of 2024.</p>
                <table>
                    <thead>
                        <tr>
                            <th>Month</th>
                            <th>Sales Revenue</th>
                        </tr>
                    </thead>
                    <tbody>
                        <tr>
                            <td>January</td>
                            <td>$50,000</td>
                        </tr>
                        <tr>
                            <td>February</td>
                            <td>$55,000</td>
                        </tr>
                        <tr>
                            <td>March</td>
                            <td>$60,000</td>
                        </tr>
                    </tbody>
                </table>
                <p>This report highlights the positive growth in sales revenue over the quarter.</p>"
		'  Convertir contenido HTML en PDF
		Dim PDF = Renderer.RenderHtmlAsPdf(htmlContent)
		'  Guarde el PDF como example.pdf
		PDF.SaveAs("example.pdf")
		Console.WriteLine("PDF saved successfully.")
	End Sub
End Class
VB   C#

Comparación entre IronPDF y PDFSharpCore: Figura 3 - Salida de envío de informes PDF

Archivo HTML a PDF

IronPDF también permite convertir archivos HTML completos en documentos PDF. Resulta especialmente útil para convertir en formato PDF páginas HTML estáticas o plantillas almacenadas como archivos. He aquí un ejemplo de código para convertir un archivo HTML en un documento PDF:

using IronPdf;
class Program
{
    void Main(string [] args)
    {
        License.LicenseKey = "License-Key";
        //  Crear una nueva instancia de IronPdf.ChromePdfRenderer
        var Renderer = new ChromePdfRenderer();
        //  Convertir contenido HTML en PDF
        var PDF = Renderer.RenderHtmlFileAsPdf(@"C:\Users\Tayyab Ali\Desktop\example.html");
        PDF.SaveAs("example.pdf");
        Console.WriteLine("PDF saved successfully.");
    }
}
using IronPdf;
class Program
{
    void Main(string [] args)
    {
        License.LicenseKey = "License-Key";
        //  Crear una nueva instancia de IronPdf.ChromePdfRenderer
        var Renderer = new ChromePdfRenderer();
        //  Convertir contenido HTML en PDF
        var PDF = Renderer.RenderHtmlFileAsPdf(@"C:\Users\Tayyab Ali\Desktop\example.html");
        PDF.SaveAs("example.pdf");
        Console.WriteLine("PDF saved successfully.");
    }
}
Imports IronPdf
Friend Class Program
	Private Sub Main(ByVal args() As String)
		License.LicenseKey = "License-Key"
		'  Crear una nueva instancia de IronPdf.ChromePdfRenderer
		Dim Renderer = New ChromePdfRenderer()
		'  Convertir contenido HTML en PDF
		Dim PDF = Renderer.RenderHtmlFileAsPdf("C:\Users\Tayyab Ali\Desktop\example.html")
		PDF.SaveAs("example.pdf")
		Console.WriteLine("PDF saved successfully.")
	End Sub
End Class
VB   C#

Comparación entre IronPDF y PDFSharpCore: Figura 4 - Salida PDF

URL a PDF

La conversión de páginas web a PDF es otra potente función de IronPDF. Esta función es inestimable para capturar contenidos web en directo, incluidos el estilo y los medios, directamente en un documento PDF. Para convertir una URL web en un documento PDF, puede utilizar el siguiente código:

using IronPdf;
class Program
{
    static void Main(string [] args)
    {
        License.LicenseKey = "License-Key";
        //  Crear una nueva instancia de IronPdf.ChromePdfRenderer
        var Renderer = new ChromePdfRenderer();
        Renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A2;
        //  Convertir contenido HTML en PDF
        var PDF = Renderer.RenderUrlAsPdf("https://dotnet.microsoft.com/en-us/download/dotnet-framework");
        //  Guarde el PDF como example.pdf
        PDF.SaveAs("webpage.pdf");
        Console.WriteLine("PDF saved successfully.");
    }
}
using IronPdf;
class Program
{
    static void Main(string [] args)
    {
        License.LicenseKey = "License-Key";
        //  Crear una nueva instancia de IronPdf.ChromePdfRenderer
        var Renderer = new ChromePdfRenderer();
        Renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A2;
        //  Convertir contenido HTML en PDF
        var PDF = Renderer.RenderUrlAsPdf("https://dotnet.microsoft.com/en-us/download/dotnet-framework");
        //  Guarde el PDF como example.pdf
        PDF.SaveAs("webpage.pdf");
        Console.WriteLine("PDF saved successfully.");
    }
}
Imports IronPdf
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		License.LicenseKey = "License-Key"
		'  Crear una nueva instancia de IronPdf.ChromePdfRenderer
		Dim Renderer = New ChromePdfRenderer()
		Renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A2
		'  Convertir contenido HTML en PDF
		Dim PDF = Renderer.RenderUrlAsPdf("https://dotnet.microsoft.com/en-us/download/dotnet-framework")
		'  Guarde el PDF como example.pdf
		PDF.SaveAs("webpage.pdf")
		Console.WriteLine("PDF saved successfully.")
	End Sub
End Class
VB   C#

Comparación entre IronPDF y PDFSharpCore: Figura 5 - Salida de URL a PDF

PDFSharpCore: Flexibilidad y control

PDFSharpCore, que es una adaptación parcial de PDFsharp para .NET Core, ofrece un control detallado del proceso de creación de documentos PDF. No convierte directamente HTML a PDF, pero ofrece amplias funciones para generar un nuevo documento desde cero o modificar archivos PDF existentes. He aquí un ejemplo básico utilizando PDFSharpCore:

var doc = new PdfDocument();
var page = doc.AddPage();
var graphics = XGraphics.FromPdfPage(page);
var font = new XFont("Verdana", 20, XFontStyle.Bold);
graphics.DrawString("Hello, World!", font, XBrushes.Black, new XRect(0, 0, page.Width, page.Height), XStringFormats.Center);
doc.Save("newdocument.pdf");
var doc = new PdfDocument();
var page = doc.AddPage();
var graphics = XGraphics.FromPdfPage(page);
var font = new XFont("Verdana", 20, XFontStyle.Bold);
graphics.DrawString("Hello, World!", font, XBrushes.Black, new XRect(0, 0, page.Width, page.Height), XStringFormats.Center);
doc.Save("newdocument.pdf");
Dim doc = New PdfDocument()
Dim page = doc.AddPage()
Dim graphics = XGraphics.FromPdfPage(page)
Dim font = New XFont("Verdana", 20, XFontStyle.Bold)
graphics.DrawString("Hello, World!", font, XBrushes.Black, New XRect(0, 0, page.Width, page.Height), XStringFormats.Center)
doc.Save("newdocument.pdf")
VB   C#

Comparación entre IronPDF y PDFSharpCore: Figura 6 - Salida de PDFSharpCore

Gestión de tareas PDF complejas: Funciones avanzadas

Funciones avanzadas de IronPDF

IronPDF destaca cuando se trata de tareas PDF avanzadas. Ofrece funciones como:

Conformidad con PDF/A: La capacidad de IronPDF para generar Documentos compatibles con PDF/A es esencial para las empresas que requieren una conservación digital a largo plazo. Esta función garantiza que los archivos PDF se produzcan de forma que cumplan estrictas normas de archivado, preservando la integridad de los documentos a lo largo del tiempo.

using IronPdf;
//  Abrir un PDF 
PdfDocument pdf = PdfDocument.FromFile("example.pdf");
//  Guardar el PDF/A-3b
pdf.SaveAsPdfA("PDFA-Document.pdf", PdfAVersions.PdfA3);
using IronPdf;
//  Abrir un PDF 
PdfDocument pdf = PdfDocument.FromFile("example.pdf");
//  Guardar el PDF/A-3b
pdf.SaveAsPdfA("PDFA-Document.pdf", PdfAVersions.PdfA3);
Imports IronPdf
'  Abrir un PDF 
Private pdf As PdfDocument = PdfDocument.FromFile("example.pdf")
'  Guardar el PDF/A-3b
pdf.SaveAsPdfA("PDFA-Document.pdf", PdfAVersions.PdfA3)
VB   C#

Marca de agua y seguridad: IronPDF proporciona herramientas robustas para añadir marcas de agua a los documentos PDF, lo que es crucial para la protección de la marca y los derechos de autor. Además, admite completas funciones de seguridad, como la posibilidad de cifrar archivos PDF, establecer permisos de usuario y añadir firmas digitales. Esto garantiza que la información sensible permanezca segura y que se mantenga la integridad de los documentos.

using IronPdf;
class Program
{
    static void Main(string [] args)
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello, IronPdf!</h1></body></html>");
        pdf.ApplyWatermark("<h2 style='color:red'>SAMPLE WATERMARK</h2>", 30, IronPdf.Editing.VerticalAlignment.Middle, IronPdf.Editing.HorizontalAlignment.Center);
        pdf.SecuritySettings.OwnerPassword = "top-secret"; //  contraseña para editar el pdf
        pdf.SecuritySettings.UserPassword = "sharable"; //  contraseña para abrir el pdf
        pdf.SaveAs("CombinedPDF.pdf");
        Console.WriteLine("PDF generated successfully!");
    }
}
using IronPdf;
class Program
{
    static void Main(string [] args)
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello, IronPdf!</h1></body></html>");
        pdf.ApplyWatermark("<h2 style='color:red'>SAMPLE WATERMARK</h2>", 30, IronPdf.Editing.VerticalAlignment.Middle, IronPdf.Editing.HorizontalAlignment.Center);
        pdf.SecuritySettings.OwnerPassword = "top-secret"; //  contraseña para editar el pdf
        pdf.SecuritySettings.UserPassword = "sharable"; //  contraseña para abrir el pdf
        pdf.SaveAs("CombinedPDF.pdf");
        Console.WriteLine("PDF generated successfully!");
    }
}
Imports IronPdf
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()
		Dim pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello, IronPdf!</h1></body></html>")
		pdf.ApplyWatermark("<h2 style='color:red'>SAMPLE WATERMARK</h2>", 30, IronPdf.Editing.VerticalAlignment.Middle, IronPdf.Editing.HorizontalAlignment.Center)
		pdf.SecuritySettings.OwnerPassword = "top-secret" '  contraseña para editar el pdf
		pdf.SecuritySettings.UserPassword = "sharable" '  contraseña para abrir el pdf
		pdf.SaveAs("CombinedPDF.pdf")
		Console.WriteLine("PDF generated successfully!")
	End Sub
End Class
VB   C#

Comparación entre IronPDF y PDFSharpCore: Figura 7 - PDF protegido con contraseña

Edición y fusión de PDF: IronPDF va más allá de la creación, ofreciendo funcionalidades para editar contenido dentro de archivos PDF existentes. Esto puede incluir la edición de textos, la manipulación de imágenes y los ajustes de diseño. Además, su capacidad de fusión permite la fusión de varios documentos PDF en un único archivo, lo que simplifica la gestión y distribución de documentos.

using IronPdf;
class Program
{
    static void Main(string [] args)
    {
        const string html_a = @"<p> [PDF_A] </p>
            <p> [PDF_A] 1st Page </p>
            <div style='page-break-after: always;'></div>
            <p> [PDF_A] 2nd Page</p>";
        const string html_b = @"<p> [PDF_B] </p>
            <p> [PDF_B] 1st Page </p>
            <div style='page-break-after: always;'></div>
            <p> [PDF_B] 2nd Page</p>";
        const string html_c =
            @"<p> Hello Iron </p>
            <p> This is 1st Page </p>
            <div style='page-break-after: always;'></div>
            <p> This is 2nd Page</p>
            <div style='page-break-after: always;'></div>
            <p> This is 3rd Page</p>";
        var renderer = new ChromePdfRenderer();
        var pdfdoc_a = renderer.RenderHtmlAsPdf(html_a);
        var pdfdoc_b = renderer.RenderHtmlAsPdf(html_b);
        var merged = PdfDocument.Merge(pdfdoc_a, pdfdoc_b);
        var pdfdoc_c = renderer.RenderHtmlAsPdf(html_c);
        merged.AppendPdf(pdfdoc_c);
        merged.SaveAs("CombinedDocument.pdf");
        Console.WriteLine("PDF generated successfully!");
    }
}
using IronPdf;
class Program
{
    static void Main(string [] args)
    {
        const string html_a = @"<p> [PDF_A] </p>
            <p> [PDF_A] 1st Page </p>
            <div style='page-break-after: always;'></div>
            <p> [PDF_A] 2nd Page</p>";
        const string html_b = @"<p> [PDF_B] </p>
            <p> [PDF_B] 1st Page </p>
            <div style='page-break-after: always;'></div>
            <p> [PDF_B] 2nd Page</p>";
        const string html_c =
            @"<p> Hello Iron </p>
            <p> This is 1st Page </p>
            <div style='page-break-after: always;'></div>
            <p> This is 2nd Page</p>
            <div style='page-break-after: always;'></div>
            <p> This is 3rd Page</p>";
        var renderer = new ChromePdfRenderer();
        var pdfdoc_a = renderer.RenderHtmlAsPdf(html_a);
        var pdfdoc_b = renderer.RenderHtmlAsPdf(html_b);
        var merged = PdfDocument.Merge(pdfdoc_a, pdfdoc_b);
        var pdfdoc_c = renderer.RenderHtmlAsPdf(html_c);
        merged.AppendPdf(pdfdoc_c);
        merged.SaveAs("CombinedDocument.pdf");
        Console.WriteLine("PDF generated successfully!");
    }
}
Imports IronPdf
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Const html_a As String = "<p> [PDF_A] </p>
            <p> [PDF_A] 1st Page </p>
            <div style='page-break-after: always;'></div>
            <p> [PDF_A] 2nd Page</p>"
		Const html_b As String = "<p> [PDF_B] </p>
            <p> [PDF_B] 1st Page </p>
            <div style='page-break-after: always;'></div>
            <p> [PDF_B] 2nd Page</p>"
		Const html_c As String = "<p> Hello Iron </p>
            <p> This is 1st Page </p>
            <div style='page-break-after: always;'></div>
            <p> This is 2nd Page</p>
            <div style='page-break-after: always;'></div>
            <p> This is 3rd Page</p>"
		Dim renderer = New ChromePdfRenderer()
		Dim pdfdoc_a = renderer.RenderHtmlAsPdf(html_a)
		Dim pdfdoc_b = renderer.RenderHtmlAsPdf(html_b)
		Dim merged = PdfDocument.Merge(pdfdoc_a, pdfdoc_b)
		Dim pdfdoc_c = renderer.RenderHtmlAsPdf(html_c)
		merged.AppendPdf(pdfdoc_c)
		merged.SaveAs("CombinedDocument.pdf")
		Console.WriteLine("PDF generated successfully!")
	End Sub
End Class
VB   C#

Comparación entre IronPDF y PDFSharpCore: Figura 8 - Editar salida PDF

Funciones avanzadas de PDFSharpCore

PDFSharpCore, aunque se centra más en lo básico, sigue ofreciendo capacidades para tareas complejas, como:

Modificación de documentos: PDFSharpCore facilita la modificación de documentos PDF existentes. Esto incluye tareas como añadir o eliminar páginas, actualizar textos e insertar imágenes.

using PdfSharpCore.Pdf;
using PdfSharpCore.Pdf.IO;
//  Abrir un documento PDF existente
var inputDocument = PdfReader.Open("input.pdf", PdfDocumentOpenMode.Modify);
//  Modificar la primera página
var page = inputDocument.Pages [0];
var graphics = XGraphics.FromPdfPage(page);
var font = new XFont("OpenSans", 20, XFontStyle.Bold);
graphics.DrawString("Added Text", font, XBrushes.Black, new XPoint(50, 100));
//  Guardar el documento modificado
inputDocument.Save("modified.pdf");
using PdfSharpCore.Pdf;
using PdfSharpCore.Pdf.IO;
//  Abrir un documento PDF existente
var inputDocument = PdfReader.Open("input.pdf", PdfDocumentOpenMode.Modify);
//  Modificar la primera página
var page = inputDocument.Pages [0];
var graphics = XGraphics.FromPdfPage(page);
var font = new XFont("OpenSans", 20, XFontStyle.Bold);
graphics.DrawString("Added Text", font, XBrushes.Black, new XPoint(50, 100));
//  Guardar el documento modificado
inputDocument.Save("modified.pdf");
Imports PdfSharpCore.Pdf
Imports PdfSharpCore.Pdf.IO
'  Abrir un documento PDF existente
Private inputDocument = PdfReader.Open("input.pdf", PdfDocumentOpenMode.Modify)
'  Modificar la primera página
Private page = inputDocument.Pages (0)
Private graphics = XGraphics.FromPdfPage(page)
Private font = New XFont("OpenSans", 20, XFontStyle.Bold)
graphics.DrawString("Added Text", font, XBrushes.Black, New XPoint(50, 100))
'  Guardar el documento modificado
inputDocument.Save("modified.pdf")
VB   C#

Gráficos y dibujo: La biblioteca utiliza las mismas rutinas de dibujo disponibles en PDFSharp, lo que permite a los desarrolladores incorporar elementos gráficos complejos a los documentos PDF. Esto incluye dibujar formas, utilizar distintos tipos de letra y aplicar color.

using PdfSharpCore.Drawing;
using PdfSharpCore.Pdf;
//  Crear un nuevo documento PDF
var document = new PdfDocument();
var page = document.AddPage();
var graphics = XGraphics.FromPdfPage(page);
//  Dibujar un rectángulo
graphics.DrawRectangle(XPens.Black, XBrushes.SkyBlue, 40, 100, 250, 120);
//  Dibujar texto
var font = new XFont("Verdana", 20, XFontStyle.BoldItalic);
graphics.DrawString("Hello, PDFSharpCore!", font, XBrushes.Black, new XRect(0, 0, page.Width, page.Height), XStringFormats.Center);
//  Guardar el documento
document.Save("drawing.pdf");
using PdfSharpCore.Drawing;
using PdfSharpCore.Pdf;
//  Crear un nuevo documento PDF
var document = new PdfDocument();
var page = document.AddPage();
var graphics = XGraphics.FromPdfPage(page);
//  Dibujar un rectángulo
graphics.DrawRectangle(XPens.Black, XBrushes.SkyBlue, 40, 100, 250, 120);
//  Dibujar texto
var font = new XFont("Verdana", 20, XFontStyle.BoldItalic);
graphics.DrawString("Hello, PDFSharpCore!", font, XBrushes.Black, new XRect(0, 0, page.Width, page.Height), XStringFormats.Center);
//  Guardar el documento
document.Save("drawing.pdf");
Imports PdfSharpCore.Drawing
Imports PdfSharpCore.Pdf
'  Crear un nuevo documento PDF
Private document = New PdfDocument()
Private page = document.AddPage()
Private graphics = XGraphics.FromPdfPage(page)
'  Dibujar un rectángulo
graphics.DrawRectangle(XPens.Black, XBrushes.SkyBlue, 40, 100, 250, 120)
'  Dibujar texto
Dim font = New XFont("Verdana", 20, XFontStyle.BoldItalic)
graphics.DrawString("Hello, PDFSharpCore!", font, XBrushes.Black, New XRect(0, 0, page.Width, page.Height), XStringFormats.Center)
'  Guardar el documento
document.Save("drawing.pdf")
VB   C#

Comparación entre IronPDF y PDFSharpCore: Figura 9 - Salida de gráficos

Generación de PDF a partir de datos: PDFSharpCore destaca en la creación de documentos PDF de forma dinámica a partir de datos de la aplicación. Esto es especialmente beneficioso para generar informes, facturas o cualquier documento que requiera la inclusión de datos dinámicos.

using PdfSharpCore.Drawing;
using PdfSharpCore.Pdf;
//  Crear un nuevo documento PDF
var document = new PdfDocument();
var page = document.AddPage();
var graphics = XGraphics.FromPdfPage(page);
var font = new XFont("Arial", 12);
//  Simular generación
var data = new List<string> { "Data 1", "Data 2", "Data 3" };
//  Generar PDF a partir de datos
var yPos = 20;
foreach (var item in data)
{
    graphics.DrawString(item, font, XBrushes.Black, new XRect(0, yPos, page.Width, page.Height), XStringFormats.TopLeft);
    yPos += 20;
}
//  Guardar el documento
document.Save("data-generated.pdf");
using PdfSharpCore.Drawing;
using PdfSharpCore.Pdf;
//  Crear un nuevo documento PDF
var document = new PdfDocument();
var page = document.AddPage();
var graphics = XGraphics.FromPdfPage(page);
var font = new XFont("Arial", 12);
//  Simular generación
var data = new List<string> { "Data 1", "Data 2", "Data 3" };
//  Generar PDF a partir de datos
var yPos = 20;
foreach (var item in data)
{
    graphics.DrawString(item, font, XBrushes.Black, new XRect(0, yPos, page.Width, page.Height), XStringFormats.TopLeft);
    yPos += 20;
}
//  Guardar el documento
document.Save("data-generated.pdf");
Imports PdfSharpCore.Drawing
Imports PdfSharpCore.Pdf
'  Crear un nuevo documento PDF
Private document = New PdfDocument()
Private page = document.AddPage()
Private graphics = XGraphics.FromPdfPage(page)
Private font = New XFont("Arial", 12)
'  Simular generación
Private data = New List(Of String) From {"Data 1", "Data 2", "Data 3"}
'  Generar PDF a partir de datos
Private yPos = 20
For Each item In data
	graphics.DrawString(item, font, XBrushes.Black, New XRect(0, yPos, page.Width, page.Height), XStringFormats.TopLeft)
	yPos += 20
Next item
'  Guardar el documento
document.Save("data-generated.pdf")
VB   C#

Conclusión

Comparación entre IronPDF y PDFSharpCore: Figura 10 - Licencias

Cuando se trata de integrar la funcionalidad PDF en sus proyectos .NET, la elección entre IronPDF y PDFSharpCore merece una cuidadosa consideración, con una ventaja particular para IronPDF por varias razones de peso. IronPDF se distingue por una gama más amplia de funciones y capacidades, especialmente para los desarrolladores que dan prioridad a las aplicaciones web y a las necesidades integrales de procesamiento de PDF.

IronPDF destaca por su facilidad de uso y flexibilidad, lo que permite a los desarrolladores convertir HTML a PDF sin esfuerzo, una función crucial para las aplicaciones web modernas en las que el contenido se genera y presenta con frecuencia en formato HTML. Además, IronPDF es compatible con funciones avanzadas de PDF, como edición, fusión, seguridad y conformidad con los estándares PDF/A, lo que proporciona un sólido conjunto de herramientas para gestionar operaciones complejas en PDF.

IronPDF se distingue no sólo por su completo conjunto de funciones, sino también por ofrecer un prueba gratuita lo que permite a los desarrolladores explorar sus capacidades de primera mano sin ninguna inversión inicial. Para quienes estén preparados para integrar IronPDF en su flujo de trabajo de desarrollo, la licencia comienza en $749.

< ANTERIOR
Comparación de la división de PDF en C# entre iTextSharp e IronPDF
SIGUIENTE >
Comparación entre IronPDF y Apryse C#

¿Listo para empezar? Versión: 2024.6 recién publicada

Comenzar prueba gratuita Descargas totales: 9,602,420
Ver licencias >