Table of Contents

List & Label Cross Platform

List & Label Cross Platform (LLCP) is a modern, cross-platform reporting engine for .NET applications. It enables server-side and cloud-ready report generation on Linux, macOS, and Windows using a unified API and JSON-based project files.

LLCP is designed for automated, scalable report generation and integrates seamlessly into backend services, containers, and CI/CD pipelines.

When to use List & Label Cross Platform

LLCP is a strong choice if your application requires:

  • Server-side or background report generation
  • Deployment on Linux, macOS, Windows, or in containers
  • Integration into cloud or microservice architectures
  • Version-controlled report definitions (JSON-based project files)
  • High-performance export to PDF, images, and other formats
Note

LLCP focuses on rendering and exporting reports, not on interactive design-time workflows. Report design is typically done using the classic List & Label Designer.

When NOT to use List & Label Cross Platform

LLCP is not the right choice if you need:

  • Interactive report design within your application
    LLCP does not include an embedded designer. Report templates must be created using the classic Windows-based List & Label Designer.

  • End-user preview dialogs or print functionality
    LLCP produces output files (PDF, PNG, etc.) but does not provide interactive preview windows or direct printer access.

  • Full Windows Classic Edition feature parity
    Some advanced features, specialized components, or legacy APIs from the Classic Edition are not available in LLCP.

  • Client-side or desktop-first applications
    If your application runs primarily on Windows desktops with interactive user workflows, the Classic Edition may be more appropriate.

Important

Evaluate whether your application requires interactive components or Windows-specific features before migrating to LLCP. If you're uncertain, test a representative subset of your reports using the migration path described in Migrating from Classic Edition.

Choosing between Classic Edition and Cross Platform

Use this table to evaluate which edition fits your requirements:

Criterion Classic Edition Cross Platform
Deployment platform Windows only Linux, macOS, Windows
Interactive designer Embedded designer available Requires external designer
Preview & printing Native preview dialogs, direct printing File export only (PDF, PNG, etc.)
Project file format Custom (.lst, .lbl, etc.) JSON (.json)
Rendering engine GDI+, Windows APIs SkiaSharp (cross-platform)
Scalability Requires Windows licensing per instance Horizontal scaling in containers
Cloud deployment Limited (Windows containers only) Optimized for Linux containers, cloud-native
Feature set Complete feature set Core reporting features (see limitations below)

Key limitations in Cross Platform

The following features from Classic Edition are not available in LLCP:

  • Embedded report designer control
  • Interactive print and preview dialogs
  • Direct printer access
  • Some specialized object types or advanced layout features (consult documentation for specific objects and features)
Note

If your application requires interactive components or relies on Windows-specific features, start with the Classic Edition. If you're building a new server-side or cloud-native reporting solution, LLCP is the recommended choice.

What LLCP is - and what it is not

  • Automated PDF or image generation
  • Batch processing of large report volumes
  • Headless server or cloud environments
  • Cross-platform .NET applications
  • Scalable microservice architectures

Design choices and limitations

LLCP shares the core reporting concepts of List & Label but differs intentionally in architecture:

  • JSON-based project files replace binary formats for better version control and tooling support
  • Skia-based rendering provides consistent cross-platform output without platform-specific graphics dependencies
  • Server-side focus eliminates interactive UI components to reduce complexity and improve reliability
  • Automated pipeline handles layout, measurement, and optimization internally without manual tuning

These architectural decisions optimize LLCP for automated, scalable workflows but constrain its use in scenarios requiring interactive components.

Architecture overview

LLCP is built around a Skia-based rendering pipeline and JSON project files, making it independent of platform-specific graphics APIs and enabling consistent output across all supported platforms.

A typical LLCP workflow:

.NET Application
      |
      | (Data binding via IDataProvider)
      |
List & Label Cross Platform API
      |
      | (Loads JSON project definition)
      |
Layout & Rendering Engine
      |
      | (SkiaSharp for cross-platform graphics)
      |
Export Pipeline
      |
Output (PDF, PNG, SVG, ...)

Why this architecture?

Cross-platform consistency
By using SkiaSharp instead of platform-specific graphics APIs (like GDI+ on Windows), LLCP produces identical output regardless of host operating system.

Infrastructure as Code
JSON-based project files can be version-controlled, diffed, and processed by standard tooling, unlike binary formats.

Automated optimization
The rendering pipeline handles text measurement, layout calculation, and caching internally. Applications benefit from these optimizations without configuration.

Scalability by design
The stateless, headless architecture allows horizontal scaling and containerized deployment without session management or desktop environment dependencies.

Getting started

This tutorial demonstrates how to get started with List & Label Cross Platform and covers both basic usage and selected advanced topics.

You will learn how to:

  • install LLCP via NuGet
  • create and configure a ListLabel instance
  • provide data to reports
  • export reports
  • enable logging and troubleshoot issues
  • migrate existing project files

First steps

Installation via NuGet

To install List & Label Cross Platform, add a package reference to the combit.ListLabel31.CrossPlatform package from nuget.org:


dotnet add package combit.ListLabel31.CrossPlatform

Creating an instance of ListLabel

After installing the package, create an instance of the ListLabel class:

ListLabel listLabel = new ListLabel
{
DataSource = GetNorthwindDataSet(),
AutoProjectFile = projectFilePath,
LicensingInfo = "..."
};

Explanation:

  • DataSource
    Assigns a supported data source. See Providing data.

  • AutoProjectFile
    Specifies the report project file.
    Repository-based projects can be referenced using repository://<repositoryId>.

  • LicensingInfo
    Provides the licensing information required to use List & Label.

Exporting a report

Once configured, export the report using an export configuration:

ExportConfiguration exportConfiguration =
new ExportConfiguration(LlExportTarget.Pdf, exportFilePath, projectFilePath);

exportConfiguration.ShowResult = true;
listLabel.Export(exportConfiguration);

Explanation:

  • ExportConfiguration
    Defines the export target, output location, and project file.

  • ShowResult
    Controls whether the result is displayed after exporting.

  • Export
    Executes the export process.

Performance considerations

LLCP is built around a modern, fully automated rendering pipeline. Performance-critical operations—text measurement, layout evaluation, and rendering optimizations—are handled internally by the engine without requiring manual configuration.

What LLCP optimizes

The rendering engine automatically manages:

  • Text measurement and layout calculation
    Font metrics and text reflow are computed once and cached across rendering passes.

  • Complex vector graphics and path effects
    SkiaSharp's GPU-accelerated rendering pipeline processes vector operations efficiently.

  • Reuse of intermediate results
    Layout calculations and rendering state are preserved when possible to avoid redundant work.

When to expect good performance

LLCP typically delivers predictable, high throughput in:

  • Server-side report generation with well-defined resource limits
  • Batch processing where reports use consistent templates
  • Containerized deployments with horizontal scaling
  • Scenarios requiring consistent cross-platform output

Advanced topics

Logging

Logging is essential for monitoring and troubleshooting report generation.

A basic setup using the built-in DebwinLogger:

using DebwinLogger logger =
new DebwinLogger("path/to/logfile.log", LogLevel.Info);

listLabel.Logger = logger;
Note

For advanced logging scenarios (for example Serilog integration), see Debugging and troubleshooting.

Migrating existing project files

If you are transitioning from the Windows Classic Edition, review the migration guide carefully.

Important steps:

  • Remove unsupported objects, or apply conditional logic using the virtual identifier LL.IsCrossPlatform to implement workarounds
  • Review layout and rendering differences
  • Test all reports after conversion

See Migrating from Classic Edition.

Redistribution and deployment

When redistributing applications using LLCP:

  • Ensure all required NuGet packages are included
  • On Linux, reference SkiaSharp.NativeAssets.Linux

For cloud and container scenarios, see the Deployment guides.

Complete example

using DebwinLogger logger =
new DebwinLogger(@"c:\logs\debwin4.log", LogLevel.Info);

ListLabel listLabel = new ListLabel
{
Logger = logger,
DataSource = GetNorthwindDataSet(),
AutoProjectFile = projectFilePath,
LicensingInfo = "..."
};

ExportConfiguration exportConfiguration =
new ExportConfiguration(LlExportTarget.Pdf, exportFilePath, projectFilePath);

exportConfiguration.ShowResult = true;
listLabel.Export(exportConfiguration);
Note

Replace placeholders with your actual data source and file paths.

Additional resources