COMPARACIóN DE PRODUCTOS

Comparación entre Report .NET e IronPDF

Chipego
Chipego Kalinda
29 de abril, 2024
Compartir:

En este artículo, examinaremos de cerca dos bibliotecas populares de C# utilizadas para trabajar con archivos PDF: IronPDF - La biblioteca PDF de .NET para desarrolladores de C# y Report.NET. Estas herramientas son esenciales para los desarrolladores que necesitan crear, modificar o interactuar con documentos PDF a través de sus aplicaciones C#. Ambas bibliotecas ofrecen una serie de funcionalidades diseñadas para facilitar y hacer más eficiente el manejo de los PDF, pero lo hacen de formas diferentes.

IronPDF y Report.NET permiten a los desarrolladores generar documentos de forma dinámica, editar contenidos y extraer texto e imágenes de los PDF. También admiten el procesamiento de formularios, la adición de firmas digitales y la garantía de que las aplicaciones puedan manejar PDF en distintas plataformas sin perder la fidelidad del documento. Esto significa que, sea cual sea el dispositivo o el sistema operativo, los PDF tendrán el aspecto y funcionarán según lo previsto.

A lo largo de esta comparación, profundizaremos en las características específicas que ofrece cada biblioteca, cómo funcionan, proporcionaremos fragmentos de código para ilustrar cómo se pueden utilizar y hablaremos de sus condiciones de licencia. Esta comparación pretende ofrecer a los desarrolladores una idea clara de lo que puede hacer cada biblioteca, ayudándoles a decidir cuál puede ser la más adecuada para los requisitos de su proyecto. Analicemos las capacidades y diferencias entre IronPDF y Report.NET, centrándonos en la simplicidad y en perspectivas prácticas para los desarrolladores.

1. Report.NET C# Biblioteca

Report.NET es una robusta biblioteca de C# diseñada para ayudar a los desarrolladores a crear, gestionar y manipular documentos PDF directamente dentro de sus aplicaciones .NET. Esta herramienta es conocida por su sencillo enfoque de la generación y manipulación de PDF, que permite crear documentos PDF complejos desde cero o modificar los existentes. Sus capacidades van desde la simple adición de texto hasta la incorporación de imágenes y formas, lo que lo convierte en una opción versátil para los desarrolladores que buscan implementar funcionalidades PDF en sus proyectos.

1.1 Características principales de Report.NET

1.1.1 Creación y edición de documentos

Report.NET brilla en la creación de nuevos documentos PDF y en la edición de los existentes. Los desarrolladores pueden añadir fácilmente texto, imágenes y gráficos, lo que permite elaborar documentos detallados y visualmente atractivos.

1.1.2 Flexibilidad en la gestión de contenidos

Esta biblioteca permite controlar con precisión el contenido del documento, incluido el formato del texto, la colocación de imágenes y los elementos gráficos. Este nivel de control garantiza que el PDF final tenga exactamente el aspecto deseado.

1.1.3 Facilidad de uso

Centrado en la sencillez, Report.NET simplifica el proceso de generación de PDF, haciéndolo accesible incluso a quienes no están familiarizados con el trabajo con PDF en un contexto de programación.

1.1.4 Compatibilidad entre plataformas

Report.NET está diseñado para funcionar sin problemas en toda la plataforma .NET, incluida .NET Core, lo que garantiza que las aplicaciones puedan generar y gestionar PDF independientemente del sistema operativo.

1.1.5 Personalización y estilo

La biblioteca ofrece amplias opciones de personalización para documentos PDF, lo que permite a los desarrolladores ajustar el diseño, el estilo y el aspecto general para satisfacer sus necesidades específicas.

1.1.6 Código abierto

Como herramienta de código abierto, Report.NET se beneficia de las contribuciones de la comunidad, lo que garantiza que se mantenga actualizada y reciba nuevas funciones a lo largo del tiempo. Este apoyo de la comunidad también significa que los desarrolladores pueden acceder a una gran cantidad de conocimientos y recursos.

2. IronPDF C# Biblioteca

IronPDF es una completa biblioteca .NET diseñada para facilitar la creación, manipulación y renderización de documentos PDF dentro de aplicaciones .NET. Esta herramienta destaca por su capacidad para gestionar tanto la generación de PDF a partir de HTML como la edición directa de archivos PDF existentes. Es muy útil para crear informes. IronPDF también se integra sin problemas con SQL Server Reporting Services. Podemos crear un diseñador de informes de usuario final con IronPDF para crear una herramienta de informes y un visor de informes.

2.1 Características principales de IronPDF

2.1.1 Conversión de HTML a PDF

Una de las fortalezas principales de IronPDF es su capacidad para convertir HTML y CSS en documentos PDF. Esta función tiene un valor incalculable para los desarrolladores que desean transformar contenidos web a un formato portátil conservando el diseño y la maquetación originales.

2.1.2 Manipulación de PDF

IronPDF destaca por ofrecer a los desarrolladores herramientas para editar y manipular documentos PDF. Esto incluye agregar o eliminar páginas, modificar texto y incrustar imágenes. También podemos extraer datos de los informes utilizando IronPDF.

2.1.3 Gestión de formularios

La biblioteca admite la creación y edición de formularios PDF, lo que permite a los usuarios interactuar con documentos de manera dinámica. Esta funcionalidad es crucial para las aplicaciones que requieren la participación de los usuarios finales, como las encuestas o los formularios de solicitud.

2.1.4 Elementos de seguridad

Con IronPDF, implementar medidas de seguridad como el cifrado y la protección con contraseña es sencillo. Estas funciones garantizan que la información confidencial de los documentos PDF permanezca a salvo de accesos no autorizados.

2.1.5 Impresión y renderizado

IronPDF permite a los desarrolladores renderizar PDFs tanto para la visualización en pantalla como para la impresión física, asegurando una salida de alta calidad en ambos casos. Esto facilita la preparación de documentos para diversas necesidades de presentación o distribución.

2.1.6 Soporte multiplataforma

IronPDF funciona en varias plataformas .NET, se adhiere a los estándares de código .NET y facilita el desarrollo en diversos entornos sin problemas de compatibilidad.

2.1.7 Documentación y asistencia completas

IronPDF cuenta con documentación detallada y soporte dedicado que ayuda a los desarrolladores a navegar por las características de la biblioteca e integrar sus funcionalidades en sus aplicaciones de manera eficiente.

2.1.8 Edición avanzada de PDF

IronPDF ofrece muchas funciones avanzadas de edición. Esto incluye la capacidad de unir y dividir documentos PDF, lo cual es particularmente útil para organizar grandes volúmenes de información o extraer secciones específicas de un documento para uso separado.

2.1.9 Encabezados y pies de página personalizados

La biblioteca permite la personalización de encabezados y pies de página dentro de documentos PDF. Esta función es esencial para añadir marcas, números de página o títulos de documentos coherentes en todas las páginas, lo que mejora el aspecto profesional de los resultados.

3. Creación de un proyecto de consola en Visual Studio

Crear una aplicación de consola en Visual Studio IDE es un proceso sencillo que implica varios pasos.

3.1 Iniciar Visual Studio

Para empezar, abra Microsoft Visual Studio. Si no lo tienes instalado, necesitarás descargarlo e instalarlo desde el sitio web oficial de Microsoft. Una vez instalado, inicie el estudio visual.

3.2 Crear un nuevo proyecto

Tras abrir Visual Studio, aparecerá la ventana de inicio. Aquí, seleccione la opción "Crear un nuevo proyecto" para iniciar el proceso de creación de una nueva aplicación de consola.

Una comparación entre Report .NET e IronPDF: Figura 1 - Abre Visual Studio y haz clic en la opción "Crear un nuevo proyecto".

3.3 Elegir el tipo de proyecto

En la ventana "Crear un nuevo proyecto", se le presentarán varias plantillas de proyecto. Escribe "console" en el cuadro de búsqueda para filtrar las opciones y, a continuación, selecciona "Console App" en la lista. Asegúrate de elegir la plantilla que corresponda al lenguaje de programación que deseas utilizar, como C#.

Una comparación entre Report .NET e IronPDF: Figura 2 - A continuación, elige el tipo de proyecto "Aplicación de consola" en el lenguaje de programación C#.

3.4 Configurar el proyecto

Una vez seleccionada la plantilla de la aplicación de consola, haz clic en "Siguiente" para pasar a la pantalla de configuración del proyecto. Aquí tendrá que facilitar algunos detalles sobre su proyecto:

  • Nombre del Proyecto: Dale a tu proyecto un nombre significativo que refleje su propósito.

    • Ubicación: Elige dónde en tu computadora quieres guardar los archivos del proyecto.

    ![Una Comparación Entre Report .NET e IronPDF: Figura 3 - Especifique el nombre y la ubicación del proyecto para el proyecto de Aplicación de Consola. De forma predeterminada, el nombre de la Solución es el mismo que el nombre del Proyecto, pero puedes cambiarlo.

  • Nombre de la solución: Por defecto, esto es lo mismo que el nombre de su proyecto, pero puede cambiarlo si planea incluir múltiples proyectos en la misma solución.

    • Framework: Seleccione la versión del .NET Framework que desea usar como objetivo. Si no estás seguro, elige la última versión.

    Una Comparación Entre Report .NET e IronPDF: Figura 4 - Seleccione la versión de .NET Framework que desea. Si no estás seguro, elige la última versión.

3.5 Crear el proyecto

Después de rellenar toda la información necesaria, haga clic en el botón "Crear". Visual Studio generará ahora un nuevo proyecto de aplicación de consola basado en sus especificaciones. Este proceso puede tardar unos instantes.

4. Instalación de la biblioteca IronPDF

Para aprovechar las capacidades de IronPDF en su proyecto, primero debe instalar la biblioteca. Existen varios métodos para conseguirlo, cada uno adaptado a diferentes flujos de trabajo o preferencias de desarrollo. A continuación se presentan tres métodos comunes para instalar la biblioteca IronPDF en su proyecto de Visual Studio.

4.1 Instalación mediante el gestor de paquetes NuGet

La interfaz de usuario del gestor de paquetes NuGet en Visual Studio ofrece una forma sencilla de examinar, seleccionar e instalar paquetes.

  1. En Visual Studio, navegue hasta su proyecto dentro del Explorador de soluciones, haga clic con el botón derecho del ratón sobre él y elija la opción "Gestionar paquetes NuGet...".

  2. Haga clic en la pestaña "Examinar" y escriba "IronPDF" en el cuadro de búsqueda.

  3. Encuentre el paquete IronPDF en los resultados de la búsqueda, selecciónelo y haga clic en el botón "Instalar". Visual Studio se encargará de la descarga y la instalación automáticamente.

    Una Comparación entre Report .NET e IronPDF: Figura 5 - Instalar IronPDF utilizando el Administrador de Paquetes NuGet para la Solución buscándolo con "IronPdf" en la barra de búsqueda del Gestor de Paquetes NuGet, luego seleccionar el proyecto y hacer clic en el botón Instalar.

4.2 Instalación mediante la consola del gestor de paquetes NuGet

Para quienes prefieren utilizar herramientas de línea de comandos, la consola del gestor de paquetes NuGet es una potente alternativa.

  1. Abrir la Consola: Ve al menú "Herramientas" en Visual Studio, luego navega a "Administrador de paquetes NuGet" > "Consola del administrador de paquetes".

    1. Comando de instalación: En la consola, escriba el siguiente comando y presione Enter:
Install-Package IronPdf

Este comando indica a NuGet que descargue e instale la última versión de IronPDF en su proyecto.

4.3 Instalación mediante el sitio web de NuGet

Si prefiere descargar manualmente el paquete o necesita una versión específica de IronPDF, el sitio web NuGet es una buena opción.

  1. Visita el sitio web de NuGet: Ve a nuget.org y busca "IronPDF".

  2. Descargar el paquete: Desde la página de IronPDF, seleccione la versión que necesita y descargue el archivo .nupkg.

  3. Instalación Manual: Una vez descargado, puedes agregar el paquete a tu proyecto manualmente. En Visual Studio, vaya al menú "Herramientas", luego a "Opciones" > "Gestor de paquetes NuGet" > "Fuentes de paquetes". Agrega una nueva fuente que apunte a la carpeta donde descargaste el archivo .nupkg. Finalmente, utiliza la interfaz de usuario del Administrador de paquetes o la Consola en Visual Studio para instalar el paquete desde tu fuente local.

5. Instalación de la biblioteca Report.NET

Abra su navegador web y vaya al repositorio Report.NET GitHub en https://github.com/ritchiecarroll/Report.NET/tree/master. Esta página contiene la versión más reciente de la biblioteca Report.NET junto con su código fuente.

5.1 Descargar la biblioteca

En la página del repositorio, localice el botón "Código" y haga clic en él. En el menú desplegable, seleccione "Descargar ZIP" para descargar todo el repositorio como archivo ZIP. Guarde este archivo en una ubicación conveniente de su ordenador y extraiga su contenido.

5.2 Añadir Report.NET al proyecto

Tras extraer el archivo ZIP, encontrará el código fuente de la biblioteca Report.NET entre los archivos extraídos. Para utilizar Report.NET en su proyecto de Visual Studio, siga estos pasos:

  1. Abra Su Proyecto: Inicie Visual Studio y abra el proyecto al que desea agregar Report.NET.

    1. Agregar la biblioteca manualmente: Hay un par de formas de incluir la biblioteca en tu proyecto:

      • Como un Ensamblado Compilado: Si el repositorio de GitHub incluye un archivo DLL compilado, simplemente puedes agregar una referencia a este DLL en tu proyecto. Haga clic con el botón derecho del ratón en "Referencias" en el Explorador de soluciones del proyecto, seleccione "Añadir referencia..." y, a continuación, busque y seleccione el archivo DLL.
    • Incluyendo Archivos Fuente: Si prefieres incluir el código fuente directamente o si no se proporciona un DLL compilado, puedes agregar los archivos de código fuente a tu proyecto. Haga clic con el botón derecho del ratón en su proyecto en el Explorador de soluciones, seleccione "Añadir" > "Elemento existente..." y, a continuación, vaya a los archivos de código fuente Report.NET que extrajo del ZIP y selecciónelos.
  2. Asegúrese de la compatibilidad: Asegúrese de que su proyecto apunte a una versión de .NET Framework compatible según lo requerido por Report.NET.

6. Características avanzadas en IronPDF vs Report.NET C#

6.1 Funciones avanzadas de IronPDF C#

IronPDF viene con un conjunto de funciones avanzadas diseñadas para manejar con facilidad una amplia gama de tareas relacionadas con PDF.

6.1.1 Renderizado de HTML a PDF

IronPDF puede tomar contenido HTML, incluidos CSS y JavaScript, y convertirlo directamente en un documento PDF. Esto significa que las páginas web o las plantillas HTML pueden convertirse en PDF con el mismo aspecto que en un navegador.

6.1.1.1 Cadena HTML a PDF

IronPDF permite la conversión directa de cadenas HTML a PDF. Esto significa que los desarrolladores pueden tomar el código HTML almacenado como una variable de cadena y utilizar IronPDF para convertirlo en un archivo PDF. Esta función es especialmente útil cuando el contenido HTML es generado o modificado dinámicamente por la aplicación antes de la conversión.

using IronPdf;
var Renderer = new IronPdf.HtmlToPdf();
var PDF = Renderer.RenderHtmlAsPdf("<h1>Hello IronPDF</h1>");
PDF.SaveAs("HtmlStringToPdf.pdf");
using IronPdf;
var Renderer = new IronPdf.HtmlToPdf();
var PDF = Renderer.RenderHtmlAsPdf("<h1>Hello IronPDF</h1>");
PDF.SaveAs("HtmlStringToPdf.pdf");
Imports IronPdf
Private Renderer = New IronPdf.HtmlToPdf()
Private PDF = Renderer.RenderHtmlAsPdf("<h1>Hello IronPDF</h1>")
PDF.SaveAs("HtmlStringToPdf.pdf")
$vbLabelText   $csharpLabel

6.1.1.2 Archivo HTML a PDF

De manera similar, IronPDF puede convertir archivos HTML existentes en documentos PDF. Para ello, se lee el archivo HTML del sistema de archivos y se utiliza IronPDF para crear un documento PDF con el mismo formato y estructura.

using IronPdf;
var Renderer = new ChromePdfRenderer();
var PDF = Renderer.RenderHTMLFileAsPdf("invoice.html");
PDF.SaveAs("HtmlFileToPdf.pdf");
using IronPdf;
var Renderer = new ChromePdfRenderer();
var PDF = Renderer.RenderHTMLFileAsPdf("invoice.html");
PDF.SaveAs("HtmlFileToPdf.pdf");
Imports IronPdf
Private Renderer = New ChromePdfRenderer()
Private PDF = Renderer.RenderHTMLFileAsPdf("invoice.html")
PDF.SaveAs("HtmlFileToPdf.pdf")
$vbLabelText   $csharpLabel

Una comparación entre Report .NET e IronPDF: Figura 6 - Archivo HTML a salida PDF usando IronPDF

6.1.1.3 URL a PDF

IronPDF también es capaz de renderizar un PDF desde una URL en vivo. Esto permite a los desarrolladores introducir una dirección web, e IronPDF obtendrá el contenido HTML de la URL y lo renderizará como PDF.

using IronPdf;
var Renderer = new ChromePdfRenderer();
var PDF = Renderer.RenderUrlAsPdf("http://ironpdf.com");
PDF.SaveAs("UrlToPdf.pdf");
using IronPdf;
var Renderer = new ChromePdfRenderer();
var PDF = Renderer.RenderUrlAsPdf("http://ironpdf.com");
PDF.SaveAs("UrlToPdf.pdf");
Imports IronPdf
Private Renderer = New ChromePdfRenderer()
Private PDF = Renderer.RenderUrlAsPdf("http://ironpdf.com")
PDF.SaveAs("UrlToPdf.pdf")
$vbLabelText   $csharpLabel

Una comparación entre Report .NET e IronPDF: Figura 7 - Salida de conversión de URL a PDF usando IronPDF

6.1.2 Edición de PDF

Con IronPDF, puedes editar documentos PDF existentes. Esto incluye añadir texto, imágenes y páginas o eliminar páginas del documento. También puedes buscar y reemplazar texto del documento PDF.

using IronPdf;
var document = PdfDocument.FromFile("original_document.pdf");
const int targetPageIndex = 1;
const string oldString = "Hello, World!";
const string newString = "Greetings, Universe!";
document.ReplaceTextOnPage(targetPageIndex, oldString, newString);
document.SaveAs("modified_document.pdf");
using IronPdf;
var document = PdfDocument.FromFile("original_document.pdf");
const int targetPageIndex = 1;
const string oldString = "Hello, World!";
const string newString = "Greetings, Universe!";
document.ReplaceTextOnPage(targetPageIndex, oldString, newString);
document.SaveAs("modified_document.pdf");
Imports IronPdf
Private document = PdfDocument.FromFile("original_document.pdf")
Private Const targetPageIndex As Integer = 1
Private Const oldString As String = "Hello, World!"
Private Const newString As String = "Greetings, Universe!"
document.ReplaceTextOnPage(targetPageIndex, oldString, newString)
document.SaveAs("modified_document.pdf")
$vbLabelText   $csharpLabel

Una Comparación entre Report .NET e IronPDF: Figura 8 - Salida: Editando PDF existente usando IronPDF

6.1.3 Extracción de texto e imágenes

Esta biblioteca puede extraer texto e imágenes de archivos PDF, similar a Crystal Reports, que puedes usar para indexar, buscar o reutilizar contenido.

6.1.4 Generar formularios PDF

IronPDF admite la creación de formularios PDF. Los desarrolladores pueden crear mediante programación formularios dentro de un PDF y los usuarios pueden rellenarlos.

using IronPdf;
using System;
const string alternativeHtmlContent = @"
    <html>
        <body>
            <h2>Alternative PDF Form</h2>
            <form>
              Name: <br> 
              Age: <br> 
              <br>
              <p>Select country:</p>
              <select name='country'>
                <option value='USA'>USA</option>
                <option value='UK'>UK</option>
                <option value='Canada'>Canada</option>
              </select>
              <br>
              <p>Select interests:</p>
              <label for='interest1'> Interest 1</label><br>
              <label for='interest2'> Interest 2</label><br>
            </form>
        </body>
    </html>";
var alternativePdfRenderer = new ChromePdfRenderer();
alternativePdfRenderer.RenderingOptions.CreatePdfFormsFromHtml = true;
alternativePdfRenderer.RenderHtmlAsPdf(alternativeHtmlContent).SaveAs("AlternativeForm.pdf");
using IronPdf;
using System;
const string alternativeHtmlContent = @"
    <html>
        <body>
            <h2>Alternative PDF Form</h2>
            <form>
              Name: <br> 
              Age: <br> 
              <br>
              <p>Select country:</p>
              <select name='country'>
                <option value='USA'>USA</option>
                <option value='UK'>UK</option>
                <option value='Canada'>Canada</option>
              </select>
              <br>
              <p>Select interests:</p>
              <label for='interest1'> Interest 1</label><br>
              <label for='interest2'> Interest 2</label><br>
            </form>
        </body>
    </html>";
var alternativePdfRenderer = new ChromePdfRenderer();
alternativePdfRenderer.RenderingOptions.CreatePdfFormsFromHtml = true;
alternativePdfRenderer.RenderHtmlAsPdf(alternativeHtmlContent).SaveAs("AlternativeForm.pdf");
Imports IronPdf
Imports System
Private Const alternativeHtmlContent As String = "
    <html>
        <body>
            <h2>Alternative PDF Form</h2>
            <form>
              Name: <br> 
              Age: <br> 
              <br>
              <p>Select country:</p>
              <select name='country'>
                <option value='USA'>USA</option>
                <option value='UK'>UK</option>
                <option value='Canada'>Canada</option>
              </select>
              <br>
              <p>Select interests:</p>
              <label for='interest1'> Interest 1</label><br>
              <label for='interest2'> Interest 2</label><br>
            </form>
        </body>
    </html>"
Private alternativePdfRenderer = New ChromePdfRenderer()
alternativePdfRenderer.RenderingOptions.CreatePdfFormsFromHtml = True
alternativePdfRenderer.RenderHtmlAsPdf(alternativeHtmlContent).SaveAs("AlternativeForm.pdf")
$vbLabelText   $csharpLabel

Una comparación entre Report .NET e IronPDF: Figura 9 - PDF de salida: Generación de formularios PDF usando IronPDF

6.1.5 Fusionar documentos PDF

Puede combinar múltiples archivos PDF en un solo documento. Esta función resulta útil para consolidar informes o combinar diferentes secciones de documentos.

using IronPdf;
var firstHtmlContent = @"<h1>Document A</h1>
        <p>This is the first document.</p>
        <div style='page-break-after: always;'></div>
        <p>Continuation of Document A</p>";
var secondHtmlContent = @"<h1>Document B</h1>
        <p>This is the second document.</p>
        <div style='page-break-after: always;'></div>
        <p>Continuation of Document B</p>";
var pdfRenderer = new ChromePdfRenderer();
var pdfDocA = pdfRenderer.RenderHtmlAsPdf(firstHtmlContent);
var pdfDocB = pdfRenderer.RenderHtmlAsPdf(secondHtmlContent);
var mergedPdf = PdfDocument.Merge(pdfDocA, pdfDocB);
mergedPdf.SaveAs("MergedDocuments.pdf");
using IronPdf;
var firstHtmlContent = @"<h1>Document A</h1>
        <p>This is the first document.</p>
        <div style='page-break-after: always;'></div>
        <p>Continuation of Document A</p>";
var secondHtmlContent = @"<h1>Document B</h1>
        <p>This is the second document.</p>
        <div style='page-break-after: always;'></div>
        <p>Continuation of Document B</p>";
var pdfRenderer = new ChromePdfRenderer();
var pdfDocA = pdfRenderer.RenderHtmlAsPdf(firstHtmlContent);
var pdfDocB = pdfRenderer.RenderHtmlAsPdf(secondHtmlContent);
var mergedPdf = PdfDocument.Merge(pdfDocA, pdfDocB);
mergedPdf.SaveAs("MergedDocuments.pdf");
Imports IronPdf
Private firstHtmlContent = "<h1>Document A</h1>
        <p>This is the first document.</p>
        <div style='page-break-after: always;'></div>
        <p>Continuation of Document A</p>"
Private secondHtmlContent = "<h1>Document B</h1>
        <p>This is the second document.</p>
        <div style='page-break-after: always;'></div>
        <p>Continuation of Document B</p>"
Private pdfRenderer = New ChromePdfRenderer()
Private pdfDocA = pdfRenderer.RenderHtmlAsPdf(firstHtmlContent)
Private pdfDocB = pdfRenderer.RenderHtmlAsPdf(secondHtmlContent)
Private mergedPdf = PdfDocument.Merge(pdfDocA, pdfDocB)
mergedPdf.SaveAs("MergedDocuments.pdf")
$vbLabelText   $csharpLabel

Una Comparación Entre Report .NET & IronPDF: Figura 10 - PDF de Salida: Generación de múltiples archivos PDF y su combinación en un solo PDF.

6.1.6 Dividir documentos PDF

Por el contrario, IronPDF puede dividir un PDF único en múltiples documentos. Esto puede ser necesario si desea distribuir páginas individuales o secciones.

6.1.7 Cifrar y descifrar PDFs

IronPDF permite la encriptación y desencriptación de documentos PDF, añadiendo una capa extra de seguridad a la información sensible.

using IronPdf;
using System;
var encryptedPdf = PdfDocument.FromFile("protected.pdf", "password");
encryptedPdf.SecuritySettings.RemovePasswordsAndEncryption();
encryptedPdf.SecuritySettings.MakePdfDocumentReadOnly("super-secret-key");
encryptedPdf.Password = "new-password";
encryptedPdf.SaveAs("secured.pdf");
using IronPdf;
using System;
var encryptedPdf = PdfDocument.FromFile("protected.pdf", "password");
encryptedPdf.SecuritySettings.RemovePasswordsAndEncryption();
encryptedPdf.SecuritySettings.MakePdfDocumentReadOnly("super-secret-key");
encryptedPdf.Password = "new-password";
encryptedPdf.SaveAs("secured.pdf");
Imports IronPdf
Imports System
Private encryptedPdf = PdfDocument.FromFile("protected.pdf", "password")
encryptedPdf.SecuritySettings.RemovePasswordsAndEncryption()
encryptedPdf.SecuritySettings.MakePdfDocumentReadOnly("super-secret-key")
encryptedPdf.Password = "new-password"
encryptedPdf.SaveAs("secured.pdf")
$vbLabelText   $csharpLabel

6.1.8 Establecer propiedades y metadatos del documento

Con esta biblioteca, establecer las propiedades del documento, como el título, el autor y los metadatos, es muy sencillo. Esto ayuda a gestionar y organizar los documentos.

using IronPdf;
using System;
var encryptedPdf = PdfDocument.FromFile("sample.pdf");
pdf.MetaData.Author = "Iron Developer";
pdf.MetaData.Keywords = "Confidential, Private";
pdf.MetaData.ModifiedDate = DateTime.Now;
pdf.SaveAs("modified.pdf");
using IronPdf;
using System;
var encryptedPdf = PdfDocument.FromFile("sample.pdf");
pdf.MetaData.Author = "Iron Developer";
pdf.MetaData.Keywords = "Confidential, Private";
pdf.MetaData.ModifiedDate = DateTime.Now;
pdf.SaveAs("modified.pdf");
Imports IronPdf
Imports System
Private encryptedPdf = PdfDocument.FromFile("sample.pdf")
pdf.MetaData.Author = "Iron Developer"
pdf.MetaData.Keywords = "Confidential, Private"
pdf.MetaData.ModifiedDate = DateTime.Now
pdf.SaveAs("modified.pdf")
$vbLabelText   $csharpLabel

6.1.9 Conformidad PDF/A

IronPDF puede generar documentos compatibles con PDF/A, que son necesarios para el archivo a largo plazo y propósitos de conservación de registros.

6.1.10 Informes XML con IronPDF

IronPDF no admite la conversión directa de XML a PDF, pero un enfoque viable consiste en convertir inicialmente los datos XML a formato HTML. Esto se logra empleando XSLT (Transformaciones de Lenguaje de Hojas de Estilo Extensibles), un potente lenguaje de estilo XML diseñado para transformar documentos XML en otros formatos como HTML, texto o incluso un nuevo documento XML. Digamos que es nuestro archivo data.xml:

<?xml version="1.0" encoding="UTF-8"?>
<Library>
    <Book id="1">
        <Title>The Great Gatsby</Title>
        <Author>F. Scott Fitzgerald</Author>
        <Genre>Fiction</Genre>
        <Year>1925</Year>
    </Book>
    <Book id="2">
        <Title>To Kill a Mockingbird</Title>
        <Author>Harper Lee</Author>
        <Genre>Fiction</Genre>
        <Year>1960</Year>
    </Book>
    <Book id="3">
        <Title>1984</Title>
        <Author>George Orwell</Author>
        <Genre>Dystopian</Genre>
        <Year>1949</Year>
    </Book>
</Library>
XML

Y es nuestro archivo style.xslt:

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:output method="html" doctype-system="about:legacy-compat" encoding="UTF-8" indent="yes"/>
    <xsl:template match="/">
        <html>
            <head>
                <title>Library Catalog</title>
                <style>
                    body { font-family: Arial, sans-serif; margin: 20px; }
                    table { border-collapse: collapse; width: 100%; }
                    th, td { text-align: left; padding: 8px; }
                    tr:nth-child(even) { background-color: #f2f2f2; }
                    th { background-color: #4CAF50; color: white; }
                </style>
            </head>
            <body>
                <h2>Library Catalog</h2>
                <table>
                    <tr>
                        <th>Title</th>
                        <th>Author</th>
                        <th>Genre</th>
                        <th>Year</th>
                    </tr>
                    <xsl:for-each select="Library/Book">
                        <tr>
                            <td><xsl:value-of select="Title"/></td>
                            <td><xsl:value-of select="Author"/></td>
                            <td><xsl:value-of select="Genre"/></td>
                            <td><xsl:value-of select="Year"/></td>
                        </tr>
                    </xsl:for-each>
                </table>
            </body>
        </html>
    </xsl:template>
</xsl:stylesheet>
XML

Aquí está el fragmento de código que cómo podemos abordar esta lógica:

using System;
using System.Xml.Xsl;
using System.Xml;
XslCompiledTransform transform = new XslCompiledTransform();
transform.Load("style.xslt");
XmlReader reader = XmlReader.Create("data.xml");
XmlWriterSettings settings = new XmlWriterSettings { Indent = true, OmitXmlDeclaration = true };
using (XmlWriter writer = XmlWriter.Create("output.html", settings))
{
    transform.Transform(reader, writer);
}
License.LicenseKey = "Liecense-Key";
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlFileAsPdf("output.html");
pdf.SaveAs("Report.pdf");
using System;
using System.Xml.Xsl;
using System.Xml;
XslCompiledTransform transform = new XslCompiledTransform();
transform.Load("style.xslt");
XmlReader reader = XmlReader.Create("data.xml");
XmlWriterSettings settings = new XmlWriterSettings { Indent = true, OmitXmlDeclaration = true };
using (XmlWriter writer = XmlWriter.Create("output.html", settings))
{
    transform.Transform(reader, writer);
}
License.LicenseKey = "Liecense-Key";
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlFileAsPdf("output.html");
pdf.SaveAs("Report.pdf");
Imports System
Imports System.Xml.Xsl
Imports System.Xml
Private transform As New XslCompiledTransform()
transform.Load("style.xslt")
Dim reader As XmlReader = XmlReader.Create("data.xml")
Dim settings As New XmlWriterSettings With {
	.Indent = True,
	.OmitXmlDeclaration = True
}
Using writer As XmlWriter = XmlWriter.Create("output.html", settings)
	transform.Transform(reader, writer)
End Using
License.LicenseKey = "Liecense-Key"
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlFileAsPdf("output.html")
pdf.SaveAs("Report.pdf")
$vbLabelText   $csharpLabel
  1. Comienzas con una hoja de estilo XSLT (style.xslt) que indica cómo los datos XML deben estructurarse como HTML. La clase XslCompiledTransform en .NET se utiliza para cargar su archivo XSLT.

  2. Utilice XmlReader para cargar sus datos XML (data.xml). XmlReader es eficiente para este propósito porque proporciona una vista de solo avance y solo lectura de los datos XML.

  3. El HTML transformado se escribe en un archivo (output.html) usando XmlWriter, configurado para producir HTML con sangría para legibilidad y para omitir la declaración XML, la cual no es necesaria en el resultado HTML.

  4. Con el archivo HTML listo, se utiliza ChromePdfRenderer de IronPDF para convertir el documento HTML en un PDF. Este renderizador imita un motor de renderizado de alta calidad, garantizando que el PDF generado represente fielmente el contenido HTML.

  5. Finalmente, el documento PDF se guarda en el sistema de archivos (Report.pdf). Este paso concluye el proceso de conversión, dando como resultado un documento PDF derivado de los datos XML originales.

    Es cómo generamos informes utilizando XML e IronPDF. El archivo PDF de salida que generamos:

    Una comparación entre Report .NET & IronPDF: Figura 11 - Archivo PDF de salida de informes XML usando IronPDF y XSLT

    También podemos crear informes interactivos de SAP mediante programación y convertirlos después con IronPDF. Para una guía más detallada, siga esta guía sobre generación de informes en C#.

6.2 Funciones avanzadas de Report.NET

Report.NET proporciona un conjunto de características avanzadas que permiten la generación y personalización exhaustiva de PDFs. Las características que aparecen en la imagen reflejan algunas de estas capacidades avanzadas. Analicemos cada una de ellas en detalle.

6.2.1 Añadir fuentes

Esta función permite utilizar varios estilos y tamaños de fuente en un documento PDF. Permite a los desarrolladores probar el aspecto de distintos tipos de letra, asegurándose de que el texto se muestra correctamente y de acuerdo con las especificaciones del diseño.

using Root.Reports;
using System;
using System.Drawing;
namespace ReportSamples {
  public class Test : Report {
    private readonly FontDef fontDef;
    private readonly FontProp fontProp_Title;
    private readonly FontProp fontProp_Label;
    public Test() {
      fontDef = FontDef.FontDefFromName(this, FontDef.StandardFont.Helvetica);
      fontProp_Title = new FontPropMM(fontDef, 6) { Bold = true };
      fontProp_Label = new FontPropMM(fontDef, 4);
    }
    protected override void Create() {
      FontTest();
    }
    private void FontTest() {
      FontProp fp_Title = new FontPropMM(fontDef, 12) { Bold = true };
      FontProp fp = new FontPropMM(fontDef, 6);
      FontProp fp_Small = new FontPropMM(fontDef, 1.4);
      FontProp fp_XSmall = new FontPropMM(fontDef, 0.8);
      Page page_Cur = new Page(this);
      page_Cur.AddCB_MM(30, new RepString(fontProp_Title, "Font Test"));
      Double rX = 300;
      Double rY = 40;
      for (Int32 i = 32; i < 127; i++) {
        PrintCharacter(i, fp, fp_Small, fp_XSmall, rX, rY, page_Cur);
      }
      for (Int32 i = 161; i < 256; i++) {
        PrintCharacter(i, fp, fp_Small, fp_XSmall, rX, rY, page_Cur);
      }
      PrintCharacter('�', fp, fp_Small, fp_XSmall, rX, rY, page_Cur);
    }
    private void PrintCharacter(Int32 iChar, FontProp fp, FontProp fp_Small, FontProp fp_XSmall, Double rX, Double rY, Page page_Cur) {
      if (rX > 185) {
        rY += fp.rLineFeedMM;
        rX = 22;
      }
      if (rY > 280) {
        new Page(this);
        rY = 40;
      }
      Char ch = (Char)iChar;
      String s = ch.ToString();
      page_Cur.AddMM(rX + 2, rY, new RepString(fp, s));
      rX += 15;
    }
  }
}
using Root.Reports;
using System;
using System.Drawing;
namespace ReportSamples {
  public class Test : Report {
    private readonly FontDef fontDef;
    private readonly FontProp fontProp_Title;
    private readonly FontProp fontProp_Label;
    public Test() {
      fontDef = FontDef.FontDefFromName(this, FontDef.StandardFont.Helvetica);
      fontProp_Title = new FontPropMM(fontDef, 6) { Bold = true };
      fontProp_Label = new FontPropMM(fontDef, 4);
    }
    protected override void Create() {
      FontTest();
    }
    private void FontTest() {
      FontProp fp_Title = new FontPropMM(fontDef, 12) { Bold = true };
      FontProp fp = new FontPropMM(fontDef, 6);
      FontProp fp_Small = new FontPropMM(fontDef, 1.4);
      FontProp fp_XSmall = new FontPropMM(fontDef, 0.8);
      Page page_Cur = new Page(this);
      page_Cur.AddCB_MM(30, new RepString(fontProp_Title, "Font Test"));
      Double rX = 300;
      Double rY = 40;
      for (Int32 i = 32; i < 127; i++) {
        PrintCharacter(i, fp, fp_Small, fp_XSmall, rX, rY, page_Cur);
      }
      for (Int32 i = 161; i < 256; i++) {
        PrintCharacter(i, fp, fp_Small, fp_XSmall, rX, rY, page_Cur);
      }
      PrintCharacter('�', fp, fp_Small, fp_XSmall, rX, rY, page_Cur);
    }
    private void PrintCharacter(Int32 iChar, FontProp fp, FontProp fp_Small, FontProp fp_XSmall, Double rX, Double rY, Page page_Cur) {
      if (rX > 185) {
        rY += fp.rLineFeedMM;
        rX = 22;
      }
      if (rY > 280) {
        new Page(this);
        rY = 40;
      }
      Char ch = (Char)iChar;
      String s = ch.ToString();
      page_Cur.AddMM(rX + 2, rY, new RepString(fp, s));
      rX += 15;
    }
  }
}
Imports Root.Reports
Imports System
Imports System.Drawing
Namespace ReportSamples
  Public Class Test
	  Inherits Report

	Private ReadOnly fontDef As FontDef
	Private ReadOnly fontProp_Title As FontProp
	Private ReadOnly fontProp_Label As FontProp
	Public Sub New()
	  fontDef = FontDef.FontDefFromName(Me, FontDef.StandardFont.Helvetica)
	  fontProp_Title = New FontPropMM(fontDef, 6) With {.Bold = True}
	  fontProp_Label = New FontPropMM(fontDef, 4)
	End Sub
	Protected Overrides Sub Create()
	  FontTest()
	End Sub
	Private Sub FontTest()
	  Dim fp_Title As FontProp = New FontPropMM(fontDef, 12) With {.Bold = True}
	  Dim fp As FontProp = New FontPropMM(fontDef, 6)
	  Dim fp_Small As FontProp = New FontPropMM(fontDef, 1.4)
	  Dim fp_XSmall As FontProp = New FontPropMM(fontDef, 0.8)
	  Dim page_Cur As New Page(Me)
	  page_Cur.AddCB_MM(30, New RepString(fontProp_Title, "Font Test"))
	  Dim rX As Double = 300
	  Dim rY As Double = 40
	  For i As Int32 = 32 To 126
		PrintCharacter(i, fp, fp_Small, fp_XSmall, rX, rY, page_Cur)
	  Next i
	  For i As Int32 = 161 To 255
		PrintCharacter(i, fp, fp_Small, fp_XSmall, rX, rY, page_Cur)
	  Next i
	  PrintCharacter(AscW(" "c), fp, fp_Small, fp_XSmall, rX, rY, page_Cur)
	End Sub
	Private Sub PrintCharacter(ByVal iChar As Int32, ByVal fp As FontProp, ByVal fp_Small As FontProp, ByVal fp_XSmall As FontProp, ByVal rX As Double, ByVal rY As Double, ByVal page_Cur As Page)
	  If rX > 185 Then
		rY += fp.rLineFeedMM
		rX = 22
	  End If
	  If rY > 280 Then
		Dim tempVar As New Page(Me)
		rY = 40
	  End If
	  Dim ch As Char = ChrW(iChar)
	  Dim s As String = ch.ToString()
	  page_Cur.AddMM(rX + 2, rY, New RepString(fp, s))
	  rX += 15
	End Sub
  End Class
End Namespace
$vbLabelText   $csharpLabel

Una comparación entre Report .NET e IronPDF: Figura 12 - Agregar varios estilos y tamaños de fuente a un documento PDF usando Report.NET

6.2.2 Incrustación de imágenes

Con la función de muestra de imágenes, los desarrolladores pueden incrustar imágenes en documentos PDF. Esto incluye el control del tamaño y la posición de las imágenes, así como la posibilidad de aplicarles transformaciones o efectos.

using Root.Reports;
using System.Drawing;
namespace ReportSamples {
  public class ImageSample : Report {
    protected override void Create() {
      FontDef fd = new FontDef(this, FontDef.StandardFont.Helvetica);
      FontProp fp_Title = new FontPropMM(fd, 15) { Bold = true };
      FontProp fp_SubTitle = new FontPropMM(fd, 4) { Bold = true };
      PenProp pp = new PenProp(this, 0.2, Color.FromArgb(235, 235, 235));
      PenProp pp_Black = new PenProp(this, 0.2, Color.Black);
      BrushProp bp = new BrushProp(this, Color.LightGray);
      new Page(this);
      page_Cur.AddCB_MM(40, new RepString(fp_Title, "Image Sample"));
      System.IO.Stream stream = GetType().Assembly.GetManifestResourceStream("ReportSamples.Image.jpg");
      page_Cur.AddMM(20, 90, new RepImageMM(stream, 40, Double.NaN));
      page_Cur.AddMM(20, 95, new RepString(fp_SubTitle, "W = 40mm, H = auto."));
      page_Cur.AddMM(67, 90, new RepImageMM(stream, 40, 20));
      page_Cur.AddMM(67, 95, new RepString(fp_SubTitle, "W = 40mm, H = 20mm"));
      page_Cur.AddMM(114, 90, new RepImageMM(stream, Double.NaN, 30));
      page_Cur.AddMM(114, 95, new RepString(fp_SubTitle, "W = auto., H = 30mm"));
      page_Cur.AddMM(161, 90, new RepImageMM(stream, 30, 30));
      page_Cur.AddMM(161, 95, new RepString(fp_SubTitle, "W = 30mm, H = 30mm"));
    }
  }
}
using Root.Reports;
using System.Drawing;
namespace ReportSamples {
  public class ImageSample : Report {
    protected override void Create() {
      FontDef fd = new FontDef(this, FontDef.StandardFont.Helvetica);
      FontProp fp_Title = new FontPropMM(fd, 15) { Bold = true };
      FontProp fp_SubTitle = new FontPropMM(fd, 4) { Bold = true };
      PenProp pp = new PenProp(this, 0.2, Color.FromArgb(235, 235, 235));
      PenProp pp_Black = new PenProp(this, 0.2, Color.Black);
      BrushProp bp = new BrushProp(this, Color.LightGray);
      new Page(this);
      page_Cur.AddCB_MM(40, new RepString(fp_Title, "Image Sample"));
      System.IO.Stream stream = GetType().Assembly.GetManifestResourceStream("ReportSamples.Image.jpg");
      page_Cur.AddMM(20, 90, new RepImageMM(stream, 40, Double.NaN));
      page_Cur.AddMM(20, 95, new RepString(fp_SubTitle, "W = 40mm, H = auto."));
      page_Cur.AddMM(67, 90, new RepImageMM(stream, 40, 20));
      page_Cur.AddMM(67, 95, new RepString(fp_SubTitle, "W = 40mm, H = 20mm"));
      page_Cur.AddMM(114, 90, new RepImageMM(stream, Double.NaN, 30));
      page_Cur.AddMM(114, 95, new RepString(fp_SubTitle, "W = auto., H = 30mm"));
      page_Cur.AddMM(161, 90, new RepImageMM(stream, 30, 30));
      page_Cur.AddMM(161, 95, new RepString(fp_SubTitle, "W = 30mm, H = 30mm"));
    }
  }
}
Imports Root.Reports
Imports System.Drawing
Namespace ReportSamples
  Public Class ImageSample
	  Inherits Report

	Protected Overrides Sub Create()
	  Dim fd As New FontDef(Me, FontDef.StandardFont.Helvetica)
	  Dim fp_Title As FontProp = New FontPropMM(fd, 15) With {.Bold = True}
	  Dim fp_SubTitle As FontProp = New FontPropMM(fd, 4) With {.Bold = True}
	  Dim pp As New PenProp(Me, 0.2, Color.FromArgb(235, 235, 235))
	  Dim pp_Black As New PenProp(Me, 0.2, Color.Black)
	  Dim bp As New BrushProp(Me, Color.LightGray)
	  Dim tempVar As New Page(Me)
	  page_Cur.AddCB_MM(40, New RepString(fp_Title, "Image Sample"))
	  Dim stream As System.IO.Stream = Me.GetType().Assembly.GetManifestResourceStream("Image.jpg")
	  page_Cur.AddMM(20, 90, New RepImageMM(stream, 40, Double.NaN))
	  page_Cur.AddMM(20, 95, New RepString(fp_SubTitle, "W = 40mm, H = auto."))
	  page_Cur.AddMM(67, 90, New RepImageMM(stream, 40, 20))
	  page_Cur.AddMM(67, 95, New RepString(fp_SubTitle, "W = 40mm, H = 20mm"))
	  page_Cur.AddMM(114, 90, New RepImageMM(stream, Double.NaN, 30))
	  page_Cur.AddMM(114, 95, New RepString(fp_SubTitle, "W = auto., H = 30mm"))
	  page_Cur.AddMM(161, 90, New RepImageMM(stream, 30, 30))
	  page_Cur.AddMM(161, 95, New RepString(fp_SubTitle, "W = 30mm, H = 30mm"))
	End Sub
  End Class
End Namespace
$vbLabelText   $csharpLabel

Una Comparación entre Report .NET e IronPDF: Figura 13 - PDF de Salida: Insertar imágenes en documentos PDF usando Report.NET

6.2.3 Gestor de diseño de listas

El Administrador de diseño de listas permite añadir listas a un documento PDF. Resulta útil para crear listas ordenadas o desordenadas, personalizar la sangría de las listas, los estilos de las viñetas y gestionar el diseño general de los elementos de las listas dentro del documento.

using Root.Reports;
using System.Drawing;
namespace ReportSamples {
  public class ListLayoutManagerSample : Report {
    private Double rMarginLeft = 20;  // millimeters
    private Double rWidth = 175;  // millimeters
    protected override void Create() {
      FontDef fd = new FontDef(this, FontDef.StandardFont.Helvetica);
      FontProp fp = new FontPropMM(fd, 1.9);
      Double rY = 40;  // vertical position in millimeters
      new Page(this);
      FontProp fp_Title = new FontPropMM(fd, 8);
      page_Cur.AddCB_MM(rY, new RepString(fp_Title, "List Layout Manager Sample"));
      rY += 18;
      ListLayoutManager llm = null;
      using (llm = new ListLayoutManager(this)) {
        PenProp pp_BorderLine = new PenPropMM(this, 0.4, Color.Blue);
        PenProp pp_GridLine = new PenPropMM(this, 0.1, Color.Blue);
        // Configuration for columns
        TlmColumn col_Number = new TlmColumnMM(llm, 10);
        col_Number.tlmCellDef_Default.rAlignH = RepObj.rAlignCenter;
        col_Number.tlmCellDef_Default.rAlignV = RepObj.rAlignCenter;
        col_Number.tlmCellDef_Default.penProp_LineLeft = pp_BorderLine;
        TlmColumn col_Text = new TlmColumnMM(llm, 100);
        col_Text.tlmCellDef_Default.tlmTextMode = TlmTextMode.MultiLine;
        TlmColumn col_Author = new TlmColumnMM(llm, rWidth - llm.rWidthMM);
        col_Author.tlmCellDef_Default.penProp_LineRight = pp_BorderLine;
        col_Author.tlmCellDef_Default.brushProp_Back = new BrushProp(this, Color.FromArgb(255, 210, 210));
        llm.container_CreateMM(page_Cur, rMarginLeft, rY);  // immediately creates a container
        // Adding rows and content
        // ...
        // Rows and content omitted for brevity
        // ...
      }
      rY += llm.rCurY_MM + 1.5;
      fp.rSizeMM = 1.5;
      page_Cur.AddRT_MM(rMarginLeft + rWidth, rY, new RepString(fp, "End of list"));
    }
  }
}
using Root.Reports;
using System.Drawing;
namespace ReportSamples {
  public class ListLayoutManagerSample : Report {
    private Double rMarginLeft = 20;  // millimeters
    private Double rWidth = 175;  // millimeters
    protected override void Create() {
      FontDef fd = new FontDef(this, FontDef.StandardFont.Helvetica);
      FontProp fp = new FontPropMM(fd, 1.9);
      Double rY = 40;  // vertical position in millimeters
      new Page(this);
      FontProp fp_Title = new FontPropMM(fd, 8);
      page_Cur.AddCB_MM(rY, new RepString(fp_Title, "List Layout Manager Sample"));
      rY += 18;
      ListLayoutManager llm = null;
      using (llm = new ListLayoutManager(this)) {
        PenProp pp_BorderLine = new PenPropMM(this, 0.4, Color.Blue);
        PenProp pp_GridLine = new PenPropMM(this, 0.1, Color.Blue);
        // Configuration for columns
        TlmColumn col_Number = new TlmColumnMM(llm, 10);
        col_Number.tlmCellDef_Default.rAlignH = RepObj.rAlignCenter;
        col_Number.tlmCellDef_Default.rAlignV = RepObj.rAlignCenter;
        col_Number.tlmCellDef_Default.penProp_LineLeft = pp_BorderLine;
        TlmColumn col_Text = new TlmColumnMM(llm, 100);
        col_Text.tlmCellDef_Default.tlmTextMode = TlmTextMode.MultiLine;
        TlmColumn col_Author = new TlmColumnMM(llm, rWidth - llm.rWidthMM);
        col_Author.tlmCellDef_Default.penProp_LineRight = pp_BorderLine;
        col_Author.tlmCellDef_Default.brushProp_Back = new BrushProp(this, Color.FromArgb(255, 210, 210));
        llm.container_CreateMM(page_Cur, rMarginLeft, rY);  // immediately creates a container
        // Adding rows and content
        // ...
        // Rows and content omitted for brevity
        // ...
      }
      rY += llm.rCurY_MM + 1.5;
      fp.rSizeMM = 1.5;
      page_Cur.AddRT_MM(rMarginLeft + rWidth, rY, new RepString(fp, "End of list"));
    }
  }
}
Imports Root.Reports
Imports System.Drawing
Namespace ReportSamples
  Public Class ListLayoutManagerSample
	  Inherits Report

	Private rMarginLeft As Double = 20 ' millimeters
	Private rWidth As Double = 175 ' millimeters
	Protected Overrides Sub Create()
	  Dim fd As New FontDef(Me, FontDef.StandardFont.Helvetica)
	  Dim fp As FontProp = New FontPropMM(fd, 1.9)
	  Dim rY As Double = 40 ' vertical position in millimeters
	  Dim tempVar As New Page(Me)
	  Dim fp_Title As FontProp = New FontPropMM(fd, 8)
	  page_Cur.AddCB_MM(rY, New RepString(fp_Title, "List Layout Manager Sample"))
	  rY += 18
	  Dim llm As ListLayoutManager = Nothing
	  llm = New ListLayoutManager(Me)
	  Using llm
		Dim pp_BorderLine As PenProp = New PenPropMM(Me, 0.4, Color.Blue)
		Dim pp_GridLine As PenProp = New PenPropMM(Me, 0.1, Color.Blue)
		' Configuration for columns
		Dim col_Number As TlmColumn = New TlmColumnMM(llm, 10)
		col_Number.tlmCellDef_Default.rAlignH = RepObj.rAlignCenter
		col_Number.tlmCellDef_Default.rAlignV = RepObj.rAlignCenter
		col_Number.tlmCellDef_Default.penProp_LineLeft = pp_BorderLine
		Dim col_Text As TlmColumn = New TlmColumnMM(llm, 100)
		col_Text.tlmCellDef_Default.tlmTextMode = TlmTextMode.MultiLine
		Dim col_Author As TlmColumn = New TlmColumnMM(llm, rWidth - llm.rWidthMM)
		col_Author.tlmCellDef_Default.penProp_LineRight = pp_BorderLine
		col_Author.tlmCellDef_Default.brushProp_Back = New BrushProp(Me, Color.FromArgb(255, 210, 210))
		llm.container_CreateMM(page_Cur, rMarginLeft, rY) ' immediately creates a container
		' Adding rows and content
		' ...
		' Rows and content omitted for brevity
		' ...
	  End Using
	  rY += llm.rCurY_MM + 1.5
	  fp.rSizeMM = 1.5
	  page_Cur.AddRT_MM(rMarginLeft + rWidth, rY, New RepString(fp, "End of list"))
	End Sub
  End Class
End Namespace
$vbLabelText   $csharpLabel

Una comparación entre Report .NET e IronPDF: Figura 14 - PDF de salida: Añadir listas a documentos PDF usando Report.NET

6.2.4 Propiedades PDF

Esto se refiere a la capacidad de establecer y modificar varias propiedades del documento PDF en sí, como los metadatos (autor, título, tema), las preferencias de visualización y las configuraciones de seguridad como la encriptación y los permisos de acceso.

using Root.Reports;
using System;
namespace ReportSamples {
  public class PdfPropertiesSample : Report {
    public PdfPropertiesSample() {
      PdfFormatter pf = (PdfFormatter)formatter;
      pf.sTitle = "PDF Sample";
      pf.sAuthor = "Otto Mayer, mot@root.ch";
      pf.sSubject = "Sample of some PDF features";
      pf.sKeywords = "Sample PDF RSF";
      pf.sCreator = "RSF Sample Application";
      pf.dt_CreationDate = new DateTime(2002, 8, 15, 0, 0, 0, 0);
      pf.pageLayout = PageLayout.TwoColumnLeft;
      pf.bHideToolBar = true;
      pf.bHideMenubar = false;
      pf.bHideWindowUI = true;
      pf.bFitWindow = true;
      pf.bCenterWindow = true;
      pf.bDisplayDocTitle = true;
    }
    protected override void Create() {
      FontDef fd = new FontDef(this, FontDef.StandardFont.Helvetica);
      FontProp fp = new FontPropMM(fd, 4);
      FontProp fp_Title = new FontPropMM(fd, 11);
      fp_Title.bBold = true;
      Page page = new Page(this);
      page.AddCB_MM(40, new RepString(fp_Title, "PDF Properties Sample"));
      fp_Title.rSizeMM = 8;
      page.AddCB_MM(100, new RepString(fp_Title, "First Page"));
      page.AddCB_MM(120, new RepString(fp, "Choose <Document Properties, Summary> from the"));
      page.AddCB_MM(126, new RepString(fp, "File menu to display the document properties"));
      page = new Page(this);
      page.AddCB_MM(100, new RepString(fp_Title, "Second Page"));
    }
  }
}
using Root.Reports;
using System;
namespace ReportSamples {
  public class PdfPropertiesSample : Report {
    public PdfPropertiesSample() {
      PdfFormatter pf = (PdfFormatter)formatter;
      pf.sTitle = "PDF Sample";
      pf.sAuthor = "Otto Mayer, mot@root.ch";
      pf.sSubject = "Sample of some PDF features";
      pf.sKeywords = "Sample PDF RSF";
      pf.sCreator = "RSF Sample Application";
      pf.dt_CreationDate = new DateTime(2002, 8, 15, 0, 0, 0, 0);
      pf.pageLayout = PageLayout.TwoColumnLeft;
      pf.bHideToolBar = true;
      pf.bHideMenubar = false;
      pf.bHideWindowUI = true;
      pf.bFitWindow = true;
      pf.bCenterWindow = true;
      pf.bDisplayDocTitle = true;
    }
    protected override void Create() {
      FontDef fd = new FontDef(this, FontDef.StandardFont.Helvetica);
      FontProp fp = new FontPropMM(fd, 4);
      FontProp fp_Title = new FontPropMM(fd, 11);
      fp_Title.bBold = true;
      Page page = new Page(this);
      page.AddCB_MM(40, new RepString(fp_Title, "PDF Properties Sample"));
      fp_Title.rSizeMM = 8;
      page.AddCB_MM(100, new RepString(fp_Title, "First Page"));
      page.AddCB_MM(120, new RepString(fp, "Choose <Document Properties, Summary> from the"));
      page.AddCB_MM(126, new RepString(fp, "File menu to display the document properties"));
      page = new Page(this);
      page.AddCB_MM(100, new RepString(fp_Title, "Second Page"));
    }
  }
}
Imports Root.Reports
Imports System
Namespace ReportSamples
  Public Class PdfPropertiesSample
	  Inherits Report

	Public Sub New()
	  Dim pf As PdfFormatter = CType(formatter, PdfFormatter)
	  pf.sTitle = "PDF Sample"
	  pf.sAuthor = "Otto Mayer, mot@root.ch"
	  pf.sSubject = "Sample of some PDF features"
	  pf.sKeywords = "Sample PDF RSF"
	  pf.sCreator = "RSF Sample Application"
	  pf.dt_CreationDate = New DateTime(2002, 8, 15, 0, 0, 0, 0)
	  pf.pageLayout = PageLayout.TwoColumnLeft
	  pf.bHideToolBar = True
	  pf.bHideMenubar = False
	  pf.bHideWindowUI = True
	  pf.bFitWindow = True
	  pf.bCenterWindow = True
	  pf.bDisplayDocTitle = True
	End Sub
	Protected Overrides Sub Create()
	  Dim fd As New FontDef(Me, FontDef.StandardFont.Helvetica)
	  Dim fp As FontProp = New FontPropMM(fd, 4)
	  Dim fp_Title As FontProp = New FontPropMM(fd, 11)
	  fp_Title.bBold = True
	  Dim page As New Page(Me)
	  page.AddCB_MM(40, New RepString(fp_Title, "PDF Properties Sample"))
	  fp_Title.rSizeMM = 8
	  page.AddCB_MM(100, New RepString(fp_Title, "First Page"))
	  page.AddCB_MM(120, New RepString(fp, "Choose <Document Properties, Summary> from the"))
	  page.AddCB_MM(126, New RepString(fp, "File menu to display the document properties"))
	  page = New Page(Me)
	  page.AddCB_MM(100, New RepString(fp_Title, "Second Page"))
	End Sub
  End Class
End Namespace
$vbLabelText   $csharpLabel

6.2.5 PDF a partir de texto

La función PDF a partir de texto muestra las capacidades de la biblioteca para añadir y personalizar contenido de texto en un PDF. Esto incluye ajustar la alineación del texto, el interlineado, el color y aplicar efectos de texto como negrita o cursiva.

7. Documentación y apoyo

7.1 IronPDF

IronPDF es conocido por su extensa y detallada documentación. IronPDF ofrece una sección de documentación bien organizada que incluye instrucciones de configuración, tutoriales y referencias a la API. Las guías están estructuradas para ayudar tanto a principiantes como a desarrolladores experimentados a encontrar rápidamente la información que necesitan. Para obtener ayuda de la comunidad, los desarrolladores pueden recurrir a foros y debates comunitarios. Aquí pueden hacer preguntas, compartir experiencias y encontrar respuestas de otros usuarios.

IronPDF también ofrece asistencia profesional a través de un sistema de tickets en el que los ingenieros pueden obtener ayuda directamente del equipo de IronPDF. Este servicio puede formar parte de la licencia de pago, que ofrece una asistencia más directa e inmediata.

7.2 Informe.NET

Report.NET, al ser una biblioteca de código abierto, tiene un enfoque diferente para la documentación y el soporte. Puede que la documentación no sea tan extensa como la de las bibliotecas comerciales, pero es suficiente para empezar y realizar tareas comunes. La documentación de la biblioteca se encuentra en el repositorio de GitHub o como comentarios en línea en el código fuente. Suele ser más técnico y puede requerir indagar un poco para encontrar la información necesaria.

Dado que Report.NET es una biblioteca gratuita y de código abierto, no ofrece asistencia profesional formal. Los desarrolladores cuentan con la ayuda de la comunidad o pueden necesitar contratar a un especialista para cuestiones más profundas.

8. Modelos de licencia

Una comparación entre Report .NET e IronPDF: Figura 15 - Información de la licencia de IronPDF for .NET

8.1 Modelo de licencia de IronPDF

IronPDF ofrece una variedad de modelos de licencia para adaptarse a diferentes necesidades de desarrollo y despliegue, asegurando que haya una opción adecuada para proyectos y organizaciones de todos los tamaños. He aquí un resumen:

  1. Lite License ($749 USD): Esta es la opción más básica, adecuada para desarrolladores individuales que trabajan en un solo proyecto en un solo lugar. Incluye asistencia por correo electrónico, pero no cubre la redistribución libre de derechos.

  2. Plus License ($1,499 USD): Dirigida a pequeños equipos, esta licencia admite hasta tres desarrolladores trabajando en tres proyectos en tres ubicaciones. Mejora la asistencia para incluir correo electrónico y chat las 24 horas del día, así como asistencia telefónica.

  3. Professional License ($2,999 USD): Este está diseñado para equipos y proyectos más grandes, y permite hasta 10 desarrolladores en 10 ubicaciones trabajando en 10 proyectos. Incluye todas las opciones de asistencia Plus y añade la posibilidad de compartir la pantalla para una resolución de problemas más interactiva.

  4. Licencia de prueba gratuita: Ideal para fines de evaluación, esta licencia de prueba te permite probar IronPDF sin costo. Sin embargo, está destinada a uso privado y los PDFs generados no deben publicarse en ningún proyecto público o corporativo de internet o intranet.

    Además de las licencias básicas, existen opciones de cobertura ampliada:

    • Redistribución sin Regalías: Si necesitas incluir IronPDF en un producto de software que vas a distribuir o vender, se requiere cobertura de redistribución sin regalías. Su precio es de 1.499 dólares para SaaS y redistribución OEM.
    • Soporte y Actualizaciones Extendidas: Este complemento garantiza que recibas actualizaciones continuas del producto y soporte. Puede elegir entre paquetes de asistencia de 1 o 5 años, y este último ofrece un ahorro con respecto a la opción anual.

8.2 Modelo de licencia de Report.NET

Report.NET se distribuye gratuitamente bajo licencia LGPL. La LGPL (Lesser General Public License) es una licencia de software libre que permite a los usuarios ejecutar, estudiar, compartir y modificar el software. La licencia garantiza que la biblioteca Report.NET pueda utilizarse libremente tanto en software de código abierto como propietario, siempre que no se modifiquen las partes del código bajo licencia LGPL. Si se modifican, esas modificaciones deben compartirse bajo la misma licencia.

9. Conclusión

Al observar IronPDF y Report.NET, hemos examinado varios elementos como sus capacidades, la gama de características que ofrecen, la facilidad de uso, los servicios de soporte y cómo están licenciados.

IronPDF proporciona un conjunto completo de características que permiten a los desarrolladores no solo crear y editar archivos PDF a partir de HTML, imágenes y texto, sino también implementar características avanzadas como cifrado, firmas digitales y encabezados/pies de página personalizados. La compatibilidad con distintas licencias significa que puede adaptarse a proyectos de distintos tamaños, desde desarrolladores en solitario hasta grandes empresas. Su completa documentación y su estructura de asistencia profesional lo hacen idóneo para proyectos en los que son importantes las actualizaciones constantes y la asistencia directa. IronPDF también ofrece una prueba gratuita de IronPDF que comienza desde $749.

Report.NET, en cambio, es una herramienta sencilla capaz de generar documentos PDF. Su licencia LGPL significa que es bastante accesible para que los desarrolladores lo utilicen tanto en proyectos personales como comerciales sin restricciones significativas. Aunque puede que no ofrezca el mismo nivel de soporte estructurado que IronPDF, la naturaleza de código abierto de Report.NET fomenta las aportaciones y la ayuda de la comunidad.

Su decisión entre IronPDF y Report.NET dependerá de las demandas específicas de su proyecto. Si su proyecto requiere la creación y manipulación detallada de PDF con el respaldo de un servicio de asistencia profesional, IronPDF podría ser la elección acertada.

Chipego
Ingeniero de software
Chipego tiene una habilidad natural para escuchar que le ayuda a comprender los problemas de los clientes y a ofrecer soluciones inteligentes. Se unió al equipo de Iron Software en 2023, después de estudiar una licenciatura en Tecnología de la Información. IronPDF e IronOCR son los dos productos en los que Chipego se ha centrado, pero su conocimiento de todos los productos crece día a día, a medida que encuentra nuevas formas de ayudar a los clientes. Disfruta de lo colaborativa que es la vida en Iron Software, con miembros del equipo de toda la empresa que aportan su variada experiencia para contribuir a soluciones eficaces e innovadoras. Cuando Chipego está lejos de su escritorio, a menudo se le puede encontrar disfrutando de un buen libro o jugando al fútbol.
< ANTERIOR
Comparación entre Compdfkit y IronPDF
SIGUIENTE >
Herramientas de elaboración de informes en C# (comparación de funciones)