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.
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.
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.
La demo ReportTables en .NET WinForms: la vista previa con navegación de páginas, zoom, impresión, PDF, búsqueda, miniaturas y exportación, más botones para el diseñador y el editor de tablas.
Un informe agrupado con una cabecera por grupo, subtotales y números de página.
Una factura a partir de datos maestro y detalle, con sus líneas, los totales y un código QR.
Una definición de informe JSON y la página que renderiza. Cambia un diseño sin recompilar tu aplicación.
Un informe preparado, escrito en PDF, un libro de Excel, un archivo CSV y un PNG por página.
El editor de tablas del diseñador de informes: filas de cabecera, datos y pie, celdas combinadas, estilos y resaltados.
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.
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.
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.
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.
El paquete esegece.sgcReports.WinForms: el control de vista previa de informes, TsgcWinFormsReportDesigner (un UserControl), el TsgcWinFormsReportDesignerForm modal y sgcReports_Designer_WinForms.sgcShowReportDesigner.
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.
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.
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();
}
}
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();
}
}
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 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.
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.
Enlaza una fuente de detalle con su maestro mediante MasterSource, MasterFields y DetailFields, igual que una factura enlaza sus líneas con la factura.
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.
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 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.
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.
| Formato | Detalles | .NET Community (gratuita) |
|---|---|---|
| PDF/UA | PDF/UA-1 etiquetado por defecto, con orden de lectura, texto alternativo para imágenes y encabezados marcados. PDF/UA-2 si lo pides. | ✓ |
| PDF/A | PDF/A-3 (rpaA3b, rpaA3a) para archivos y facturas electrónicas con el XML de la factura incrustado, y PDF/A-4. | ✓ |
| XLSX y CSV | Libros de Excel y archivos CSV a partir de las mismas páginas preparadas. | ✓ |
| PNG, SVG, ODS, HTML y texto | Una imagen por página, hojas de cálculo OpenDocument, HTML y texto sin formato. | ✓ |
| DOCX, ODT y RTF | Documentos de Word, texto OpenDocument y Rich Text Format. | − |
| PDF firmado | El paquete puente de sgcSign firma las exportaciones PDF (PAdES). | ✓ |
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.
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);
}
}
}
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 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.
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.
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 | − | ✓ |
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.
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 →€199
Licencias Single, Team y Site disponibles.
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.