Render Crystal Reports to PDF in C#

ReportModel model = ReportModelBuilder.FromRpt("report.rpt");

// A saved report prints with the parameter values it was saved with.
IReadOnlyDictionary<string, FormulaValue> parameters =
    ParameterBinding.Resolve(model, new Dictionary<string, string>(), useSavedValues: true);
model = ReportDataBinder.Bind(model, new SavedDataRowSource(), parameters, "report.rpt");

PaginatedDocument doc = Paginator.Paginate(model, new PdfTextMeasurer(), Locale.EnGb, parameters);
PdfRenderer.RenderToFile(doc, model, "out.pdf");

ReportModel model = ReportModelBuilder.FromRpt("report.rpt");
File.WriteAllText("report.json", ReportModel.ToJson(model));

// ...and back: the engine renders the definition, not the .rpt.
ReportModel definition = ReportModel.FromJson(File.ReadAllText("report.json"));

IReadOnlyDictionary<string, FormulaValue> parameters =
    ParameterBinding.Resolve(definition, new Dictionary<string, string>(), useSavedValues: true);
definition = ReportDataBinder.Bind(definition, new SavedDataRowSource(), parameters, "report.json");

PaginatedDocument doc = Paginator.Paginate(definition, new PdfTextMeasurer(), Locale.EnGb, parameters);
PdfRenderer.RenderToFile(doc, definition, "out.pdf");

{
  "RecordSelection": "{ORDERS.CUSTOMER_ID} = {?CUSTOMER_ID}",
  "Formulas": [
    { "Name": "IsOpenOrder", "ResultType": "Boolean", "Text": "{ORDERS.STATUS} <> 'CANCELLED'" }
  ],
  "Groups": [
    { "ConditionField": "ORDERS.ORDER_ID", "Direction": "NoSortOrder" }
  ],
  "Areas": [
    {
      "Kind": "Detail",
      "Sections": [
        {
          "Height": 240,
          "Objects": [
            {
              "Name": "LineDescription",
              "Kind": "Field",
              "Bounds": { "Left": 598, "Top": 0, "Width": 9737, "Height": 180 },
              "FontName": "Arial",
              "FontSizePt": 9,
              "FontBold": false,
              "CanGrow": true,
              "DataSource": "{ORDER_LINES.DESCRIPTION}"
            }
          ]
        }
      ]
    }
  ]
}

<ItemGroup>
  <Reference Include="Reporter.Db.Postgres">
    <HintPath>providers/Reporter.Db.Postgres.dll</HintPath>
  </Reference>
</ItemGroup>

dotnet add package Npgsql --no-restore
dotnet restore --packages ./packages-cache

IDbProvider provider = new PostgresProvider();
string connection = Environment.GetEnvironmentVariable("REPORTS_DB")!;

ReportModel model = ReportModelBuilder.FromRpt("orders.rpt");

// Values arrive as text and are coerced to each parameter's declared type.
IReadOnlyDictionary<string, FormulaValue> parameters = ParameterBinding.Resolve(
    model,
    new Dictionary<string, string> { ["CUSTOMER_ID"] = "100234" });

// The row source builds the report's own query: links, join order, pruning, and the
// record selection pushed down to the server. Parameters bind, never interpolate.
var rows = new DbRowSource(
    () => provider.Open(connection),
    provider.Dialect,
    provider.PrepareCommand,
    provider.ReadValue);

model = ReportDataBinder.Bind(model, rows, parameters, "orders.rpt");
PaginatedDocument doc = Paginator.Paginate(model, new PdfTextMeasurer(), Locale.EnGb, parameters);
PdfRenderer.RenderToFile(doc, model, "orders.pdf");

IDbProvider provider = new OracleProvider();

// Any connection string the managed driver accepts, for example:
//   User Id=reports;Password=...;Data Source=db.internal:1521/ORCLPDB1
//   User Id=reports;Password=...;Data Source=REPORTS;TNS_ADMIN=/etc/oracle
//   User Id=reports;Password=...;Data Source=REPORTS_TCPS;TNS_ADMIN=/etc/oracle;WALLET_LOCATION=/etc/oracle/wallet
string connection = Environment.GetEnvironmentVariable("REPORTS_DB")!;

ReportModel model = ReportModelBuilder.FromRpt("statement.rpt");
IReadOnlyDictionary<string, FormulaValue> parameters = ParameterBinding.Resolve(
    model,
    new Dictionary<string, string> { ["ACCOUNT_ID"] = "40018" });

var rows = new DbRowSource(
    () => provider.Open(connection),
    provider.Dialect,
    provider.PrepareCommand,
    provider.ReadValue);

model = ReportDataBinder.Bind(model, rows, parameters, "statement.rpt");
PaginatedDocument doc = Paginator.Paginate(model, new PdfTextMeasurer(), Locale.EnGb, parameters);
PdfRenderer.RenderToFile(doc, model, "statement.pdf");

IDbProvider provider = new SqliteProvider();

// The database is one file. Read-only, so a mistyped path fails rather than creating an empty one.
string connection = "Data Source=/var/data/sales.db;Mode=ReadOnly";

ReportModel model = ReportModelBuilder.FromRpt("sales.rpt");
IReadOnlyDictionary<string, FormulaValue> parameters = ParameterBinding.Resolve(
    model,
    new Dictionary<string, string> { ["REGION"] = "North" });

var rows = new DbRowSource(
    () => provider.Open(connection),
    provider.Dialect,
    provider.PrepareCommand,
    provider.ReadValue);

model = ReportDataBinder.Bind(model, rows, parameters, "sales.rpt");
PaginatedDocument doc = Paginator.Paginate(model, new PdfTextMeasurer(), Locale.EnGb, parameters);
PdfRenderer.RenderToFile(doc, model, "sales.pdf");

ReportModel model = ReportModelBuilder.FromRpt("command-report.rpt");
IReadOnlyDictionary<string, FormulaValue> parameters = ParameterBinding.Resolve(
    model, new Dictionary<string, string>());

// Replace these fictional rows with results from your own parameterized query.
// Column names must match the report's ALIAS.FIELD names, without braces.
var data = new SavedRows(
    [new SavedColumn("Command.ORDER_ID", FieldValueType.String),
     new SavedColumn("Command.AMOUNT", FieldValueType.Number)],
    [["ORD-1001", "125.00"], ["ORD-1002", "79.50"]]);
model = ReportDataBinder.Bind(model, new CommandRows(data), parameters, "command-report.rpt");
PaginatedDocument document = Paginator.Paginate(model, new PdfTextMeasurer(), Locale.EnGb, parameters);
PdfRenderer.RenderToFile(document, model, "out.pdf");

sealed class CommandRows(SavedRows rows) : IRowSource
{
    public RowFetch Fetch(ReportModel report, IReadOnlyDictionary<string, FormulaValue> parameters) =>
        new(rows, SelectionApplied: false);
}

WebApplicationBuilder builder = WebApplication.CreateBuilder(args);
WebApplication app = builder.Build();

IDbProvider provider = new PostgresProvider();
string connection = builder.Configuration.GetConnectionString("Reports")!;

// Parse the .rpt once. Binding returns a new model, so the parsed one is never changed.
ReportModel invoice = ReportModelBuilder.FromRpt("Reports/invoice.rpt");

app.MapGet("/invoices/{id}.pdf", (string id) =>
{
    IReadOnlyDictionary<string, FormulaValue> parameters;
    try
    {
        parameters = ParameterBinding.Resolve(invoice, new Dictionary<string, string> { ["INVOICE_ID"] = id });
    }
    catch (FormatException)
    {
        return Results.BadRequest();
    }

    var rows = new DbRowSource(
        () => provider.Open(connection),
        provider.Dialect,
        provider.PrepareCommand,
        provider.ReadValue);
    try
    {
        ReportModel bound = ReportDataBinder.Bind(invoice, rows, parameters, "invoice.rpt");
        PaginatedDocument doc = Paginator.Paginate(bound, new PdfTextMeasurer(), Locale.EnGb, parameters);

        var pdf = new MemoryStream();
        PdfRenderer.Render(doc, bound, pdf);
        pdf.Position = 0;
        return Results.File(pdf, "application/pdf", $"invoice-{id}.pdf");
    }
    catch (ReportDataException ex)
    {
        // A driver can quote part of the connection string back in its message.
        app.Logger.LogError("invoice {Id}: {Error}", id, ConnectionSecrets.Redact(ex.Message, connection));
        return Results.StatusCode(StatusCodes.Status502BadGateway);
    }
});

app.Run();

VerificationReport report = DataSourceVerifier.Verify(
    model,
    () => provider.Open(connection),
    provider.Dialect,
    parameters,
    provider.PrepareCommand);

foreach (VerificationCheck check in report.Checks)
{
    Console.WriteLine($"{check.Outcome,-8} {check.Name}: {ConnectionSecrets.Redact(check.Detail, connection)}");
}
return report.Passed ? 0 : 1;

// The engine reads REPORTER_LICENSE, then reporter.lic beside the application.
// To keep the file somewhere else, point the engine at it once, at startup:
LicenseInfo licence = ReporterLicense.SetFile("/run/secrets/reporter.lic");
if (!licence.IsLicensed)
{
    Console.Error.WriteLine($"Reporter is unlicensed ({licence.Code}): {licence.Reason}");
}