DEV Community: combit Software

A European Alternative to Crystal Reports

Pius Richter — Tue, 08 Sep 2026 13:19:06 +0000

We're seeing more and more satisfied customers switching to us from SAP Crystal Reports (a reporting solution that is no longer being developed).

For many software teams, Crystal Reports is not just a reporting tool. It is years of templates, invoices, labels, PDFs, customer-specific layouts, and “please don’t touch this” legacy code.

That is why replacing it is hard.

Why Teams Start Looking Beyond Crystal Reports

The usual pain points are familiar:

fragile deployment
runtime dependencies that are easy to break
security issues/no more security patches
no Linux/iOS support
designers detached from the application
limited flexibility when customers want to adjust reports themselves
and migration projects that look risky because no one wants to rebuild hundreds of reports by hand.

There is also the bigger question: do you really want your reporting stack tied to an old workflow while the rest of your application moves forward?

A Reporting Component Built for Developers → List & Label by combit

That is where we can offer a solution—List & Label.

List & Label is a cross-platform reporting component for developers who want reporting to be part of their own application, not a separate world bolted onto it.

It integrates into .NET, with C# in Visual Studio (and other DLL/API-compatible environments), so teams keep control over the user experience and architecture.

Migration Without Starting From Zero

A practical reason to look at List & Label as a Crystal Reports alternative is migration.

List & Label includes a customizable Crystal Reports converter in the Professional and Enterprise editions. It can transfer Crystal Reports content directly into List & Label, including standard areas and groupings, and comes with C# source code so teams can adapt the converter to their own setup.

That matters because real-world reporting is never clean. Reports contain conventions, exceptions, formatting rules, and business logic that has grown over time.

An adaptable migration path is much more useful than a “one-size-fits-all” promise.

Easier Deployment & Modern Reporting Features

List & Label also reduces development friction. It supports xcopy deployment, so no special database drivers or complex setup routines are needed. In many cases, the required files can simply be copied with the application. That makes deployment easier to understand, automate, and support.

The product also covers what teams expect from a mature reporting solution: rich designer objects, many export formats, more than 30 data providers, custom data provider support, web controls, different viewer controls, and a Report Server option for web, cloud, and REST API scenarios.

A Designer Inside Your Application

For end users, the integrated report designer is a major difference. Instead of opening a separate tool or process, the designer can become a first-class part of your application. Users work with reports where they already work, while you decide which functionality they can access.

Why the European Alternative Matters

And for European software companies, there is another reason to care: List & Label's manufacturer combit is based in Germany. For teams that prefer a European vendor and a reporting partner closer to their regulatory and procurement context, List & Label is a serious alternative to consider. Read more about this here:
List & Label—the European reporting alternative.

Moving Reporting Forward

Switching reporting tools is not something anyone does for fun.

But if Crystal Reports has become a source of deployment pain, technical debt, or product friction, List & Label gives developers a migration path, an embeddable designer, flexible deployment, web and cloud options, and a European vendor behind it.

You do not have to rebuild your reporting strategy from scratch. You can move it forward.

Visit this site for further informations or to get the free List & Label trial: Alternative to Crystal Reports.

How to Let Users Customize Reports Without Shipping New Code

Pius Richter — Thu, 03 Sep 2026 14:39:35 +0000

Reports often start simple: export a table, generate an invoice, create a PDF.

Then real users arrive.

Finance wants a different invoice layout. Operations needs grouped tables. A customer asks for custom fields. Someone wants Excel instead of PDF. Suddenly, every report change becomes a development task.

That does not scale.

A better approach is to separate report data from report layout. Your application still controls the data, permissions, and business rules. The visual structure can live in configurable templates.

Why hard-coded reports become painful

Hard-coded reports are fine for one fixed output. They become expensive when users need variations:

different layouts per customer
localized labels
custom columns
PDF and Excel exports
frequent layout changes

Each small change means code changes, testing, deployment, and another ticket.

A better pattern: controlled customization

Instead of rebuilding reports every time, expose the data users are allowed to use and let trusted users adjust the layout.

A typical workflow looks like this:

Your application provides structured data.
A report template defines the layout.
A designer lets users edit fields, tables, labels, and charts.
The application previews, prints, or exports the result.

This keeps business logic in code while moving presentation changes into templates.

Where List & Label fits

List & Label is a report generator for developers who want to add reporting, printing, preview, export, and report design features to their own applications.

For .NET teams, the Report Designer can be integrated into the application itself. Users can adjust templates without leaving the product, while developers still control which data is available and how it is secured.

That makes it useful for invoices, forms, printable lists, dashboards, PDF exports, Excel exports, and user-editable reports.

When it makes sense

Embedding a report designer is probably overkill for one static PDF.

But if users regularly ask for layout changes, custom fields, export options, or customer-specific reports, a designer-based approach can save engineering time.

The idea is simple: do not ship new code for every report layout change. Give users safe, controlled flexibility instead.

For .NET applications that need embedded report design, List & Label is one option worth evaluating.

Have a look at the free Online Demo or get the free trial to get started.

Integrated and automated MySQL database reporting for your application

Pius Richter — Tue, 28 Jul 2026 14:07:47 +0000

Reporting from MySQL data often starts simple: run a query, export the table and send the result as file. But as soon as users need filtered views, charts, drilldowns, scheduled exports, or editable report layouts, hardcoded reporting logic becomes a maintenance problem.

Embedded MySQL database reporting

List & Label approaches this as an embedded reporting layer for developers. Instead of building report design, preview, export, and distribution workflows from scratch, you can connect your application directly to a MySQL database and use List & Label’s integrated Designer to create reports from tables, views, stored procedures, or custom SQL commands.

The integration works through the MySqlConnectionDataProvider, which binds MySQL data to a ListLabel object. From there, the Designer can expose the connected database structure and let developers - or even end users, depending on the application setup - build report templates visually.

Interactive reports

Once connected, reports can go beyond static tables. List & Label supports interactive elements such as report parameters, drilldowns, expandable regions, sortable columns and objects like charts, crosstabs, barcodes, PDFs, subreports, master-detail layouts and much more. That makes it suitable for dashboards, operational reports, invoices, analytics views, and customer-facing exports.

Automate your MySQL database reports

Automation is another key part of the workflow. Reports can be exported to formats such as PDF, Excel, Word, PowerPoint, HTML, JSON, XML, CSV, and a lot of image formats. They can also be distributed by email through SMTP, Microsoft Graph API, Simple MAPI, or XMAPI and with ZIP packaging available when needed.

Benefits for developers

For developers, the main benefit is control. The application keeps ownership of the data pipeline, database connection, security model, and report logic, while List & Label handles the reporting layer: design, preview, rendering, export, and distribution.

In short

MySQL reporting does not have to mean manually generating files or rebuilding the same export logic again and again. With an embedded reporting tool like List & Label, MySQL data can become integrated, interactive, and automated reporting directly inside your application.

Read the full guide, which includes a code example showing how to create reports from MySQL databases using List & Label.

Oracle Database Reporting Tool

Pius Richter — Wed, 22 Oct 2025 07:24:24 +0000

Developers working with Oracle databases often need to generate dashboards, printable reports, exports, or user-editable templates from structured data.

While Oracle Reports remains a known option, it's no longer actively developed. For .NET developers seeking a modern alternative, List & Label is one reporting tool that integrates with Oracle using standard components and libraries.

This article outlines how it works and shows limitations and benefits.

If you would like to test Oracle database reporting with List & Label, get the free trial linked at the end of this article.

How to Generate Reports Using List & Label

How to Connect and Query Oracle Data

List & Label connects directly to Oracle databases, making it possible to evaluate data stored in tables, views, sql statements or returned by executing stored procedures. As a reporting tool with relational database support, it also enables features like drilldown and drill-through for deeper data exploration.

To connect to an Oracle database, List & Label uses the OracleConnectionDataProvider class from the combit.Reporting.DataProviders namespace. This requires the Oracle.ManagedDataAccess NuGet package, which provides access to Oracle's ODP.NET (Oracle Data Provider for .NET). Once set up, the entire Oracle database - including tables and views - can be queried. The code example below shows the steps for establishing the connection and launching the List & Label Designer to create a report.

// Step1: Adding the NuGet packages for List & Label and Oracle 
// and the necessary using statements
using combit.Reporting;
using combit.Reporting.DataProviders;
using Oracle.ManagedDataAccess.Client;

// Step 2: Preparing the connection information for the Oracle database
OracleConnectionStringBuilder oracleConnectionStringBuilder =
    new OracleConnectionStringBuilder
    {
        DataSource = Properties.Resources.OracleInstance,
        UserID = Properties.Resources.OracleUsername,
        Password = Properties.Resources.OraclePassword,
        PersistSecurityInfo = true
    };

// Step 3: Connecting the Oracle connection with the appropriate List & Label data provider 
OracleConnectionDataProvider oracleDataProvider = 
    new OracleConnectionDataProvider(
        oracleConnectionStringBuilder.ConnectionString,
        "HR"
        );

// Step 4: Creating the List & Label object, adding the Oracle data provider 
// and calling the Designer 
using (ListLabel LL = new ListLabel())
{
    LL.DataSource = oracleDataProvider;
    LL.Design();
}

💡Tip: The article Using the DbCommandSetDataProvider With Stored Procedures shows how easy it is to access stored procedures in an Oracle database. These can then be used as data sources for reports. This also works with Oracle databases. If necessary, just use additional individual SQL statements in the process.

Features and Benefits of Oracle DB Reporting with List & Label

Native Oracle Database Integration via ODP.NET

Advantage: Uses Oracle’s own managed data provider (Oracle.ManagedDataAccess via NuGet).

Benefit: No need for custom drivers or data abstraction layers. Developers can connect directly to Oracle and access tables, views, stored procedures, or SQL statements.

OracleConnectionDataProvider in .NET

Advantage: Exposes Oracle schema as structured objects usable in the List & Label reporting engine.

Benefit: Enables both developers and end-users to select and visualize Oracle data in a report designer interface, without manual object mapping.

WYSIWYG Report Designer

Advantage: GUI-based editor supports tables, charts, barcodes, crosstabs, maps, gauges, subreports and more designer objects.

Benefit: End-users (non-devs) can create or update report templates without needing code changes or development cycles.

Multi-format Export Engine

Advantage: Supports PDF (including ZUGFeRD/XRechnung), Excel, Word, JSON, XML, HTML, CSV, PNG, and more.

Benefit: Reports can be distributed via email, stored as files, embedded in documents, or printed - covering most B2B and internal reporting use cases.

Multi-source Support

Advantage: In addition to Oracle, it supports 30+ other data providers including MSSQL, PostgreSQL, SQLite, CSV, JSON, REST, Entity Framework, and custom objects.

Benefit: Developers building applications with multiple backend systems can unify reporting in one tool, without switching engines.

Use Cases Where It’s Relevant

You need to replace or extend legacy Oracle Reports workflows.
You want to let users define their own layouts while keeping backend logic in Oracle.
You’re building .NET desktop or web apps and want to embed Oracle report generation.
You need to export structured Oracle data to industry formats (XLSX, PDF, JSON, etc.).

Limitations to Be Aware Of

List & Label is not open-source; licensing applies.
It requires a .NET-based development environment.
While Oracle-specific, the tool does not depend on Oracle Forms or Oracle APEX.

Summary

If you're searching for an Oracle database reporting tool that integrates directly with Oracle via ODP.NET, supports customizable templates with an powerful designer, and works well in .NET environments, List & Label is one practical option.

It covers typical developer needs - structured access, export options, and template control - without tying you to legacy tooling.

For technical docs or API details:
📖 Online .NET Help
📊 More about List & Label
🧪 Get free List & Label Trial

How to Build Fillable PDF Forms in .NET — Without Fighting the PDF Beast

Pius Richter — Thu, 18 Sep 2025 10:03:15 +0000

Create fully fillable PDF forms in .NET with the List & Label software component — fast, simple, and without extra tools.

⚡TL;DR

Edit existing PDF files or forms and add form elements. Or build a form from scratch.

Design forms visually in the report designer
Use form elements (text boxes, checkboxes etc.) in the form
Export directly to interactive PDF with just a few lines of C# code
No Acrobat Pro, no external PDF SDKs, List & Label uses its onw export engine
Supports compliance standards like PDF/A and ZUGFeRD e-invoices out of the box

👉 See how it works.

📝 Impractical and Poor PDF Files

🤦‍♂️Problem
You export a report or form to PDF. It looks nice… but your users can’t actually use it. No fields. No checkboxes. Just a flat file.

That’s frustrating for you and for your users.

😊Solution
List & Label fixes that. It lets you design your form visually with real, editable form elements and export it to PDF with just a few lines of code.

🚦 Getting Started Without the Complexity

If you're new to .NET or just dipping your toes into working with PDF exports, List & Label won’t overwhelm you.

You don’t need to learn PDF internals, wrestle with Acrobat, or deal with brittle third-party tools.

With List & Label, you can design, export, and test fillable PDF forms directly from your app visually and with just a few lines of code.

🛠️ First Steps: Try It in Your Own Project

Here’s how to get up and running:

1. Download & Install

Get the List & Label trial for free
Add the NuGet package
- Supports .NET Framework, .NET Core, and .NET 6–9

2. Open a sample project from GitHub

Browse the GitHub samples for WinForms, WPF, ASP.NET, or Blazor
Pick the one that matches your stack

3. Run & Explore

Run the sample to see how it connects to a data source
Open the Report Designer from the project

4. Use the Report Designer

Open a project file
Drag in a text field or checkbox
Save and export as PDF

Now your form has fillable fields.

5. Export from C#
Export is just a few lines of code — no Acrobat needed:

using (ListLabel LL = new ListLabel())
{
    // Define data source
    LL.DataSource = CreateDataSet();

    // Creating the export configuration (the target format here is PDF)
    ExportConfiguration exportConfiguration = new ExportConfiguration(LlExportTarget.Pdf, "<Dateipfad der PDF-Datei>", "<Dateipfad der Layout-Datei>");

    // Optional: show result
    exportConfiguration.ShowResult = false;

    // Export
    LL.Export(exportConfiguration);
}

6. Open your PDF and test the fields

You’ll now have a PDF your users can interact with — no printing or scanning required.

And it just works.
No third-party Acrobat software. No hand-coded layout logic.

👉 You're Not Alone:

Friendly community forum
Clear, well-organized documentation

✅ Stay Compliant with Zero Extra Effort

Working on invoices or anything long-term? List & Label supports:

PDF/A for archival-safe documents
ZUGFeRD for smart e-invoices (with structured XML baked into the PDF)

That’s compliance handled — no standards manual required.

💬What's next?

Get started with the free trial now
Or browse the PDF section in the Reporting Blog to discover more feature developments around the PDF format
Or leave a comment if you have any questions

New Features for the Web Report Designer in List & Label 28

Pius Richter — Mon, 13 Mar 2023 08:32:30 +0000

The Web Report Designer is a central element if you’re using List & Label in web applications. We’re constantly improving and adding to it, and with the release of version 28, we’ve added many new objects and functions again. Here’s a quick overview of the new features.

New Designer Objects

The following Designer objects are now supported since version 28 – both as standalone objects and also in tables:

Gauges, visualizing data as speedometers, thermometers, etc.
Data graphics, visualizing data as pictograms
Checkboxes, displaying true/false values
PDFs to use as background for forms, or more complex document parts that are available as PDF files

Pie Charts

Finally, pie charts can be created directly in the Web Report Designer, and being used as standalone objects as well as in tables. In order to achieve this, a completely new editing mode has been integrated into the Web Report Designer. This editing mode can be opened directly in the workspace, just using a separate button.

Other chart types are already in the making, and will be gradually integrated. Our goal is to transform the Web Report Designer into a fully-fledged, browser-based replacement for the previous Windows app-based Web Designer.

Repository

Provide the content of your repository with more structure and clarity. Folder structures are automatically supported now, without doing changes to existing implementations. Project files, but also additional files such as images, etc., can now be created and managed right within folder structures.

Table Editor

Create and move fields easily with drag & drop. Also, adjusting their properties got a lot easier and more convenient with the new table editor. Currently available are text fields, images, barcodes, checkboxes and PDF files. You can also insert data graphics, gauges, and charts really quick and easy.

Export Right from the Designer

Create your reports in the Designer and export right from there to check your layout on different output media.

Start Online Demo

If you like to take a closer look at the Web Report Designer in List & Label check out the interactive Online Demo.
Or directly get the free List & Label trial.

Creating reports from MariaDB databases

Pius Richter — Tue, 07 Feb 2023 09:26:48 +0000

Learn how to easily bind report generator List & Label to MariaDB data to create comprehensive reports and other output in various formats.

What is MariaDB?

MariaDB is a free relational database system created from a fork of MySQL. It is compatible with MySQL in almost all respects and can thus be connected in the same way.

Creating reports from MariaDB data sources

List & Label can be easily bound to MariaDB data. This allows you to create comprehensive reports based on your existing MariaDB data. Relational links are also supported, allowing you to drill down or drill through your data.

How can List & Label be linked to MariaDB data sources?

Since the release of version 28 in 2022, List & Label offers the MariaDBConnectionDataProvider.

A minimal sample for using the new provider would be:

using MariaDBConnectionDataProvider provider = new MariaDBConnectionDataProvider(
    $"server={address};userid={userid};password={password};database={database}")
{
    using ListLabel LL = new ListLabel();
    {
        LL.DataSource = provider;
        LL.Design();
    }
}

which gives the following result in the Designer:

If you do not want to provide all but only some tables in Designer, you can also use the DbCommandSetDataProvider to connect to MariaDB databases.

More about MariaDB and List & Label

You can also find more valuable information about using List & Label in the .NET Tutorial.

It doesn’t matter if you have a classic Windows desktop or a modern web application using ASP.NET - the List & Label data providers can be used in both worlds.

Want to see more or try it for yourself?

Have a look at the Online Demo or get the fully-functional List & Label trial if you want to try it yourself

Please leave a reply to this post if you have any questions about creating reports with List & Label based on data from MariaDB databases or if you are missing information on this topic.

Miscellaneous Treats in .NET Report Generator List & Label 27

Pius Richter — Tue, 24 May 2022 09:58:01 +0000

As with every version, there are way too many new features in version 27 to cover them all. So here’s a quick summary of some of the rather hidden gems that still deserve some attention.

Supporting Windows 11, Visual Studio 2022 and .NET 6
Parametrized data sources now support passing a “displayformula” option in order to set the displayed value for the auto generated parameter. This allows the use ID values for the parameter itself, while displaying a user friendly substitution.
The AskString$ and AskStringChoice$ dialogs are now resizable.
New barcode type added: Pharmacode
New image type added: SVGZ (compressed SVG)
Report parameters can now be validated via a regular expression.
The Drawing() function can receive a valid SVG string, which will be converted into an image on the fly, e.g. Drawing(‘’).
Lines are now exported as inline SVG files, when exporting to XHTML. Line styles are also partly supported, diagonal lines are no longer raster images.
The .NET component now automatically tries to decode Base64 encoded images, if they are defined e.g. via LL.Fields.Add(“MyBase64Image”, Base64String, LlFieldType.Drawing). Note: this feature requires the Base64 string to be padded to a multiple of four bytes with “=” as defined in RFC 4648.
If a preview contains input objects, the ribbon now provides two different PDF modes (PDF with input objects and PDF with input data as fixed text).
JPEG images with EXIF rotation information are automatically displayed correctly now.
The extended properties of 2D barcodes (Aztec, QRCode, DataMatrix, PDF417, MicroPDF417, Maxicode) are now accessible via DOM.
Pie charts now support a maximum segment count. All additional segments will then be summarized as “Others”. Before, there was only a minimum share, which was not flexible enough in cases where many segments had the same (small) share.
The HTML object now supports https for downloads.
VCL FireDac: the ExportOptions can now be set directly via the ExportOptions class.
VCL FireDac: simplified variant for setting options & print options
Crosstab label cells can now contain an image.

This wraps up the feature posts on version 27 – we’ll start blogging about the upcoming version 28 pretty soon. Stay tuned!

More New Features in List & Label 27

Creating Reports from Microsoft Access Databases with List & Label

Pius Richter — Wed, 19 Jan 2022 07:30:20 +0000

Create reports based on your existing Microsoft Access databases with the reporting component List & Label. See how it works here.

How to Create Reports with List & Label Using Data from Microsoft Access Databases

List & Label can be easily bound to Microsoft Access databases. This allows you to create comprehensive reports based on your existing Access data, whether it is in tables or stored procedures. Relational databases are also supported out of the box, enabling you to drill down or drill through your data.

Samples for Binding Microsoft Access Databases to List & Label

The OleDbConnection of the .NET Framework is used as a basis, which uses the Jet OleDb driver to access the Microsoft Access database.

Connect to Access Database

string databasePath = @"c:\temp\Northwind.mdb";
string connStr = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + databasePath;
OleDbConnection myOleDbConnection = new OleDbConnection(connStr);

Note: For 32-bit applications, the Jet OleDB driver can still be used. But for a 64-bit application, this driver reaches its limits and an alternative must be found. For this purpose, Microsoft itself offers the ACE OleDB driver, which is provided as the Microsoft Access Database Engine. Accordingly, connStr must be adapted as follows:

string databasePath = @"c:\temp\Northwind.mdb";
string connStr = "Provider=Microsoft.Jet.ACE.OLEDB.12.0;Data Source=" + databasePath;
OleDbConnection myOleDbConnection = new OleDbConnection(connStr);

Important: For successful installation and registration of the ACE OleDB driver, a suitable 64-bit Office installation is required on the target system.

Assign Data from Microsoft Access Database to List & Label

Once the appropriate connection has been provided using OleDbConnection, there are a number of ways to access the Microsoft Access database data.

Load the Data into an ADO DataSet

List & Label gets access to ADO objects with the help of the AdoDataProvider:

// Connect to the Microsoft Access database
string databasePath = @"c:\temp\Northwind.mdb";
string connStr = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + databasePath;
OleDbConnection oleDbConn = new OleDbConnection(connStr);
oleDbConn.Open();

DataSet ds = new System.Data.DataSet();

// Add table 'Customers' to the DataSet
string sqlCustomers = "SELECT * FROM [Customers]";
OleDbCommand commandCustomers = new OleDbCommand(sqlCustomers, oleDbConn);
OleDbDataAdapter daCustomers = new OleDbDataAdapter(commandCustomers);
daCustomers.FillSchema(ds, SchemaType.Source, "Customers");
daCustomers.Fill(ds, "Customers");

// Add table 'Orders' to the DataSet
string sqlOrders = "SELECT * FROM [Orders]";
OleDbCommand commandOrders = new OleDbCommand(sqlOrders, oleDbConn);
OleDbDataAdapter daOrders = new OleDbDataAdapter(commandOrders);
daOrders.FillSchema(ds, SchemaType.Source, "Orders");
daOrders.Fill(ds, "Orders");

// Define relation between tables
string relName = "Customers2Orders";
ds.Relations.Add(new DataRelation(relName, "CustomerId", "CustomerId"));

// Create the List & Label object and attach the ADO DataSet
// and call the designer
using(ListLabel LL = new ListLabel())
{
    LL.DataSource = new AdoDataProvider(ds);
    LL.Design();
}

Load Data Directly as `IDbCommand`

With the help of DbCommandSetDataProvider List & Label has direct access to the data via IDbCommand. The advantage of this variant is that the data is not loaded into memory in advance as it is the case with the DataSet, especially with very large databases this is important:

// Connect to the Microsoft Access database
string databasePath = @"c:\temp\Northwind.mdb";
string connStr = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + databasePath;
OleDbConnection oleDbConn = new OleDbConnection(connStr);
oleDbConn.Open();

DbCommandSetDataProvider provider = new DbCommandSetDataProvider();

// Add table 'Customers' to the DataSet
string sqlCustomers = "SELECT * FROM [Customers]";
OleDbCommand commandCustomers = new OleDbCommand(sqlCustomers, oleDbConn);
provider.AddCommand(commandCustomers, "Customers");

// Add table 'Orders'
string sqlOrders = "SELECT * FROM [Orders]";
OleDbCommand commandOrders = new OleDbCommand(sqlOrders, oleDbConn);
provider.AddCommand(commandOrders , "Orders");

// Define relation between tables
string relName = "Customers2Orders";
provider.AddRelation(relName, "Customers", "Orders", "CustomerID", "CustomerID");

// Create the List & Label object and attach the ADO DataSet
// and call the designer
using(ListLabel LL = new ListLabel())
{
    LL.DataSource = provider;
    LL.Design();
}

More about Microsoft Access Reporting and List & Label

Also see the .NET Tutorial for even more valuable information on using List & Label.

It doesn’t matter if you have a classic Windows desktop application or a modern web application with ASP.NET - the List & Label data providers can be used in both worlds.

Tip: The installation of List & Label already delivers numerous programming samples that use Microsoft Access databases as data sources. These can also be viewed in our GitHub repository.

Please leave a reply to this post if you’ve got questions about how to create reports with List & Label based on data from Microsoft Access databases or if you miss any information about this topic.

If you already enjoy connecting Microsoft Access databases as datasource to List & Label for creating amazing reports, feel free to show your love with a heart for this post. 💖 🙂

Creating Charts via Drag & Drop in the Desktop Designer

Pius Richter — Tue, 18 Jan 2022 13:47:04 +0000

tl;dr List & Label is a reporting component for software developers and improved the Drag & Drop support for charts in the desktop designer. Check out the example below to see how it works.

List & Label’s chart dialog offers a load of possible customizations. However, as always, with great power comes great complexity. Even creating a simple pie chart could have taken some time if you’re not yet familiar with List & Label’s chart features. As you can already easily create crosstabs via Drag & Drop, and we just recently improved the table’s drag & drop features, offering a thorough D&D support for charts was the next logical step on our path to a simpler, more intuitive end user desktop designer.

For a quick walkthrough, let’s start with a simple pie chart in our demo application – the distribution of customers by country. Simply drag the Customers.Country field to the workspace and drop it there.

This brings up the following choices:

Note the last entry, which is new to List & Label 27. In the next step, you choose the chart type directly in the workspace:

As we’re happy with the default for this case – that’s all. The preview shows the result:

As a more complicated example, let’s compare the sales for the different regions EMEA, NAFTA and APAC through the years. To create this, just drag Sales.Year and drop it on the workspace. Choose “Bar” and “Clustered”. As we already have aggregated values in the EMEA, NAFA and APAC fields of the database, we want to create the values by series. So let’s choose this.

Now, simply create the series by dropping the APAC, EMEA and NAFTA fields into the designated area. After that, here’s what the workspace looks like:

Of course, you still need to tweak sometimes – as for example, the years have two digits here, as they aren’t integer fields in the database. Of course, the dialog with all its properties is always still available to the rescue. Simply double-click the chart to bring up the dialog. Take note of the new, (hopefully) helpful tooltip while you’re there:

We’ve added these to a number of places to highlight often overlooked features. You can immediately apply this new knowledge and click on one of the year labels in the dialog’s preview, in order to get to the coordinate value and edit its format property:

Which (after doing the same tweak for the y-Axis) results in:

We’re pretty sure this new feature makes the creation of your charts much easier and intuitive.

Visit our Reporting Blog to find out more about topics that keep us busy.

Creating EPC Barcodes with Report Generator List & Label

Pius Richter — Thu, 28 Oct 2021 12:20:47 +0000

What is an EPC Barcode?

An EPC QR code is a data format standardized by the European Payments Council that contains all the data for a SEPA credit transfer and is machine-readable via QR coding. A brief description of the format can be found here:

The European Payments Council (EPC) Quick Response (QR) code is a technical standard by the European Payments Council. It uses a QR code containing all the necessary information for initiating a SEPA credit transfer (SCT). It is commonly used on invoices and payment requests in the countries that support it.

View on Wikipedia>

Procedure - How to Create Barcodes With List & Label

With List & Label you can easily create such a barcode by encoding the content according to the standard. A formula for such a barcode would be:

Barcode(
/* Service tag */
"BCD"+chr$(13)+
/* Version */
"002"+chr$(13)+
/* Character set */
"2" +chr$(13)+
/* SEPA Credit Transfer */
"SCT" +chr$(13)+
/* Recipient's BIC */
"GENODE61RAD"+chr$(13)+
/* Recipient's name */
"combit GmbH"+chr$(13)+
/* Recipient's IBAN */
"DE36692910000214809206"+chr$(13)+
/* Amount */
"EUR0.01"+chr$(13)+
/* Purpose, optional */
"CHAR" +chr$(13)+
/* Reference */
"" +chr$(13)+
/* Reason */
"Charity for combit"+chr$(13)+
/* Hint */
"Hint", 
"QRCode"
)

The resulting barcode can then be scanned in all common applications:

If you have any questions, please leave a comment.
Want to test it yourself? Get a free trial of List & Label.

Revisiting C# Script Performance

Pius Richter — Wed, 13 Oct 2021 14:18:02 +0000

This is another often overlooked feature in our reporting tool List & Label – you can add scripts to your projects and use your favorite language to do so. Since a couple of versions already, List & Label supports C# Scripts. However, the performance was less than perfect, making it a good choice for complex calculations but not so much for using it on a line-to-line base. In List & Label 26, we were able to push the performance quite remarkably – now using scripts is perfectly feasible.

One reason why many people overlook the scripting feature is that it is opt-in. For security reasons, we decided to default the availability to false. Switching it on is just a matter of setting the option LL_OPTION_SCRIPTENGINE_ENABLED (index 276) to 1. Let’s do a quick walkthrough, using the “order list with scripting” sample report of the demo application. It displays the order number, order and delivery date and a script-powered calculation of the number of working days between those two dates.

The last column in the report just reads:

ScriptVal ("CSharpScript", LoadFile$ (ProjectPath$() + "WorkingDays.cs"))

That means, load the WorkingDays.cs script from within the project path and return its value. So let’s dig into the script. The crucial part is the Main() method:

static void Main() { var workDayCalc = new WorkingDaysCalculator(); WScript.Result = workDayCalc.Calculate(Report.Field("Orders.OrderDate"), Report.Field("Orders.ShippedDate")); }

The WorkingDaysCalculator is just a simple class to calculate the working days in a quite simple manner. The more interesting part is the usage of the Report object that’s added dynamically. It has a couple of methods:

Method name	Purpose
Eval	Evaluates a full List & Label formula, based on the provided fields and variables at the time of evaluation-aligned
Variable	Gets the value of a variable
Field	Gets the value of a field
SetVar	Sets a variable in the report that can later be retrieved by using GetVar() outside of the script
GetVar	Gets a variable from the report that was set earlier by using SetVar() outside of the script

Using these methods, you can easily interact with the report and your data. And by setting WScript.Result, you can return a value for the ScriptVal function as shown above.

Additionally, there is also the possibility of debugging your scripts. All you have to do is add the line

at the very beginning of the script. This will automatically include the following code at the start of the Main() method which will start a suitable debugger (if there is one installed on your system), attach it to the LL process, and break before any of the actual code gets executed.

System.Diagnostics.Debugger.Launch();
if (System.Diagnostics.Debugger.IsAttached)
{
System.Diagnostics.Debugger.Break();
}

Looking forward to seeing more usage of this hidden gem in the future :-).

Please leave a comment if you have any questions. Or just visit our blog to get to know us a bit better.