C# para .NET NuGet Edición Community gratuita

La herramienta de informes .NET para C#

sgcReports es una herramienta de informes .NET y un generador de informes en C#: crea informes en código, muéstralos en WinForms, WPF y Avalonia, y exporta a PDF y Excel.

Builder fluido en C# y diseños JSON Diseñador para WinForms, WPF, Avalonia PDF/UA, PDF/A-3, XLSX y CSV Sin interfaz en servicios y en Linux

Ver precios →   Descargas y demos de .NET →

Informe de turno creado con sgcReports y mostrado en la vista previa de informes: una página A4 con cuadros de OEE, disponibilidad, rendimiento y calidad, un gráfico de producción por hora, barras de paradas por causa y un código de barras de lote

Informes creados con sgcReports

Listas agrupadas, facturas, tablas y catálogos, preparados una sola vez por el motor de informes y mostrados en una vista previa o escritos en PDF, Excel, CSV e imágenes.

Cómo crear un informe en C#

Dale al informe sus datos con un TsgcReportDataTableSource sobre un DataTable, describe el diseño con el TsgcReportBuilder fluido y guárdalo. El builder crea y posee su propio informe y motor de informes. Todos los tipos están en el espacio de nombres esegece.sgcReports, con los mismos nombres de clase que la edición para Delphi.

SalesReport.cs
using esegece.sgcReports;

public static class SalesReport
{
    // aSales: a TsgcReportDataTableSource named "Sales" over a DataTable
    // with the columns Region, Customer and Amount, sorted by Region
    public static TsgcReportBuilder Build(TsgcReportDataSource aSales)
    {
        TsgcReportBuilder oBuilder = new TsgcReportBuilder();
        oBuilder.Title("Sales by region").Units(TsgcReportUnits.ruMillimeters)
            .Style("Group").Font("Arial", 11).Bold().BackColor(0xEEEEEE).EndStyle()
            .Page().Paper(TsgcReportPaperSize.rpsA4).Margins(15)
            .ReportTitle(14)
            .Text("Sales by region", 0, 0, 180, 10).Bold().EndBand()
            // one header per region, one line per sale, a total per region
            .GroupHeader("Sales.Region", 9).Style("Group")
            .Text("Region: [Sales.Region]", 0, 1, 180, 7).EndBand()
            .MasterData("Sales", 6)
            .Text("[Sales.Customer]", 2, 0, 120, 6)
            .Text("[Sales.Amount]", 130, 0, 50, 6).AlignRight().Format("#,0.00").EndBand()
            .GroupFooter(9)
            .Text("Region total [FormatFloat('#,0.00', Sum(Sales.Amount))]", 80, 1, 100, 6)
            .AlignRight().Bold().EndBand()
            .EndPage().Data(aSales);
        return oBuilder;
    }
}

Rellena un DataTable desde tu base de datos o tus objetos, pásalo a la fuente de datos y guarda el informe. La salida PDF es PDF/UA etiquetado por defecto, y las mismas páginas preparadas van a Excel y CSV.

Program.cs
using System.Data;
using esegece.sgcReports;

DataTable oTable = new DataTable("Sales");
oTable.Columns.Add("Region", typeof(string));
oTable.Columns.Add("Customer", typeof(string));
oTable.Columns.Add("Amount", typeof(double));
oTable.Rows.Add("East", "Acme Corp", 1450.00);
oTable.Rows.Add("East", "Blue Harbor", 600.00);
oTable.Rows.Add("North", "Nordic Labs", 2100.75);

using (TsgcReportDataTableSource oSales = new TsgcReportDataTableSource())
{
    oSales.SourceName = "Sales";
    oSales.DataTable = oTable;
    using (TsgcReportBuilder oBuilder = SalesReport.Build(oSales))
    {
        // tagged PDF/UA by default, the same pages as an Excel workbook and a CSV file
        oBuilder.SaveToPDF("sales.pdf");
        oBuilder.SaveToXLSX("sales.xlsx");
        oBuilder.SaveToCSV("sales.csv");
        // PDF/A-3 on request, for archiving
        oBuilder.PDFExport.PDFA = TsgcReportPDFAMode.rpaA3b;
        oBuilder.SaveToPDF("sales-archive.pdf");
        // keep the layout as a JSON report definition
        sgcReports_Definition.sgcReportSaveToJSONFile(oBuilder.Report, "sales.json");
    }
}

El builder también añade cabeceras y pies de página, cabeceras de columna, bandas de detalle, tablas, casillas de verificación, códigos de barras, parámetros de informe y marcadores. Consulta el tema de ayuda de TsgcReportBuilder y la guía de primeros pasos.

Diseñador y visor de informes para WinForms, WPF y Avalonia

Cada paquete de interfaz tiene una vista previa de informes y un diseñador de informes para usuarios finales listo para usar, de modo que tus usuarios pueden abrir, cambiar y guardar diseños de informe dentro de tu aplicación. Los diseñadores tienen una barra de herramientas, pestañas Design y Preview, los árboles Toolbox, Outline y Data, un inspector de propiedades, reglas, deshacer y rehacer, y un editor de scripts. Los tres hosts comparten un único modelo de diseñador independiente de la plataforma.

WinForms

El paquete esegece.sgcReports.WinForms: el control de vista previa de informes, TsgcWinFormsReportDesigner (un UserControl), el TsgcWinFormsReportDesignerForm modal y sgcReports_Designer_WinForms.sgcShowReportDesigner.

WPF

El paquete esegece.sgcReports.Wpf: TsgcWpfReportPreview con navegación de páginas, zoom, impresión y guardado en PDF, TsgcWpfReportDesigner (un DockPanel) y el TsgcWpfReportDesignerWindow modal.

Avalonia

El paquete esegece.sgcReports.Avalonia: TsgcAvaloniaReportPreview con navegación de páginas, zoom y guardado en PDF, TsgcAvaloniaReportDesigner y sgcShowReportDesignerAsync con selectores de archivos asíncronos.

Las vistas previas tienen una barra de búsqueda, miniaturas de página, el esquema del PDF, un menú Export con once formatos, un botón Cancel mientras se prepara un informe largo y un aviso para los parámetros del informe. Las vistas previas están en todas las ediciones, las clases de diseñador en la edición Registered. Los diseñadores también importan plantillas .rtm de ReportBuilder como informes nuevos. Consulta la ayuda de los diseñadores .NET.

SalesForm.cs
using System.Data;
using System.Windows.Forms;
using esegece.sgcReports;

public class SalesForm : Form
{
    TsgcReportDataTableSource FSales;
    TsgcReportBuilder FBuilder;
    TsgcReportPreviewVCL FPreview;

    public SalesForm(DataTable aSales)
    {
        Width = 1000;
        Height = 760;
        FSales = new TsgcReportDataTableSource();
        FSales.SourceName = "Sales";
        FSales.DataTable = aSales;
        FBuilder = SalesReport.Build(FSales);
        // the preview: page navigation, zoom, find, thumbnails, print and export
        FPreview = new TsgcReportPreviewVCL();
        FPreview.Dock = DockStyle.Fill;
        Controls.Add(FPreview);
        Button oDesign = new Button();
        oDesign.Text = "Design...";
        oDesign.Dock = DockStyle.Top;
        oDesign.Click += (s, e) =>
        {
            // the end-user designer (Registered edition) as a modal window
            if (sgcReports_Designer_WinForms.sgcShowReportDesigner(FBuilder.Engine, FSales))
            {
                sgcReports_Definition.sgcReportSaveToJSONFile(FBuilder.Engine.Report, "sales.json");
                FPreview.Prepare();
            }
        };
        Controls.Add(oDesign);
        FPreview.Engine = FBuilder.Engine;
        FPreview.Prepare();
    }
}
DesignerWindow.cs
using System.Windows;
using esegece.sgcReports;

public class DesignerWindow : Window
{
    public DesignerWindow(TsgcReportEngine aEngine, TsgcReportDataSource aSales)
    {
        Title = "Report designer";
        TsgcWpfReportDesigner oDesigner = new TsgcWpfReportDesigner();
        Content = oDesigner;
        oDesigner.Engine = aEngine;
        oDesigner.AddDataSource(aSales);
        oDesigner.LoadFromFile("sales.json");
        Closed += (s, e) => oDesigner.Dispose();
    }
}

public class PreviewWindow : Window
{
    public PreviewWindow(TsgcReportEngine aEngine)
    {
        TsgcWpfReportPreview oPreview = new TsgcWpfReportPreview();
        Content = oPreview;
        oPreview.Engine = aEngine;
        oPreview.Prepare();
    }
}

Bandas, grupos, maestro detalle y expresiones

sgcReports es un generador de informes por bandas en C#: las páginas contienen bandas, las bandas contienen elementos, y el motor imprime cada banda en el momento adecuado para tus datos.

Bandas

Bandas de título y resumen del informe, cabecera y pie de página, cabecera de columna, cabecera y pie de grupo, datos maestros y datos de detalle, cada una con su propia altura, estilo y elementos.

Grupos y totales

Una cabecera de grupo inicia un grupo nuevo cada vez que cambia su expresión, y un pie de grupo imprime subtotales con funciones de agregado como Sum y Count.

Maestro detalle

Enlaza una fuente de detalle con su maestro mediante MasterSource, MasterFields y DetailFields, igual que una factura enlaza sus líneas con la factura.

Expresiones

Campos y funciones entre corchetes dentro de los elementos de texto, como [Sales.Customer] o [FormatFloat('#,0.00', Sum(Sales.Amount))], más resaltados que cambian el estilo de un elemento cuando una condición es verdadera.

Tablas y tablas de referencias cruzadas

Elementos de tabla con filas de cabecera, datos y pie, celdas combinadas y filas que crecen con su texto, y tablas de referencias cruzadas con varias medidas y totales.

Parámetros, scripts y herencia

Parámetros de informe tipados con un aviso, un pequeño lenguaje de script guardado en el informe, e informes que heredan de un diseño base como un membrete.

Los datos proceden de un TsgcReportDataTableSource sobre un DataTable, o de un TsgcReportJSONSource sobre un array JSON de objetos. El texto enriquecido, las marcas de agua, los códigos de barras, las casillas de verificación y los marcadores están en todas las ediciones. Los elementos de gráfico, sparkline, indicador y tabla dinámica vienen con los paquetes puente Registered sgcCharts, sgcGauges y sgcPivotGrid. Consulta la matriz de características de sgcReports.

Exporta un informe a PDF y Excel en C#

El motor prepara las páginas una sola vez, y cada exportación las escribe en su propio formato. La salida PDF usa el motor sgcPDF, así que sgcPDF es obligatorio en toda configuración.

FormatoDetalles.NET Community (gratuita)
PDF/UAPDF/UA-1 etiquetado por defecto, con orden de lectura, texto alternativo para imágenes y encabezados marcados. PDF/UA-2 si lo pides.✓
PDF/APDF/A-3 (rpaA3b, rpaA3a) para archivos y facturas electrónicas con el XML de la factura incrustado, y PDF/A-4.✓
XLSX y CSVLibros de Excel y archivos CSV a partir de las mismas páginas preparadas.✓
PNG, SVG, ODS, HTML y textoUna imagen por página, hojas de cálculo OpenDocument, HTML y texto sin formato.✓
DOCX, ODT y RTFDocumentos de Word, texto OpenDocument y Rich Text Format.−
PDF firmadoEl paquete puente de sgcSign firma las exportaciones PDF (PAdES).✓

Genera informes en servicios, ASP.NET Core y Linux

El motor y las exportaciones no necesitan interfaz, así que el mismo informe se ejecuta en un servicio de Windows, una API web o un daemon de Linux. Carga una definición de informe JSON guardada por tu código o por el diseñador, adjunta los datos y escribe el archivo.

ReportJob.cs
using System.Data;
using esegece.sgcReports;

public static class ReportJob
{
    public static void Run(DataTable aSales, string aFileName)
    {
        using (TsgcReport oReport = new TsgcReport())
        using (TsgcReportEngine oEngine = new TsgcReportEngine())
        using (TsgcReportDataTableSource oSales = new TsgcReportDataTableSource())
        using (TsgcReportPDFExport oPDF = new TsgcReportPDFExport())
        {
            // the layout comes from a JSON definition, the data from your code
            sgcReports_Definition.sgcReportLoadFromJSONFile(oReport, "sales.json");
            oSales.SourceName = "Sales";
            oSales.DataTable = aSales;
            oEngine.Report = oReport;
            oEngine.AddDataSource(oSales);
            TsgcReportPreparedPages oPages = oEngine.Prepare();
            oPDF.SaveToFile(oPages, aFileName);
        }
    }
}

Informes sobre HTTP

TsgcReportHTTPEndpoint sirve informes registrados (RegisterReport) como PDF, XLSX, CSV, HTML y otros archivos, y los paquetes esegece.sgcReports.HTML y esegece.sgcReports.AspNetCore alojan sus rutas en ASP.NET Core.

Un motor por hilo

Un servidor prepara informes concurrentes con un motor y un conjunto de fuentes de datos por hilo. Las demos .NET incluyen un proyecto LinuxDaemon y otro HTTPServer.

Instala la herramienta de informes .NET desde NuGet

esegece.sgcReports contiene el builder, las fuentes de datos, el motor y las exportaciones. Añade el paquete de tu framework de interfaz para la vista previa y el diseñador, y los paquetes HTML y ASP.NET Core para servir informes en la web.

dotnet add package esegece.sgcReports
dotnet add package esegece.sgcReports.WinForms
dotnet add package esegece.sgcReports.Wpf
dotnet add package esegece.sgcReports.Avalonia
dotnet add package esegece.sgcReports.AspNetCore

Para la edición Community gratuita, usa los mismos ids de paquete con el sufijo .Community, por ejemplo dotnet add package esegece.sgcReports.Community. La lista completa de paquetes está en la página de descargas de sgcReports, y la visión general de .NET explica los componentes. Las demos .NET son Invoice, Groups, JSONDefinition, PDFUA, Exports, Fluent, HTTPServer, LinuxDaemon, DatabaseSQL y MobileMAUI.

Ediciones Community y Registered

Los paquetes Community gratuitos incluyen el motor, las exportaciones y las vistas previas. La edición Registered añade los diseñadores para usuarios finales, las exportaciones a DOCX, ODT y RTF y los puentes de gráficos, indicadores y tablas dinámicas.

Característica.NET Community (gratuita)Registered
Builder fluido, modelo de informe y definiciones JSON✓✓
Bandas, grupos, maestro detalle y expresiones✓✓
Exportación a PDF/UA y PDF/A-3✓✓
Exportación a XLSX, CSV, PNG, ODS, SVG, HTML y texto sin formato✓✓
Vistas previas de WinForms, WPF y Avalonia✓✓
Motor sin interfaz para servicios y Linux✓✓
Diseñador de informes para usuarios finales de WinForms, WPF y Avalonia−✓
Exportación a DOCX, ODT y RTF−✓
Elementos de gráfico, sparkline, indicador y tabla dinámica−✓

Community, gratis

Los paquetes .Community son gratuitos para particulares y organizaciones con menos de 1 M EUR de ingresos brutos anuales y no más de 5 desarrolladores. Las organizaciones que alcancen o superen cualquiera de los dos umbrales necesitan una licencia Registered.

esegece.sgcReports.Community en NuGet →

Registered

Todas las características y la licencia comercial. Licencias Single, Team y Site, cada una con código fuente completo, 1 año de actualizaciones y un descuento de renovación del 50% al 70%.

Precios de sgcReports .NET →

sgcReports .NET

€199

Licencias Single, Team y Site disponibles.

  • Motor, exportaciones y los paquetes de WinForms, WPF y Avalonia
  • Paquetes HTML y ASP.NET Core
  • Código fuente completo
  • 1 año de actualizaciones

Preguntas sobre informes .NET

Sí. sgcReports tiene una vista previa de informes y un diseñador de informes para usuarios finales para WinForms (esegece.sgcReports.WinForms), WPF (esegece.sgcReports.Wpf) y Avalonia (esegece.sgcReports.Avalonia). Las vistas previas muestran las páginas con navegación, zoom, búsqueda, miniaturas y exportación. El motor y las exportaciones están en el paquete principal esegece.sgcReports y funcionan sin ninguna interfaz.

Añade el paquete NuGet esegece.sgcReports (o esegece.sgcReports.Community), envuelve tu DataTable en un TsgcReportDataTableSource, describe páginas, bandas y elementos con el TsgcReportBuilder fluido y llama a SaveToPDF, SaveToXLSX o SaveToCSV, como en el ejemplo de creación de un informe. También puedes cargar el diseño desde una definición de informe JSON.

Sí, con la edición Registered. TsgcWinFormsReportDesigner, TsgcWpfReportDesigner y TsgcAvaloniaReportDesigner son diseñadores que colocas en tu propia ventana, y sgcShowReportDesigner abre uno como ventana modal. Los usuarios arrastran elementos y campos a las bandas, editan propiedades, tablas y scripts, previsualizan el resultado y guardan el diseño como una definición JSON que tu servidor puede ejecutar sin interfaz.

Sí. SaveToPDF escribe PDF/UA etiquetado por defecto, PDFExport.PDFA cambia a PDF/A-3, y SaveToXLSX escribe un libro de Excel a partir de las mismas páginas preparadas. CSV, PNG, SVG, ODS, HTML y texto sin formato están en todas las ediciones, y DOCX, ODT y RTF en la edición Registered.

Sí. El motor sin interfaz y las exportaciones se ejecutan en Windows y en Linux, en servicios y daemons, y las demos .NET incluyen un proyecto LinuxDaemon. Para la web, el paquete esegece.sgcReports.AspNetCore integra el endpoint de informes con ASP.NET Core, que sirve informes como PDF, XLSX, CSV, HTML y otros archivos.

Sí. Cada paquete NuGet de sgcReports también se ofrece como edición Community gratuita con el sufijo .Community, con el motor, las exportaciones y las vistas previas. Es gratuita para particulares y organizaciones con menos de 1 M EUR de ingresos brutos anuales y no más de 5 desarrolladores. Los diseñadores para usuarios finales y las exportaciones a DOCX, ODT y RTF necesitan una licencia Registered, consulta los precios de sgcReports.

La mejor opción: All-AccessTodos los productos de eSeGeCe, con Premium Support incluido, desde €1,059 al año.
Ver precios de All-Access

Añade informes a tu aplicación .NET

Crea informes en C#, muéstralos en WinForms, WPF y Avalonia, y exporta a PDF y Excel con un solo paquete NuGet.