Delphi, C++ Builder & .NET Teil von sgcUI

sgcReports, die Berichts-Engine für Delphi, C++ Builder & .NET

Gestalte einen Bericht einmal und liefere ihn als barrierefreies PDF, als Excel-Datei, als CSV oder als PNG-Seiten aus. Baue ihn im Code mit einer Fluent-Kette oder lade zur Laufzeit eine JSON-Definition, mit Gruppen, Zwischensummen, Master-Detail und Barcodes. Die Engine braucht weder ein Fenster noch eine externe DLL und läuft daher in Diensten und Linux64-Daemons.

PDF/UA-1-getaggtes PDF als StandardPDF, XLSX, CSV und PNGWindows-Dienste und Linux64Enthalten in sgcUI Enterprise
sgcReports-Vorschaufenster mit einer Rechnungsseite und einem QR-Code

Alles, was eine Berichts-Engine braucht

Elf Features, jedes mit der echten API und dem Hilfethema dahinter.

Den Bericht gestalten

Beschreibe einen Bericht im Code oder in JSON, mit echten Bändern, Gruppen und Ausdrücken.

Einen vollständigen Bericht in wenigen lesbaren Zeilen schreiben

Den Bericht gestalten

Einen vollständigen Bericht in wenigen lesbaren Zeilen schreiben

Berichtsdesigner sind großartig, bis das Layout in der Versionsverwaltung leben, in einem Pull Request geprüft oder aus deinen eigenen Metadaten erzeugt werden soll. TsgcReportBuilder beschreibt Stile, Seiten, Bänder und Elemente als eine Fluent-Kette, sodass ein Bericht schlichter Code ist, der mit dem Rest deines Projekts kompiliert, verglichen und refaktoriert wird. Dieselbe Kette bereitet den Bericht vor und speichert ihn in jedes Ausgabeformat. So gebaute Berichte lassen sich in einer Schleife erzeugen, als Funktionen teilen und wie jeder andere Code mit Unit-Tests abdecken.

  • Style, Page, GroupHeader, MasterData, GroupFooter und PageFooter lesen sich wie das Layout
  • SaveToPDF, SaveToXLSX, SaveToCSV und SaveToPNG direkt vom Builder
  • Stream-Varianten wie SaveToPDFStream für Web-Antworten
  • Der Builder füllt ein normales TsgcReport-Modell, das du im Code weiter anpassen kannst
  • Rechts nach links für Arabisch und Hebräisch: RightToLeft am Bericht und BiDiMode an Bändern und Elementen spiegeln das Layout, mit geformtem arabischem und hebräischem Text in den Ausgaben PDF, XLSX und HTML
Hilfethema lesen
Gruppen, Zwischensummen und Seitenzahlen, die einfach funktionieren

Den Bericht gestalten

Gruppen, Zwischensummen und Seitenzahlen, die einfach funktionieren

Geschäftsberichte sind selten eine flache Liste: Umsatz nach Region, Rechnungen nach Kunde, Bestand nach Lager. sgcReports hat ein echtes Bandlayout mit Berichtstitel, Seitenkopf, Gruppenkopf, Daten, Gruppenfuß, Seitenfuß und Zusammenfassungsbändern. Eine Gruppe bricht um, wenn sich ihr Ausdruck ändert, druckt ihre eigenen Summen und kann eine neue Seite beginnen oder ihren Kopf auf jeder Seite wiederholen, sodass lange Berichte lesbar bleiben. Unterberichte lassen eine Seite das Layout einer anderen einbinden, für Zusammenfassungen und Anhänge.

  • GroupExpression an einem Gruppenkopfband, verschachtelte Gruppen für zwei oder mehr Ebenen
  • StartNewPage, RepeatOnEveryPage und KeepTogether steuern den Seitenfluss
  • Bandtypen von rbtReportTitle bis rbtReportSummary, dazu Spaltenköpfe und Spaltenfüße
  • TotalPages in Ausdrücken für Fußzeilen wie „Seite 2 von 7“
  • PrintOnFirstPage und PrintOnLastPage bestimmen, wo Seitenbänder erscheinen; SubreportPageName bettet eine andere Seite ein
Hilfethema lesen
Rechnungen direkt aus deiner Datenbank

Den Bericht gestalten

Rechnungen direkt aus deiner Datenbank

Eine Rechnung ist ein Master-Datensatz mit seinen Positionen, und jede Position braucht das richtige Produkt, die richtige Menge und den richtigen Preis. Eine DataSet-Quelle bindet jedes TDataSet, FireDAC eingeschlossen, und verknüpft eine Detailquelle über Schlüsselfelder mit ihrem Master, sodass jede Rechnung ihre eigenen Positionen und Summen druckt. JSON-Arrays und deine eigenen ereignisgesteuerten Quellen funktionieren genauso, wenn die Daten nicht in einer Datenbank liegen. Das Detailband wiederholt sich für jede Position des aktuellen Master-Datensatzes, und der Fuß druckt die Rechnungssumme mit einem Aggregatausdruck über die Positionen.

  • TsgcReportDataSetSource mit MasterSource, MasterFields und DetailFields
  • TsgcReportJSONSource liest einen JSON-String oder eine Datei, RecordsPath wählt das Array
  • TsgcReportEventSource holt Zeilen aus deinem Code über OnFirst, OnNext und OnGetValue
  • Quellen werden mit AddDataSource an der Engine registriert
Hilfethema lesen
Einen Bericht ändern, ohne neu zu kompilieren

Den Bericht gestalten

Einen Bericht ändern, ohne neu zu kompilieren

Eine neue Spalte im Monatsauszug sollte keine neue Version deiner Anwendung erfordern. Berichtsdefinitionen lassen sich in JSON speichern und aus JSON laden, sodass Layouts in einer Datenbank, einem Konfigurationsordner oder einem kundenspezifischen Verzeichnis liegen können. Die Anwendung lädt die Definition zur Laufzeit, bindet die Daten und rendert sie, und dieselbe Datei speist den Web-Designer. Definitionen sind reiner Text, sodass sie sich in der Versionsverwaltung sauber vergleichen lassen und von deinen eigenen Werkzeugen erzeugt oder per Skript migriert werden können.

  • sgcReportLoadFromJSON und sgcReportSaveToJSON, dazu Datei- und Stream-Varianten
  • sgcReportGenerateSchema schreibt ein JSON-Schema für Editoren und Validierung
  • Fehler nennen den JSON-Pfad des fehlerhaften Members
  • Die Demo ReportJSONDefinition bearbeitet eine Definition und ihre Daten nebeneinander
Hilfethema lesen
Ausdrücke und Barcodes in jedem Band

Den Bericht gestalten

Ausdrücke und Barcodes in jedem Band

Summen, formatierte Datumsangaben, bedingter Text und Versandetiketten laufen alle auf Ausdrücke und Barcodes hinaus. Jedes Textelement kann Ausdrücke in Klammern enthalten, etwa eine formatierte Summe eines Felds, mit eingebauten String-, Zahl- und Datumsfunktionen. Barcodes sind ebenfalls Elemente, von der sgcPDF-Engine als Vektoren gezeichnet, sodass Etiketten und Lieferscheine bei jeder Größe scharf drucken. Ausdrücke werden von der Engine für jede Zeile ausgewertet, sodass eine Fußsumme immer zu den darüber gedruckten Positionen passt.

  • Aggregate und Funktionen: Sum, FormatFloat, FormatDateTime, Upper, Round, IsNull
  • OnGetVariable liefert deine eigenen Variablen zur Laufzeit
  • Barcode im Builder mit rbsCode128, rbsEAN13, rbsQRCode, rbsDataMatrix, rbsPDF417 und mehr
  • GS1-128, ITF, Codabar, UPC-A und Code 39 für Logistiketiketten
Hilfethema lesen

Überallhin ausliefern

Einmal vorbereiten, dann in die Formate exportieren, die deine Nutzer und Aufsichtsbehörden verlangen.

Barrierefreies PDF als Standard, PDF/A auf Wunsch

Überallhin ausliefern

Barrierefreies PDF als Standard, PDF/A auf Wunsch

Öffentliche Stellen und viele Unternehmen müssen inzwischen Dokumente veröffentlichen, denen Screenreader folgen können, und Archive brauchen Dateien, die auch in zwanzig Jahren noch aufgehen. Der PDF-Export schreibt standardmäßig getaggtes PDF/UA-1, mit logischer Lesereihenfolge, Alternativtext für Bilder und markierten Überschriften. Schalte PDF/A-3 ein, wenn das Dokument in ein Langzeitarchiv geht. In Delphi und .NET schreibt der Export außerdem PDF/A-4 und PDF/UA-2. Schriften werden über denselben Schriftmanager eingebettet, den auch die Vorschau nutzt, und die Hilfe zeigt Schritt für Schritt, wie du eine Datei mit dem kostenlosen Werkzeug veraPDF validierst.

  • PDFUA ist an TsgcReportPDFExport standardmäßig True
  • AltText und TagRole an Elementen beschreiben Bilder und Überschriften
  • PDFA auf rpaA3b oder rpaA3a gesetzt für die Archivausgabe
  • FixedDocumentID und FixedCreationDate machen die Ausgabe für Tests Byte für Byte reproduzierbar
Hilfethema lesen
Ein Bericht, jedes Format, das deine Nutzer verlangen

Überallhin ausliefern

Ein Bericht, jedes Format, das deine Nutzer verlangen

Die Finanzabteilung will den Auszug in Excel, der Kunde ein PDF, die Integration eine CSV und die Webseite ein Vorschaubild. Die Engine bereitet die Seiten einmal vor, und jeder Export arbeitet mit demselben vorbereiteten Ergebnis, sodass die Zahlen in jeder Datei identisch sind. Die XLSX-Ausgabe behält Zahlen als Zahlen, sodass die Tabellenkalkulation sie ohne Aufräumen summieren kann. Jeder Export kann auch in einen Stream schreiben, was eine Web-Antwort oder ein E-Mail-Anhang braucht, und SaveToFiles schreibt mehrere Formate in einem Aufruf.

  • TsgcReportPDFExport, TsgcReportXLSXExport, TsgcReportCSVExport, TsgcReportImageExport
  • TsgcReportPreparedPages mit LoadPrepared speist mehrere Exporte aus einem Lauf
  • DetectNumbers, SheetName und ExcludePageBands gestalten die Tabelle
  • PNG-Seiten in der DPI, die du an SaveToPNG übergibst
Hilfethema lesen
Ein Vorschaufenster für Desktop-Anwendungen

Überallhin ausliefern

Ein Vorschaufenster für Desktop-Anwendungen

Nutzer wollen einen Bericht durchblättern, bevor sie ihn drucken oder speichern. Das Vorschau-Steuerelement zeigt die vorbereiteten Seiten mit derselben Darstellung wie das PDF, mit Seitennavigation, Zoom- und Anpassungsmodi und einer Toolbar, die du ausblenden kannst, wenn du eine eigene baust. Die VCL-Vorschau läuft unter Windows; die FireMonkey-Vorschau läuft unter Windows. Die Vorschau zeichnet über das sgcPDF-Viewer-Steuerelement, sodass Nutzer am Bildschirm sehen, was der PDF-Export schreibt, und SaveToPDF an der Vorschau speichert die Seiten, die sie gerade ansehen.

  • TsgcReportPreviewVCL mit FirstPage, NextPage, PriorPage und LastPage
  • ZoomIn, ZoomOut, FitWidth und FitPage
  • ShowToolbar, CurrentPage und OnPageChange für deine eigene Navigation
  • TsgcReportPreviewFMX: FireMonkey-Vorschau unter Windows
Hilfethema lesen

Überallhin ausliefern

Läuft headless in Diensten und Linux-Daemons

Die meisten Berichte entstehen heute auf einem Server: nächtliche Auszüge, Rechnungen nach dem Checkout, Exporte hinter einer API. Der sgcReports-Kern hat keine VCL- oder FireMonkey-Abhängigkeit und braucht keine externe DLL und keinen Druckertreiber, sodass derselbe Code in einem Windows-Dienst oder einem Linux64-Daemon läuft. Die Hilfe beschreibt ein Worker-Pool-Muster, bei dem jeder Thread seine eigene Engine besitzt. Aufträge, Daten und Berichtsdefinitionen können als JSON-Dateien eintreffen, sodass ein Daemon von jedem System gespeist werden kann, das eine Datei schreiben kann.

  • TsgcReportEngine bereitet Berichte ohne Fenster vor
  • Die Demo ReportLinuxDaemon überwacht einen Auftragsordner und rendert PDF, XLSX, CSV oder PNG mit 4 Worker-Threads
  • sgcReportsConfigureForServer stimmt den Speichermanager unter Windows auf viele Threads ab
  • Ein gemeinsamer, schreibgeschützter TsgcReportFontManager bedient jeden Thread
Hilfethema lesen

Berichte im Web

Die Brücke sgcReportsHTML liefert Berichte über HTTP aus und lässt Nutzer Layouts im Browser bearbeiten.

Berichte im Web Nur Registered

Berichte über HTTP ausliefern

Ein Webportal, ein Intranet oder eine mobile App braucht oft einfach eine URL, die den Bericht liefert. Der HTTP-Endpunkt registriert Berichte unter Namen an einem sgcWebSockets-HTTP-Server und liefert sie als PDF, XLSX, CSV oder PNG aus, mit einem HTML-Viewer, der die Parameter abfragt, das Ergebnis durchblättert und die Downloads anbietet. Dein Code füllt die Daten vor jedem Lauf in einem Ereignis. Der Endpunkt nutzt dieselben Berichtsdefinitionen und Datenquellen wie dein Desktop-Code, sodass ein einmal geschriebener Bericht die Anwendung und den Browser bedient.

  • TsgcReportHTTPEndpoint mit RegisterReport und BasePath
  • OnBeforePrepare setzt Parameter und Daten pro Anfrage
  • TsgcReportHTMLViewer mit ShowParameters für ein Parameterformular
  • Läuft auf TsgcWebSocketHTTPServer; die Demo ReportHTTPServer ist ein vollständiger Server

Delphi und C++ Builder: braucht sgcWebSockets Professional oder höher und sgcHTML. .NET: Die Pakete esegece.sgcReports.HTML und AspNetCore hosten dieselben Routen.

Hilfethema lesen

Berichte im Web Nur Registered

Ein Web-Berichtsdesigner für deine Nutzer

Power-User wollen immer noch eine Spalte mehr oder eine andere Gruppierung, und früher war jede Änderung ein Ticket für die Entwickler. Der Browser-Designer bearbeitet die JSON-Definition eines Berichts mit einer Bandfläche, einem Eigenschaftsinspektor und einer Live-Vorschau, ausgeliefert vom selben Endpunkt wie der fertige Bericht. Du entscheidest, wer bearbeiten darf, und gespeicherte Definitionen laden in jedem anderen Teil von sgcReports. Eine Schaltfläche JSON herunterladen gibt die Definition an jeden weiter, der sie behalten will.

  • TsgcReportHTMLDesigner an einem Endpunkt mit DesignerEnabled
  • Baum aus Seiten, Bändern und Elementen, Ziehen, Größe ändern und Einrasten in Millimetern, Rückgängig und Wiederholen
  • Eigenschaftsinspektor aus dem JSON-Schema des Berichts erzeugt; serverseitige Validierung zeigt auf das Feld
  • Gespeicherte Definitionen laden mit sgcReportLoadFromJSON überall, auch im Linux-Daemon

Lasse DesignerEnabled an Produktivendpunkten aus und stelle ihn hinter deine eigene Authentifizierung.

Hilfethema lesen

sgcReports in Aktion erleben

sgcReports in den sgcUI-Suite-Demos: vollständige Anwendungen, die offline mit integrierten Simulationsdaten laufen.

Wer mit sgcReports baut

Rechnungen, Lieferscheine und Auszüge

Branchenanwendungen drucken täglich Dokumente aus ihrer Datenbank. Eine DataSet-Quelle mit Master-Detail verknüpft jede Rechnung mit ihren Positionen, Gruppen und Fußzeilen drucken die Summen, ein QR-Code oder GS1-128-Barcode kommt aufs Etikett, und der PDF-Export schreibt eine barrierefreie Datei, bereit zum Versand per E-Mail. Derselbe Bericht lässt sich für die Buchhaltung als XLSX speichern.

  • Master-Detail
  • Gruppen und Zwischensummen
  • Barcodes
  • Barrierefreies PDF
Demo ReportInvoice ausführen

Serverseitige Berichte für Webportale

Kundenportale und interne APIs brauchen Berichte auf Abruf. Registriere die Berichte am HTTP-Endpunkt, und der Browser bekommt einen Viewer mit Parametern und Downloads, oder lasse die Engine in einem Linux64-Daemon laufen, der Aufträge aus einer Warteschlange mit einem Worker-Pool rendert. Es sind weder ein Druckertreiber noch ein Fenster noch eine externe DLL beteiligt. Dieselben JSON-Definitionen bedienen den Viewer und den Daemon.

  • Berichte über HTTP ausliefern
  • Linux-Daemon
  • JSON-Definitionen
Demo ReportHTTPServer ausführen

Pflichten zu Barrierefreiheit und Archivierung

Lieferanten der öffentlichen Hand und regulierte Unternehmen müssen Dokumente veröffentlichen, denen Screenreader folgen können, und sie über Jahre archivieren. Getaggtes PDF/UA-1 ist die Standardausgabe, Alternativtext und Überschriftenrollen liegen an den Berichtselementen, und PDF/A-3 ist nur eine Eigenschaft entfernt. Die Hilfe zeigt, wie du das Ergebnis mit dem kostenlosen Validator veraPDF prüfst. Reproduzierbare Ausgabe hilft automatisierten Tests beim Vergleich von Dateien.

  • Barrierefreies PDF
  • PDF/A-3
  • Reproduzierbare Ausgabe
Demo ReportPDFUA ausführen

A Grouped Sales Report in a Few Lines

The same API in Delphi, C++ Builder and C#: a header per region, a line per sale and a subtotal per region, saved as PDF, XLSX and CSV.

A fluent report over a JSON source: one group per region with a subtotal, saved as PDF, XLSX and CSV.

uses
  Classes, SysUtils,
  sgcReports_Types, sgcReports_Model, sgcReports_Data, sgcReports_Fluent;

const
  CS_SALES = '[' +
    '{"Region":"East","Customer":"Acme Corp","Amount":1450.00},' +
    '{"Region":"East","Customer":"Blue Harbor","Amount":600.00},' +
    '{"Region":"North","Customer":"Nordic Labs","Amount":2100.75},' +
    '{"Region":"North","Customer":"Fjord Ltd","Amount":880.20}]';
  CS_TOTAL = '[FormatFloat(''#,0.00'', Sum(Sales.Amount))]';

procedure ExportSalesReport(const aFolder: string);
var
  oSales: TsgcReportJSONSource;
  oBuilder: TsgcReportBuilder;
begin
  oSales := TsgcReportJSONSource.Create(nil);
  oBuilder := TsgcReportBuilder.Create;
  try
    oSales.SourceName := 'Sales';
    oSales.JSON := CS_SALES;
    oBuilder.Title('Sales by region').Author('eSeGeCe').Units(ruMillimeters)
      .Style('Base').Font('Arial', 10).EndStyle
      .Style('Group').Font('Arial', 11).Bold.BackColor($EEEEEE).EndStyle
      .Page.Paper(rpsA4).Margins(15)
      // one header per region, one line per sale, a subtotal per region
      .GroupHeader('Sales.Region', 9).Style('Group')
      .Text('Region: [Sales.Region]', 0, 1, 180, 7).TagRole(rtrHeading2).EndBand
      .MasterData('Sales', 6).Style('Base')
      .Text('[Sales.Customer]', 2, 0, 120, 6)
      .Text('[Sales.Amount]', 130, 0, 50, 6).AlignRight.Format('#,0.00').EndBand
      .GroupFooter(9).Style('Base')
      .Text('Region total ' + CS_TOTAL, 80, 1, 100, 6).AlignRight.Bold.EndBand
      .PageFooter(8).Style('Base')
      .Text('Page [Page] of [TotalPages]', 0, 1, 180, 6).AlignCenter.EndBand
      .EndPage.Data(oSales);
    // accessible PDF (PDF/UA is on by default), plus the same data as Excel
    oBuilder.SaveToPDF(IncludeTrailingPathDelimiter(aFolder) + 'sales.pdf');
    oBuilder.SaveToXLSX(IncludeTrailingPathDelimiter(aFolder) + 'sales.xlsx');
    oBuilder.SaveToCSV(IncludeTrailingPathDelimiter(aFolder) + 'sales.csv');
  finally
    oBuilder.Free;
    oSales.Free;
  end;
end;

Hilfethema lesen →

The same report in C++ Builder with the generated sgcReports headers.

#include <vcl.h>
#include "sgcReports_Types.hpp"
#include "sgcReports_Model.hpp"
#include "sgcReports_Data.hpp"
#include "sgcReports_Fluent.hpp"

void ExportSalesReport(const String Folder)
{
  const String Total = "[FormatFloat('#,0.00', Sum(Sales.Amount))]";
  TsgcReportJSONSource *Sales = new TsgcReportJSONSource(NULL);
  TsgcReportBuilder *Builder = new TsgcReportBuilder();
  try
  {
    Sales->SourceName = "Sales";
    Sales->JSON = "[{\"Region\":\"East\",\"Customer\":\"Acme Corp\",\"Amount\":1450.00},"
                  "{\"Region\":\"East\",\"Customer\":\"Blue Harbor\",\"Amount\":600.00},"
                  "{\"Region\":\"North\",\"Customer\":\"Nordic Labs\",\"Amount\":2100.75}]";
    Builder->Title("Sales by region")->Author("eSeGeCe")->Units(ruMillimeters)
      ->Style("Base")->Font("Arial", 10)->EndStyle()
      ->Style("Group")->Font("Arial", 11)->Bold()->BackColor(0xEEEEEE)->EndStyle()
      ->Page("")->Paper(rpsA4, roPortrait)->Margins(15)
      // one header per region, one line per sale, a subtotal per region
      ->GroupHeader("Sales.Region", 9)->Style("Group")
      ->Text("Region: [Sales.Region]", 0, 1, 180, 7)->TagRole(rtrHeading2)->EndBand()
      ->MasterData("Sales", 6)->Style("Base")
      ->Text("[Sales.Customer]", 2, 0, 120, 6)
      ->Text("[Sales.Amount]", 130, 0, 50, 6)->AlignRight()->Format("#,0.00")->EndBand()
      ->GroupFooter(9)->Style("Base")
      ->Text("Region total " + Total, 80, 1, 100, 6)->AlignRight()->Bold()->EndBand()
      ->EndPage()->Data(Sales);
    // accessible PDF (PDF/UA is on by default), plus the same data as Excel
    Builder->SaveToPDF(IncludeTrailingPathDelimiter(Folder) + "sales.pdf");
    Builder->SaveToXLSX(IncludeTrailingPathDelimiter(Folder) + "sales.xlsx");
    Builder->SaveToCSV(IncludeTrailingPathDelimiter(Folder) + "sales.csv");
  }
  __finally
  {
    delete Builder;
    delete Sales;
  }
}

Hilfethema lesen →

The same builder chain in C#, with the same class names as Delphi.

using System.IO;
using esegece.sgcReports;

public static class SalesReport
{
    const string Sales = "[" +
        "{\"Region\":\"East\",\"Customer\":\"Acme Corp\",\"Amount\":1450.00}," +
        "{\"Region\":\"East\",\"Customer\":\"Blue Harbor\",\"Amount\":600.00}," +
        "{\"Region\":\"North\",\"Customer\":\"Nordic Labs\",\"Amount\":2100.75}," +
        "{\"Region\":\"North\",\"Customer\":\"Fjord Ltd\",\"Amount\":880.20}]";
    const string Total = "[FormatFloat('#,0.00', Sum(Sales.Amount))]";

    public static void Export(string aFolder)
    {
        using (TsgcReportJSONSource oSales = new TsgcReportJSONSource())
        using (TsgcReportBuilder oBuilder = new TsgcReportBuilder())
        {
            oSales.SourceName = "Sales";
            oSales.JSON = Sales;
            oBuilder.Title("Sales by region").Author("eSeGeCe").Units(TsgcReportUnits.ruMillimeters)
                .Style("Base").Font("Arial", 10).EndStyle()
                .Style("Group").Font("Arial", 11).Bold().BackColor(0xEEEEEE).EndStyle()
                .Page().Paper(TsgcReportPaperSize.rpsA4).Margins(15)
                // one header per region, one line per sale, a subtotal per region
                .GroupHeader("Sales.Region", 9).Style("Group")
                .Text("Region: [Sales.Region]", 0, 1, 180, 7)
                .TagRole(TsgcReportTagRole.rtrHeading2).EndBand()
                .MasterData("Sales", 6).Style("Base")
                .Text("[Sales.Customer]", 2, 0, 120, 6)
                .Text("[Sales.Amount]", 130, 0, 50, 6).AlignRight().Format("#,0.00").EndBand()
                .GroupFooter(9).Style("Base")
                .Text("Region total " + Total, 80, 1, 100, 6).AlignRight().Bold().EndBand()
                .EndPage().Data(oSales);
            // accessible PDF (PDF/UA is on by default), plus the same data as Excel
            oBuilder.SaveToPDF(Path.Combine(aFolder, "sales.pdf"));
            oBuilder.SaveToXLSX(Path.Combine(aFolder, "sales.xlsx"));
            oBuilder.SaveToCSV(Path.Combine(aFolder, "sales.csv"));
        }
    }
}
dotnet add package esegece.sgcReports

Hilfethema lesen →

Die sgcReports-Demos ausführen

Zu sgcReports gehören zehn Delphi-Demos, acht C++-Builder-Demos und zehn .NET-Demos. Die Karten unten sind die Delphi-Projekte; die meisten haben einen C++-Builder- und einen .NET-Zwilling mit demselben Namen.

ReportInvoice

ReportInvoice

Eine Master-Detail-Rechnung aus DataSets: Kopf, Positionen, Summen und ein QR-Code, in der Vorschau und als PDF.

ReportGroups

ReportGroups

Umsatz nach Region gruppiert, mit Gruppenköpfen, Zwischensummen und einer Gesamtsumme im Zusammenfassungsband.

ReportFluent

ReportFluent

Ein vollständiger Bericht, mit dem Fluent-Builder geschrieben und dann in jedes Format exportiert.

ReportJSONDefinition

ReportJSONDefinition

Bearbeite eine JSON-Definition und ihre Daten in zwei Memos und rendere sie, mit Fehlern, die auf den JSON-Pfad zeigen.

ReportPDFUA

ReportPDFUA

Getaggte PDF/UA-1-Ausgabe mit Alternativtext und Überschriftenrollen, bereit für eine veraPDF-Prüfung.

ReportExports

ReportExports

Ein vorbereiteter Bericht, geschrieben als PDF-, XLSX-, CSV- und PNG-Dateien.

ReportDatabaseSQL

ReportDatabaseSQL

Ein Bericht, der über DataSet-Quellen von SQL-Abfragen gespeist wird.

ReportMobileFMX

Die FireMonkey-Vorschau mit Seitennavigation. Die FireMonkey-Vorschau läuft unter Windows.

ReportLinuxDaemon

Ein Konsolen-Daemon für Windows und Linux64, der in einer Warteschlange liegende JSON-Aufträge mit einem Pool von Worker-Threads rendert.

Nur Registered ReportHTTPServer

Über HTTP ausgelieferte Berichte mit Browser-Viewer, Parametern und Downloads. Braucht sgcWebSockets und sgcHTML.

Kompilierte Demos

Sofort lauffähige Programme jedes sgcUI-Produkts, nichts zu installieren.

sgcUI_bin.zip herunterladen →

Wo sgcReports enthalten ist

sgcReports ist in sgcUI Enterprise enthalten und wird auch einzeln verkauft. Es nutzt die sgcPDF-Engine für PDF-Ausgabe und Barcodes, sodass sgcPDF in jeder Konfiguration erforderlich ist. sgcReports ist außerdem im All-Access-Bundle enthalten.

sgcReports Einzelpaket

€199 / Entwickler, voller Quellcode, 1 Jahr Updates.

sgcReports kaufen → Preise ansehen →

sgcUI Enterprise

Alle 14 sgcUI-Produkte, ab €699.

Enterprise ansehen →

Die kostenlosen .NET-Community-Pakete (esegece.sgcReports.Community, .WinForms.Community, .HTML.Community, .AspNetCore.Community) enthalten die Engine, die Exporte und die Vorschau. In Delphi bietet der Community-Installer sgcReports nur an, wenn ein lizenziertes sgcPDF installiert ist. Die Brücke sgcReportsHTML für Delphi und C++ Builder ist nur Registered.

FunktionCommunity (kostenlos)Registered
Fluent-Builder, Berichtsmodell und JSON-Definitionen✓✓
Bänder, Gruppen, Master-Detail und Ausdrücke✓✓
Barcodes✓✓
PDF/UA- und PDF/A-3-Export✓✓
XLSX-, CSV- und PNG-Export✓✓
WinForms-Vorschau✓✓
Headless-Engine für Dienste und Linux✓✓
sgcReportsHTML-Brücke für Delphi und C++ Builder (HTTP-Endpunkt, Viewer, Web-Designer)−✓

Unterstützte Frameworks und Plattformen

Komponenten in sgcReports

Engine und Modell

TsgcReport, TsgcReportEngine und der Fluent-Builder TsgcReportBuilder.

Datenquellen

TsgcReportDataSetSource, TsgcReportJSONSource und TsgcReportEventSource.

Exporte

TsgcReportPDFExport, TsgcReportXLSXExport, TsgcReportCSVExport und TsgcReportImageExport.

Vorschau

TsgcReportPreviewVCL und TsgcReportPreviewFMX, die FireMonkey-Vorschau unter Windows.

sgcReportsHTML-Brücke

TsgcReportHTTPEndpoint, TsgcReportHTMLViewer und TsgcReportHTMLDesigner. Sie braucht sgcWebSockets Professional oder höher und sgcHTML. Registered

.NET

Dieselben Klassennamen im Namespace esegece.sgcReports: der Builder, die Quellen, die Engine und die Exporte.

ZielKomponentePlattformen
Delphi 7 bis 13Modell, Ausdrücke, Daten, Layout, Engine und ExporteWindows, Linux64, macOS, iOS und Android
C++ Builder 2007 bis 13Dieselben KlassenGenerierte .hpp-Header und statische Bibliotheken
VCL-VorschauTsgcReportPreviewVCLWindows
FireMonkey-VorschauTsgcReportPreviewFMXWindows
.NETBuilder, Quellen, Engine, Exporte und die WinForms-VorschauWindows, dazu Headless-Nutzung unter Linux

Häufig gestellte Fragen

Ja, immer. sgcReports schreibt PDF und zeichnet Barcodes mit der sgcPDF-Engine. sgcUI Enterprise enthält beides. Im Delphi-Community-Installer wird sgcReports nur angeboten, wenn ein lizenziertes sgcPDF installiert ist. Die PDF-Engine zeichnet auch die getaggte Struktur barrierefreier PDF-Dateien.

Ja, im Browser. TsgcReportHTMLDesigner aus der Brücke sgcReportsHTML bearbeitet JSON-Berichtsdefinitionen mit einer Bandfläche, einem Eigenschaftsinspektor und einer Live-Vorschau. Im Code decken der Fluent-Builder und JSON-Definitionen dasselbe Modell ab. Gespeicherte Definitionen laden in Desktop-Anwendungen, Diensten und Daemons gleichermaßen.

Ja. Der Kern hat keine VCL- oder FireMonkey-Abhängigkeit und keine externe DLL, sodass die Engine und die Exporte in Linux64-Konsolenanwendungen und Daemons laufen. Die Demo ReportLinuxDaemon und das Thema Linux-Daemon enthalten eine systemd-Unit. Derselbe Code läuft auch in Windows-Diensten.

PDF (getaggtes PDF/UA-1 als Standard, PDF/A-3 auf Wunsch), XLSX, CSV und PNG-Seiten. Alle arbeiten mit denselben vorbereiteten Seiten, sodass ein Bericht einmal vorbereitet und beliebig oft exportiert wird. Jeder Export kann in eine Datei oder in einen Stream schreiben, für Web-Antworten und E-Mail-Anhänge.

Ja, mit einer Engine pro Thread. Jeder Worker erzeugt seinen eigenen Bericht, seine eigene Engine, seine eigenen Datenquellen und Exporte, während ein Schriftmanager und eine schreibgeschützte JSON-Definition gemeinsam genutzt werden können. Das Thema Thread-Sicherheit zeigt das Worker-Pool-Muster. Ein Windows-Server kann außerdem beim Start einmal sgcReportsConfigureForServer für viele Threads aufrufen.

Ja. Speichere die Berichtsdefinitionen als JSON und lade sie zur Laufzeit mit sgcReportLoadFromJSON, sodass ein neues Layout keinen neuen Build braucht. Nutzer können sie im Web-Designer bearbeiten, oder deine Anwendung kann sie erzeugen. Fehler beim Laden nennen den JSON-Pfad des fehlerhaften Members, was kundenspezifische Layouts leicht supportbar macht.

Ja. TsgcReportPreviewVCL zeigt die vorbereiteten Seiten mit Navigation, Zoom- und Anpassungsmodi. TsgcReportPreviewFMX ist die FireMonkey-Vorschau unter Windows, und .NET hat eine WinForms-Vorschau. Die Vorschau zeichnet über das sgcPDF-Viewer-Steuerelement, sodass der Bildschirm zum PDF-Export passt.

sgcReports Hilfe

3,000+Entwickler
20+Jahre
761+Komponenten
30+API-Integrationen
5Plattformen
30 Tage Geld-zurück-GarantieNicht zufrieden? Fordere innerhalb von 30 Tagen nach dem Kauf eine vollständige Rückerstattung an. Rückerstattungsrichtlinie ansehen

sgcReports heute testen

Die sgcUI-Testversion enthält sgcReports, sgcPDF und jedes andere sgcUI-Produkt.