COMPARACIóN DE PRODUCTOS

Comparación entre Report .NET e IronPDF

Actualizado 29 de abril, 2024

En este artículo, vamos a echar un vistazo de cerca a dos populares bibliotecas de C# utilizadas para trabajar con archivos PDF: IronPDF y Informe.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. Vamos a desglosar las capacidades y diferencias entre IronPDF y Report.NET, centrándonos en la simplicidad y las ideas prácticas para los desarrolladores.

1. Report.NET C# Biblioteca

Informe.NET es una robusta biblioteca 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 representación de documentos PDF en 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

Uno de los principales puntos fuertes 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 añadir o eliminar páginas, modificar texto y imágenes incrustadas. 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 que permite a los usuarios interactuar con los documentos de forma 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, la aplicación de medidas de seguridad como el cifrado y la protección por 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 PDF tanto para su visualización en pantalla como para impresión física garantizando una producción 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 está respaldado por documentación detallada y un soporte dedicado, que ayuda a los desarrolladores a navegar por las características de la biblioteca e integrar sus funcionalidades en sus aplicaciones de forma eficiente.

2.1.8 Edición avanzada de PDF

IronPDF ofrece muchas funciones avanzadas de edición. Esto incluye la capacidad de fusionar y dividir PDF, que resulta especialmente útil para organizar grandes volúmenes de información o extraer secciones específicas de un documento para utilizarlas por separado.

2.1.9 Encabezados y pies de página personalizados

La biblioteca permite personalización de las cabeceras y pies de página en 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 tiene instalado, tendrá que descargarlo e instalarlo desde la página 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.

Comparación entre Report .NET e IronPDF: Figura 1 - Abra Visual Studio y haga clic en "Crear un nuevo proyecto" opción.

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

Comparación entre Report .NET e IronPDF: Figura 2 - A continuación, elija el tipo de proyecto "Console App" en 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 en qué lugar de tu ordenador quieres guardar los archivos del proyecto.
Nombre de la solución: Por defecto, este es el mismo que el nombre de su proyecto, pero puede cambiarlo si está planeando incluir varios proyectos en la misma solución.
- Framework: Seleccione la versión de .NET Framework a la que desea dirigirse. 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.

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...".
Haga clic en la pestaña "Examinar" y escriba "IronPDF" en el cuadro de búsqueda.
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.

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.

Abra la consola: Vaya al menú "Herramientas" de Visual Studio y, a continuación, vaya a "Gestor de paquetes NuGet" > "Consola del gestor de paquetes".
1. Comando de instalación: En la consola, escriba el siguiente comando y pulse Intro:

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.

Visite el sitio web de NuGet: Ir a nuget.org y busque "IronPDF".
Descargue el paquete: Desde la página Página de IronPDF selecciona la versión que necesitas y descarga el archivo .nupkg.
Instalación manual: Una vez descargado, puede añadir el paquete a su proyecto manualmente. En Visual Studio, vaya al menú "Herramientas", luego a "Opciones" > "Gestor de paquetes NuGet" > "Fuentes de paquetes". Añade una nueva fuente que apunte a la carpeta donde descargaste el archivo .nupkg. Por último, utiliza la interfaz de usuario del gestor de paquetes o la consola de Visual Studio para instalar el paquete desde la 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 del Informe.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:

Abra su proyecto: Inicie Visual Studio y abra el proyecto al que desea añadir Report.NET.
1. Añadir la librería manualmente: Hay un par de formas de incluir la librería en tu proyecto:
  - Como un ensamblado compilado: Si el repositorio de GitHub incluye un archivo DLL compilado, puedes simplemente añadir 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 los archivos fuente: Si prefiere incluir el código fuente directamente o si no se proporciona una DLL compilada, puede añadir los archivos de código fuente a su 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.
Asegúrese de la compatibilidad: Asegúrese de que su proyecto tiene como objetivo una versión de .NET Framework compatible, tal y como requiere 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 una amplia gama de tareas relacionadas con PDF con facilidad.

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

VB C#

6.1.1.2 Archivo HTML a PDF

Del mismo modo, IronPDF puede convertir Archivos HTML 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")

VB C#

Comparación entre Report .NET e IronPDF: Figura 6 - Salida de archivo HTML a PDF utilizando IronPDF

6.1.1.3 URL a PDF

IronPDF también es capaz de renderizar un PDF desde una URL activa. 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")

VB C#

Comparación entre Report .NET e IronPDF: Figura 7 - Conversión de URL a PDF con IronPDF

6.1.2 Edición de PDF

Con IronPDF, puede editar documentos PDF existentes. Esto incluye añadir texto, imágenes y páginas o eliminar páginas del documento. También puede 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")

VB C#

Comparación entre Report .NET e IronPDF: Figura 8 - Salida: Edición de un PDF existente con 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 puede utilizar para indexar, buscar o reutilizar contenidos.

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

VB C#

Comparación entre Report .NET e IronPDF: Figura 9 - Salida PDF: Generación de formularios PDF con IronPDF

6.1.5 Fusionar documentos PDF

Puede combinar varios archivos PDF en un único 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")

VB C#

Comparación entre Report .NET e IronPDF: Figura 10 - PDF de salida: Generación de varios archivos PDF y fusión de los mismos en un solo PDF.

6.1.6 Dividir documentos PDF

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

6.1.7 Cifrar y descifrar PDFs

IronPDF permite cifrado y descifrado de documentos PDF añadiendo una capa adicional 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")

VB C#

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

VB C#

6.1.9 Conformidad PDF/A

IronPDF puede generar PDF/A compatibles documentos necesarios para archivar y conservar registros a largo plazo.

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 consigue empleando XSLT (Transformaciones del Lenguaje Extensible de Hojas de Estilo)un potente lenguaje de hojas 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 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>

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'<?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>

VB C#

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

'INSTANT VB TODO TASK: The following line could not be converted:
<?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="/"> (Of html) (Of head) (Of title) Library Catalog</title> (Of style) body
If True Then
	font-family: Arial, sans-serif
	margin:
	20px
End If
					table
					If True Then
						border-collapse: collapse
						width:
						100 Mod 
					End If
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'					th, td
'					{
'						text-align: left;
'						padding:
'						8px;
'					}
					tr:
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'					nth-child(even)
'					{
'						background-color: #f2f2f2;
'					}
					th
					If True Then
						background-color: #4CAF50
						color:
						white
					End If
'INSTANT VB TODO TASK: The following line uses invalid syntax:
'				</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>

VB C#

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

VB C#

Se empieza con una hoja de estilo XSLT (style.xslt) que dicta cómo deben estructurarse los datos XML como HTML. La clase XslCompiledTransform en .NET se utiliza para cargar su archivo XSLT.
Utiliza XmlReader para cargar tus datos XML (data.xml). XmlReader es eficiente para este propósito porque proporciona una vista de sólo lectura de los datos XML.
El HTML transformado se escribe en un archivo (output.html) utilizando XmlWriter, configurado para producir HTML sangrado para facilitar la lectura y omitir la declaración XML, que no es necesaria en la salida HTML.
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.
Por último, el documento PDF se guarda en el sistema de archivos (**Informe.pdf). Este paso concluye el proceso de conversión, dando como resultado un documento PDF derivado de los datos XML originales.
Así es como generamos informes utilizando XML e IronPDF. El archivo PDF de salida que generamos:
También podemos crear informes interactivos de SAP mediante programación y convertirlos después con IronPDF. Para más detalles, siga esta guía sobre Generación de informes en C#.

6.2 Funciones avanzadas de Report.NET

Informe.NET ofrece un conjunto de funciones avanzadas que permiten generar y personalizar PDF de forma exhaustiva. 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

VB C#

Comparación entre Report .NET e IronPDF: Figura 12 - Adición de varios estilos y tamaños de fuente a un documento PDF mediante 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

VB C#

Comparación entre Report .NET e IronPDF: Figura 13 - PDF de salida: Incrustación de imágenes en documentos PDF con 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;  //  milímetros
    private Double rWidth = 175;  //  milímetros
    protected override void Create() {
      FontDef fd = new FontDef(this, FontDef.StandardFont.Helvetica);
      FontProp fp = new FontPropMM(fd, 1.9);
      Double rY = 40;  //  posición vertical en milímetros
      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);
        //  Configuración de las columnas
        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);  //  crea inmediatamente un contenedor
        //  Añadir filas y contenido
        //  ...
        //  Filas y contenido omitidos en aras de la brevedad
        //  ...
      }
      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;  //  milímetros
    private Double rWidth = 175;  //  milímetros
    protected override void Create() {
      FontDef fd = new FontDef(this, FontDef.StandardFont.Helvetica);
      FontProp fp = new FontPropMM(fd, 1.9);
      Double rY = 40;  //  posición vertical en milímetros
      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);
        //  Configuración de las columnas
        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);  //  crea inmediatamente un contenedor
        //  Añadir filas y contenido
        //  ...
        //  Filas y contenido omitidos en aras de la brevedad
        //  ...
      }
      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 '  milímetros
	Private rWidth As Double = 175 '  milímetros
	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 '  posición vertical en milímetros
	  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)
		'  Configuración de las columnas
		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) '  crea inmediatamente un contenedor
		'  Añadir filas y contenido
		'  ...
		'  Filas y contenido omitidos en aras de la brevedad
		'  ...
	  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

VB C#

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

6.2.4 Propiedades PDF

Se refiere a la capacidad de establecer y modificar diversas propiedades del propio documento PDF, como los metadatos (autor, título, tema)Las preferencias de visualización y los ajustes de seguridad, como el cifrado 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

VB C#

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 conocida por su amplia y documentación detallada. 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

Informe.NET al ser una biblioteca de código abierto, tiene un enfoque diferente en cuanto a documentación y 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

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

8.1 Modelo de licencia de IronPDF

IronPDF ofrece una variedad de modelos de licencia para adaptarse a las distintas necesidades de desarrollo e implantación, garantizando que se adapte a proyectos y organizaciones de todos los tamaños. He aquí un resumen:

Licencia Lite (749 USD): Esta es la opción más básica, adecuada para desarrolladores individuales que trabajan en un solo proyecto en una ubicación. Incluye asistencia por correo electrónico, pero no cubre la redistribución libre de derechos.
Licencia Plus ($1,499 USD): Dirigida a equipos pequeños, esta licencia admite hasta tres desarrolladores que trabajan 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.
Licencia profesional ($2,999 USD): Esto está diseñado para equipos y proyectos más grandes, con capacidad para hasta 10 desarrolladores a través de 10 ubicaciones que trabajan 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.
Licencia de prueba gratuita: Ideal para fines de evaluación, este test license le permite probar IronPDF sin coste alguno. Sin embargo, está pensado para uso privado y los PDF 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 libre de derechos: Si necesita incluir IronPDF en un producto de software que vaya a distribuir o vender, se requiere una cobertura de redistribución libre de derechos. Su precio es de 1.499 dólares para SaaS y redistribución OEM.
Asistencia ampliada y actualizaciones: Este complemento le garantiza actualizaciones continuas del producto y asistencia. 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 (Licencia Pública General Reducida) 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 mirar IronPDF y Informe.NET hemos examinado varios elementos, como sus capacidades, la gama de funciones que ofrecen, la facilidad de uso, los servicios de asistencia y la forma en que se conceden las licencias.

IronPDF ofrece un amplio conjunto de funciones que permiten a los desarrolladores no sólo crear y editar archivos PDF a partir de HTML, imágenes y texto, sino también implementar funciones 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 un prueba gratuita de IronPDF parte de 749 dólares.

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

SIGUIENTE >
Herramientas de elaboración de informes en C# (comparación de funciones)