USO DE IRONPDF

Cómo crear un informe en ASP .NET

Actualizado 3 de abril, 2024
Compartir:

Los informes son esenciales para presentar los datos en un formato estructurado y visualmente atractivo. Ya se trate de datos de ventas, análisis o resúmenes financieros, la generación de informes es un requisito habitual en las aplicaciones web. Microsoft proporciona servicios de informes rdlc que pueden integrarse en aplicaciones web mediante el control Visor de informes de formularios web. Sin embargo, el proceso puede ser a menudo complejo y lento.

Aquí es donde entra IronPDF. IronPDF es una biblioteca versátil que simplifica la generación de informes PDF en ASP.NET y otros marcos web, ofreciendo potentes funciones y facilidad de uso. En este artículo, exploraremos cómo crear un informe en ASP.NET utilizando IronPDF.

Cómo crear un informe en ASP.NET

  1. Crear una aplicación web ASP.NET con Visual Studio
  2. Instale IronPDF y IronPDF.Extensions.MVC.Core.
  3. Instanciar objeto ChromePdfRenderer emisor
  4. Llama al método RenderRazorViewToPdf para convertir la vista a PDF
  5. Añada "Content-Disposition" utilizando Response.Headers.Append.
  6. Crear un Informe utilizando el método File con PDF.BinaryData.

Introducción a IronPDF

IronPDF es una biblioteca versátil que simplifica la generación de documentos PDF en ASP.NET y otros marcos web. Su rico conjunto de funciones y sus intuitivas API lo convierten en la opción ideal para los desarrolladores que buscan generar informes dinámicos, facturas, recibos y mucho más directamente desde sus aplicaciones web. Con IronPDF, los desarrolladores pueden convertir sin esfuerzo HTML, CSS e incluso vistas Razor en documentos PDF de alta calidad, lo que permite una integración perfecta de la funcionalidad de generación de informes en sus proyectos ASP.NET.

Características de IronPDF

  • Conversión de HTML a PDF: Convierta fácilmente contenidos HTML, incluidos estilos CSS, en documentos PDF de alta calidad.
  • Edición de PDF: Modifique documentos PDF existentes añadiendo o eliminando texto, imágenes y anotaciones.
  • Rellenado de formularios PDF: Rellene formularios PDF dinámicamente con datos de su aplicación web.
  • Generación de códigos de barras: Genere códigos de barras y códigos QR dentro de documentos PDF para etiquetas de productos o seguimiento de inventario.
  • Marcas de agua: Añada marcas de agua a las páginas PDF para proteger información confidencial o documentos de marca.
  • Cifrado y seguridad: Proteja los documentos PDF con cifrado, contraseñas y configuración de permisos.

Requisitos previos

Antes de empezar, asegúrese de que dispone de los siguientes requisitos previos:

  • Conocimientos básicos de desarrollo ASP.NET.
  • Visual Studio está instalado en su máquina.
  • IronPDF y IronPDF.Extensions.Mvc.Core

Pasos para crear un proyecto ASP.NET en Visual Studio

  1. Abra Visual Studio y cree un nuevo proyecto ASP.NET Core.
  2. Elija la plantilla de proyecto deseada (por ejemplo, MVC o Razor Pages).

    Cómo crear un informe en ASP .NET: Figura 1

  3. Configure los ajustes del proyecto, como el nombre, la ubicación y la versión del framework.

    Cómo crear un informe en ASP .NET: Figura 2

  4. Haga clic en "Crear" para generar la estructura del proyecto.

Instalación de IronPDF y IronPDF.Extensions.Mvc.Core

A continuación, vamos a instalar IronPDF y su paquete de extensión MVC utilizando el gestor de paquetes NuGet:

  1. Abra el Gestor de paquetes NuGet para soluciones haciendo clic con el botón derecho del ratón en el Explorador de soluciones.
  2. Busque "IronPDF" y "IronPDF.Extensions.Mvc.Core".

    Cómo crear un informe en ASP .NET: Figura 3

  3. Instale ambos paquetes en su solución.

Pasos para crear un visor de informes en una aplicación web ASP.NET

Ahora, vamos a sumergirnos en los pasos para crear un informe PDF utilizando IronPDF en nuestro proyecto ASP.NET. Antes de convertir una vista en un informe, necesitamos un Modelo, una Vista y un Controlador para crear una fuente de datos para crear y descargar un nuevo informe en formato PDF.

Paso 1: Definir una clase modelo

En primer lugar, cree una clase modelo (SalesModel.cs) para representar los datos de ventas. Esta clase SalesModel de ejemplo incluirá propiedades como Date, ProductName, Quantity, UnitPrice y TotalAmount. Esto es útil cuando se recupera información de una fuente de datos como Microsoft SQL Server o MySQL Server.

namespace ReportGenerator.Models
{
    public class SalesModel
    {
        public DateTime Date { get; set; }
        public string ProductName { get; set; }
        public int Quantity { get; set; }
        public decimal UnitPrice { get; set; }
        public decimal TotalAmount => Quantity * UnitPrice;
    }
}
namespace ReportGenerator.Models
{
    public class SalesModel
    {
        public DateTime Date { get; set; }
        public string ProductName { get; set; }
        public int Quantity { get; set; }
        public decimal UnitPrice { get; set; }
        public decimal TotalAmount => Quantity * UnitPrice;
    }
}
Namespace ReportGenerator.Models
	Public Class SalesModel
		Public Property [Date]() As DateTime
		Public Property ProductName() As String
		Public Property Quantity() As Integer
		Public Property UnitPrice() As Decimal
		Public ReadOnly Property TotalAmount() As Decimal
			Get
				Return Quantity * UnitPrice
			End Get
		End Property
	End Class
End Namespace
VB   C#

Paso 2: Crear una nueva vista de formulario web

A continuación, cree una vista Razor (Ventas.cshtml) para mostrar los datos de ventas en formato tabular y proporcionar un botón para generar el informe en PDF.

<!-- Index.cshtml -->
@model List<SalesModel>
<!DOCTYPE html>
<html>
<head>
    <title>Sales Report</title>
    <style>
        table {
            border-collapse: collapse;
            width: 100%;
        }
        th, td {
            border: 1px solid #dddddd;
            text-align: left;
            padding: 8px;
        }
        th {
            background-color: #f2f2f2;
        }
    </style>
</head>
<body>
    <h2>Sales Report</h2>
    <table>
        <tr>
            <th>Date</th>
            <th>Product Name</th>
            <th>Quantity</th>
            <th>Unit Price</th>
            <th>Total Amount</th>
        </tr>
        @foreach (var item in Model)
        {
            <tr>
                <td>@item.Date.ToShortDateString()</td>
                <td>@item.ProductName</td>
                <td>@item.Quantity</td>
                <td>@item.UnitPrice.ToString("C")</td>
                <td>@item.TotalAmount.ToString("C")</td>
            </tr>
        }
    </table>
    <br />
    @using (Html.BeginForm("GeneratePdf", "Sales", FormMethod.Post))
    {
        <button type="submit">Generate PDF Report</button>
    }
</body>
</html>
<!-- Index.cshtml -->
@model List<SalesModel>
<!DOCTYPE html>
<html>
<head>
    <title>Sales Report</title>
    <style>
        table {
            border-collapse: collapse;
            width: 100%;
        }
        th, td {
            border: 1px solid #dddddd;
            text-align: left;
            padding: 8px;
        }
        th {
            background-color: #f2f2f2;
        }
    </style>
</head>
<body>
    <h2>Sales Report</h2>
    <table>
        <tr>
            <th>Date</th>
            <th>Product Name</th>
            <th>Quantity</th>
            <th>Unit Price</th>
            <th>Total Amount</th>
        </tr>
        @foreach (var item in Model)
        {
            <tr>
                <td>@item.Date.ToShortDateString()</td>
                <td>@item.ProductName</td>
                <td>@item.Quantity</td>
                <td>@item.UnitPrice.ToString("C")</td>
                <td>@item.TotalAmount.ToString("C")</td>
            </tr>
        }
    </table>
    <br />
    @using (Html.BeginForm("GeneratePdf", "Sales", FormMethod.Post))
    {
        <button type="submit">Generate PDF Report</button>
    }
</body>
</html>
HTML

Ahora, añada Ventas como un elemento de menú en el archivo _Layout.cshtml que se encuentra en la carpeta Vistas->Compartidas para crear una vista del asistente de informes:

<li class="nav-item">
    <a class="nav-link text-dark" asp-area="" asp-controller="Sales" asp-action="Sales">Sales</a>
</li>
<li class="nav-item">
    <a class="nav-link text-dark" asp-area="" asp-controller="Sales" asp-action="Sales">Sales</a>
</li>
'INSTANT VB TODO TASK: The following line uses invalid syntax:
'<li class="nav-item"> <a class="nav-link text-dark" asp-area="" asp-controller="Sales" asp-action="Sales"> Sales</a> </li>
VB   C#

Cómo crear un informe en ASP .NET: Figura 4

Paso 3: Registro del servicio View Render

Incluir el registro del servicio de renderizado de vistas en el archivo Program.cs es crucial para que la inyección de dependencias funcione correctamente. Añade el siguiente código al archivo Program.cs para registrar el servicio IRazorViewRenderer:

//  Registrar el servicio IRazorViewRenderer
builder.Services.AddSingleton<IRazorViewRenderer, RazorViewRenderer>();
//  Registrar el servicio IRazorViewRenderer
builder.Services.AddSingleton<IRazorViewRenderer, RazorViewRenderer>();
'  Registrar el servicio IRazorViewRenderer
builder.Services.AddSingleton(Of IRazorViewRenderer, RazorViewRenderer)()
VB   C#

Paso 3: Implementar la Clase Controladora de la API Web

Implementar un controlador (SalesController.cs) con acciones para representar la vista de ventas y generar el informe PDF. Inyecte el servicio IRazorViewRenderer proporcionado por IronPDF en el constructor del controlador.

using ReportGenerator.Models;
namespace ReportGenerator.Controllers
{
    public class SalesController : Controller
    {
        private readonly IRazorViewRenderer _viewRenderService;
        private readonly List<SalesModel> salesData;
        public SalesController(IRazorViewRenderer viewRenderService)
        {
            _viewRenderService = viewRenderService;
            //  Ejemplo de datos con información sobre ventas
            salesData = new List<SalesModel>
            {
                new SalesModel { Date = DateTime.Parse("2024-03-01"), ProductName = "Product A", Quantity = 10, UnitPrice = 50.00m },
                new SalesModel { Date = DateTime.Parse("2024-03-02"), ProductName = "Product B", Quantity = 15, UnitPrice = 40.00m },
                new SalesModel { Date = DateTime.Parse("2024-03-03"), ProductName = "Product C", Quantity = 20, UnitPrice = 30.00m }
                //  Añadir más datos según sea necesario
            };
        }
        public IActionResult Sales()
        {
        //  Representa los datos en la vista Ventas
            return View(salesData);
        }
    }
}
using ReportGenerator.Models;
namespace ReportGenerator.Controllers
{
    public class SalesController : Controller
    {
        private readonly IRazorViewRenderer _viewRenderService;
        private readonly List<SalesModel> salesData;
        public SalesController(IRazorViewRenderer viewRenderService)
        {
            _viewRenderService = viewRenderService;
            //  Ejemplo de datos con información sobre ventas
            salesData = new List<SalesModel>
            {
                new SalesModel { Date = DateTime.Parse("2024-03-01"), ProductName = "Product A", Quantity = 10, UnitPrice = 50.00m },
                new SalesModel { Date = DateTime.Parse("2024-03-02"), ProductName = "Product B", Quantity = 15, UnitPrice = 40.00m },
                new SalesModel { Date = DateTime.Parse("2024-03-03"), ProductName = "Product C", Quantity = 20, UnitPrice = 30.00m }
                //  Añadir más datos según sea necesario
            };
        }
        public IActionResult Sales()
        {
        //  Representa los datos en la vista Ventas
            return View(salesData);
        }
    }
}
Imports ReportGenerator.Models
Namespace ReportGenerator.Controllers
	Public Class SalesController
		Inherits Controller

		Private ReadOnly _viewRenderService As IRazorViewRenderer
		Private ReadOnly salesData As List(Of SalesModel)
		Public Sub New(ByVal viewRenderService As IRazorViewRenderer)
			_viewRenderService = viewRenderService
			'  Ejemplo de datos con información sobre ventas
			salesData = New List(Of SalesModel) From {
				New SalesModel With {
					.Date = DateTime.Parse("2024-03-01"),
					.ProductName = "Product A",
					.Quantity = 10,
					.UnitPrice = 50.00D
				},
				New SalesModel With {
					.Date = DateTime.Parse("2024-03-02"),
					.ProductName = "Product B",
					.Quantity = 15,
					.UnitPrice = 40.00D
				},
				New SalesModel With {
					.Date = DateTime.Parse("2024-03-03"),
					.ProductName = "Product C",
					.Quantity = 20,
					.UnitPrice = 30.00D
				}
			}
		End Sub
		Public Function Sales() As IActionResult
		'  Representa los datos en la vista Ventas
			Return View(salesData)
		End Function
	End Class
End Namespace
VB   C#

En el código anterior, dentro del constructor, el servicio IRazorViewRenderer se asigna al campo privado _viewRenderService. Adicionalmente, el controlador inicializa una lista llamada salesData que contiene instancias de la clase SalesModel, representando información de ventas para propósitos de demostración.

Las Ventas()El método de acción devuelve una vista llamada "Ventas", pasando la lista salesData como modelo. Esta acción se encarga de renderizar los datos de ventas en la vista asociada, permitiendo a los usuarios visualizar la información de ventas en un formato tabular o en cualquier otra disposición deseada.

Cómo crear un informe en ASP .NET: Figura 5

Paso 4: Generar informe PDF

En la acción GenerarPdf del controlador, utilice ChromePdfRenderer de IronPDF para renderizar el archivo Vista del navegador a un PDF Documento del informe. Establece las cabeceras de respuesta adecuadas y devuelve el archivo PDF al cliente.

public FileContentResult GeneratePdf()
{
    License.LicenseKey = "YOUR-LICENSE-KEY-HERE";
    ChromePdfRenderer renderer = new ChromePdfRenderer();
    //  Renderizar vista a documento PDF
    PdfDocument pdf = renderer.RenderRazorViewToPdf(_viewRenderService, "Views/Sales/Sales.cshtml", salesData);
    Response.Headers.Append("Content-Disposition", "inline");
    //  Documento PDF de salida
    return File(pdf.BinaryData, "application/pdf", "SalesReport.pdf");
}
public FileContentResult GeneratePdf()
{
    License.LicenseKey = "YOUR-LICENSE-KEY-HERE";
    ChromePdfRenderer renderer = new ChromePdfRenderer();
    //  Renderizar vista a documento PDF
    PdfDocument pdf = renderer.RenderRazorViewToPdf(_viewRenderService, "Views/Sales/Sales.cshtml", salesData);
    Response.Headers.Append("Content-Disposition", "inline");
    //  Documento PDF de salida
    return File(pdf.BinaryData, "application/pdf", "SalesReport.pdf");
}
Public Function GeneratePdf() As FileContentResult
	License.LicenseKey = "YOUR-LICENSE-KEY-HERE"
	Dim renderer As New ChromePdfRenderer()
	'  Renderizar vista a documento PDF
	Dim pdf As PdfDocument = renderer.RenderRazorViewToPdf(_viewRenderService, "Views/Sales/Sales.cshtml", salesData)
	Response.Headers.Append("Content-Disposition", "inline")
	'  Documento PDF de salida
	Return File(pdf.BinaryData, "application/pdf", "SalesReport.pdf")
End Function
VB   C#

Vamos a entender el funcionamiento del código anterior en detalle:

  1. **Configuración de la clave de licencia
    • License.LicenseKey = "YOUR-LICENSE-KEY-HERE";
      • Esta línea establece la clave de licencia necesaria para IronPDF. Es esencial para utilizar las funcionalidades de IronPDF dentro de la aplicación.
  2. **Inicialización del renderizador
    • ChromePdfRenderer renderer = new ChromePdfRenderer();
      • Se crea una instancia de ChromePdfRenderer. Este renderizador se encarga de convertir las vistas Razor a formato PDF utilizando el motor del navegador Chromium.
  3. Convertir vista a PDF:
    • PdfDocument PDF = renderer.RenderRazorViewToPdf(viewRenderService, "Vistas/Ventas/Ventas.cshtml", salesData);
      • El RenderRazorViewToPdf() Se invoca el método ChromePdfRenderer para renderizar la vista Razor especificada. (Vistas/Ventas/Ventas.cshtml) a un documento PDF. La variable salesData sirve de modelo para la vista.
  4. Cabecera Content-Disposition:
    • Response.Headers.Append("Content-Disposition", "inline");
      • El encabezado de respuesta HTTP Content-Disposition está configurado como "inline ". Esto indica al navegador que muestre el contenido del PDF directamente para ver los informes dentro de la ventana o pestaña del navegador cuando se abra.
  5. Devolución del archivo PDF:

    • devolver archivo(pdf.BinaryData, "application/pdf", "SalesReport.pdf");
    • El contenido del documento PDF se devuelve como FileContentResult. Incluye los datos binarios del PDF (pdf.BinaryData)especifica que el tipo MIME es "application/pdf ", y sugiere que el nombre del archivo sea "SalesReport.pdf ".

    En general, este método orquesta eficazmente el proceso de generación de un informe PDF a partir de una vista Razor, por lo que es adecuado para la integración dentro de la aplicación ASP.NET para mejorar las capacidades de generación de informes.

    Cómo crear un informe en ASP .NET: Figura 6

    Para obtener información detallada sobre cómo IronPDF facilita el proceso de generación de informes PDF y otras tareas relacionadas con PDF, visite la página documentación página.

Conclusión

En este artículo, hemos explorado cómo IronPDF simplifica el proceso de generación de informes PDF en aplicaciones ASP.NET. Siguiendo la guía paso a paso proporcionada anteriormente, puede integrar rápidamente IronPDF en sus proyectos ASP.NET y generar informes PDF dinámicos con facilidad.

Con su amplio conjunto de funciones y su perfecta integración, IronPDF permite a los desarrolladores crear informes de calidad profesional que satisfacen las necesidades de sus usuarios y empresas.

IronPDF ofrece un **Prueba gratuita. Descargue la biblioteca de aquí y pruébalo.

< ANTERIOR
Cómo crear una aplicación de informes en C#
SIGUIENTE >
Cómo analizar datos de documentos PDF

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

Comenzar prueba gratuita Descargas totales: 9,541,998
Ver licencias >