ZXing.Net vs IronBarcode: C# Barcode Library Comparison

The Stateful Reader Architecture

ZXing.Net's BarcodeReader requires a new instance for each thread or parallel operation. The following pattern shows the minimum correct setup for concurrent processing:

// ZXing.Net: must create a new reader per thread — not safe to share
Parallel.ForEach(imagePaths, path =>
{
    var reader = new BarcodeReader();               // new instance per iteration
    reader.Options.PossibleFormats = new List<BarcodeFormat>
    {
        BarcodeFormat.QR_CODE,
        BarcodeFormat.CODE_128,
        BarcodeFormat.EAN_13
    };

    using var bitmap = new Bitmap(path);
    var result = reader.Decode(bitmap);

    if (result != null)
        results[path] = result.Text;
});

// ZXing.Net: must create a new reader per thread — not safe to share
Parallel.ForEach(imagePaths, path =>
{
    var reader = new BarcodeReader();               // new instance per iteration
    reader.Options.PossibleFormats = new List<BarcodeFormat>
    {
        BarcodeFormat.QR_CODE,
        BarcodeFormat.CODE_128,
        BarcodeFormat.EAN_13
    };

    using var bitmap = new Bitmap(path);
    var result = reader.Decode(bitmap);

    if (result != null)
        results[path] = result.Text;
});

Imports ZXing
Imports System.Drawing
Imports System.Threading.Tasks

' ZXing.Net: must create a new reader per thread — not safe to share
Parallel.ForEach(imagePaths, Sub(path)
    Dim reader = New BarcodeReader() ' new instance per iteration
    reader.Options.PossibleFormats = New List(Of BarcodeFormat) From {
        BarcodeFormat.QR_CODE,
        BarcodeFormat.CODE_128,
        BarcodeFormat.EAN_13
    }

    Using bitmap As New Bitmap(path)
        Dim result = reader.Decode(bitmap)

        If result IsNot Nothing Then
            results(path) = result.Text
        End If
    End Using
End Sub)

The ThreadLocal<BarcodeReader> pattern reduces per-call allocation by reusing one instance per thread, but adds disposal complexity. Either way, thread safety is the caller's responsibility in ZXing.Net, not the library's.

Detailed Feature Comparison

ZXing.Net Approach

ZXing.Net's BarcodeReader is a stateful object. When Decode is called, internal state is written. If two threads share the same instance, those writes race. The results are non-deterministic: you may get a result from a different image, a null where a barcode exists, or an exception. The correct approach is to create one reader per thread — meaning every parallel or async path allocates a reader, configures it, uses it once, and discards it:

// ZXing.Net: new reader instance required per parallel operation
Parallel.ForEach(imagePaths, path =>
{
    var reader = new BarcodeReader();
    reader.Options.PossibleFormats = new List<BarcodeFormat>
    {
        BarcodeFormat.QR_CODE,
        BarcodeFormat.CODE_128,
        BarcodeFormat.EAN_13
    };

    using var bitmap = new Bitmap(path);
    var result = reader.Decode(bitmap);

    if (result != null)
        results[path] = result.Text;
});

// ZXing.Net: new reader instance required per parallel operation
Parallel.ForEach(imagePaths, path =>
{
    var reader = new BarcodeReader();
    reader.Options.PossibleFormats = new List<BarcodeFormat>
    {
        BarcodeFormat.QR_CODE,
        BarcodeFormat.CODE_128,
        BarcodeFormat.EAN_13
    };

    using var bitmap = new Bitmap(path);
    var result = reader.Decode(bitmap);

    if (result != null)
        results[path] = result.Text;
});

Imports ZXing
Imports System.Drawing
Imports System.Threading.Tasks

' ZXing.Net: new reader instance required per parallel operation
Parallel.ForEach(imagePaths, Sub(path)
    Dim reader = New BarcodeReader()
    reader.Options.PossibleFormats = New List(Of BarcodeFormat) From {
        BarcodeFormat.QR_CODE,
        BarcodeFormat.CODE_128,
        BarcodeFormat.EAN_13
    }

    Using bitmap As New Bitmap(path)
        Dim result = reader.Decode(bitmap)

        If result IsNot Nothing Then
            results(path) = result.Text
        End If
    End Using
End Sub)

The ThreadLocal<BarcodeReader> pattern reduces per-call allocation by reusing one reader per thread, but it adds disposal complexity and still requires format configuration on each instance.

IronBarcode Approach

IronBarcode's BarcodeReader.Read is a stateless static method. There is no instance to share, no instance to isolate, and no configuration state to protect. The same call runs safely from any number of concurrent threads:

// IronBarcode: static method, thread-safe, no instance management
var options = new BarcodeReaderOptions
{
    Speed = ReadingSpeed.Balanced,
    ExpectMultipleBarcodes = true,
    MaxParallelThreads = 4
};

Parallel.ForEach(imagePaths, path =>
{
    var result = BarcodeReader.Read(path, options).FirstOrDefault();
    if (result != null)
        results[path] = result.Value;
});

// IronBarcode: static method, thread-safe, no instance management
var options = new BarcodeReaderOptions
{
    Speed = ReadingSpeed.Balanced,
    ExpectMultipleBarcodes = true,
    MaxParallelThreads = 4
};

Parallel.ForEach(imagePaths, path =>
{
    var result = BarcodeReader.Read(path, options).FirstOrDefault();
    if (result != null)
        results[path] = result.Value;
});

Imports System.Threading.Tasks
Imports IronBarcode

' IronBarcode: static method, thread-safe, no instance management
Dim options As New BarcodeReaderOptions With {
    .Speed = ReadingSpeed.Balanced,
    .ExpectMultipleBarcodes = True,
    .MaxParallelThreads = 4
}

Parallel.ForEach(imagePaths, Sub(path)
    Dim result = BarcodeReader.Read(path, options).FirstOrDefault()
    If result IsNot Nothing Then
        results(path) = result.Value
    End If
End Sub)

IronBarcode's async and multithreaded barcode reading documentation explains the internal thread pooling model. The MaxParallelThreads property controls the degree of parallelism without requiring external coordination.

ZXing.Net Approach

ZXing.Net requires reader.Options.PossibleFormats to be populated before each decode. If a barcode format is not listed, it will not be detected — with no error, no warning, and no partial result:

// ZXing.Net: format list required — unlisted formats produce null, not an error
var reader = new BarcodeReader();
reader.Options.PossibleFormats = new List<BarcodeFormat>
{
    BarcodeFormat.QR_CODE,
    BarcodeFormat.CODE_128,
    BarcodeFormat.CODE_39,
    BarcodeFormat.EAN_13,
    BarcodeFormat.EAN_8,
    BarcodeFormat.UPC_A,
    BarcodeFormat.DATA_MATRIX,
    BarcodeFormat.PDF_417
    // An Aztec barcode in the same image will return null silently.
};
reader.Options.TryHarder = true;

using var bitmap = new Bitmap(imagePath);
var results = reader.DecodeMultiple(bitmap);

// ZXing.Net: format list required — unlisted formats produce null, not an error
var reader = new BarcodeReader();
reader.Options.PossibleFormats = new List<BarcodeFormat>
{
    BarcodeFormat.QR_CODE,
    BarcodeFormat.CODE_128,
    BarcodeFormat.CODE_39,
    BarcodeFormat.EAN_13,
    BarcodeFormat.EAN_8,
    BarcodeFormat.UPC_A,
    BarcodeFormat.DATA_MATRIX,
    BarcodeFormat.PDF_417
    // An Aztec barcode in the same image will return null silently.
};
reader.Options.TryHarder = true;

using var bitmap = new Bitmap(imagePath);
var results = reader.DecodeMultiple(bitmap);

Imports ZXing
Imports ZXing.Common

' ZXing.Net: format list required — unlisted formats produce null, not an error
Dim reader As New BarcodeReader()
reader.Options.PossibleFormats = New List(Of BarcodeFormat) From {
    BarcodeFormat.QR_CODE,
    BarcodeFormat.CODE_128,
    BarcodeFormat.CODE_39,
    BarcodeFormat.EAN_13,
    BarcodeFormat.EAN_8,
    BarcodeFormat.UPC_A,
    BarcodeFormat.DATA_MATRIX,
    BarcodeFormat.PDF_417
    ' An Aztec barcode in the same image will return null silently.
}
reader.Options.TryHarder = True

Using bitmap As New Bitmap(imagePath)
    Dim results = reader.DecodeMultiple(bitmap)
End Using

If every format is listed to avoid misses, performance degrades. If only expected formats are listed, silent misses become a risk when images arrive from external sources. There is no mechanism for ZXing.Net to report that it found a barcode in an unlisted format.

IronBarcode Approach

IronBarcode detects all 50+ supported formats automatically. No format list is required or accepted:

// IronBarcode: no format list — all 50+ formats detected automatically
var results = BarcodeReader.Read(imagePath);
foreach (var barcode in results)
{
    Console.WriteLine($"{barcode.Value} ({barcode.Format})");
}

// IronBarcode: no format list — all 50+ formats detected automatically
var results = BarcodeReader.Read(imagePath);
foreach (var barcode in results)
{
    Console.WriteLine($"{barcode.Value} ({barcode.Format})");
}

Imports IronBarcode

' IronBarcode: no format list — all 50+ formats detected automatically
Dim results = BarcodeReader.Read(imagePath)
For Each barcode In results
    Console.WriteLine($"{barcode.Value} ({barcode.Format})")
Next

For applications that tune reading speed against detection thoroughness, IronBarcode exposes a ReadingSpeed enum — Faster, Balanced, Detailed, ExtremeDetail — without requiring format enumeration. Speed tuning affects how aggressively the engine processes each image, not which formats it considers.

ZXing.Net Approach

When a barcode arrives embedded in a PDF, ZXing.Net requires an external PDF rendering library. The most common workaround uses PdfiumViewer, which adds approximately 20 MB of native binaries and a page rendering loop that callers must implement and maintain:

// ZXing.Net: PDF requires PdfiumViewer + a render loop per page
using var pdfDocument = PdfDocument.Load(pdfPath);

var reader = new BarcodeReader();
reader.Options.PossibleFormats = new List<BarcodeFormat>
{
    BarcodeFormat.QR_CODE,
    BarcodeFormat.CODE_128,
    BarcodeFormat.PDF_417
};

for (int i = 0; i < pdfDocument.PageCount; i++)
{
    string tempPath = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.png");
    try
    {
        using var pageImage = pdfDocument.Render(i, 200, 200, PdfRenderFlags.CorrectFromDpi);
        pageImage.Save(tempPath, ImageFormat.Png);

        using var bitmap = new Bitmap(tempPath);
        var decoded = reader.DecodeMultiple(bitmap);
        if (decoded != null)
            results.AddRange(decoded.Select(d => d.Text));
    }
    finally
    {
        File.Delete(tempPath);
    }
}

// ZXing.Net: PDF requires PdfiumViewer + a render loop per page
using var pdfDocument = PdfDocument.Load(pdfPath);

var reader = new BarcodeReader();
reader.Options.PossibleFormats = new List<BarcodeFormat>
{
    BarcodeFormat.QR_CODE,
    BarcodeFormat.CODE_128,
    BarcodeFormat.PDF_417
};

for (int i = 0; i < pdfDocument.PageCount; i++)
{
    string tempPath = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.png");
    try
    {
        using var pageImage = pdfDocument.Render(i, 200, 200, PdfRenderFlags.CorrectFromDpi);
        pageImage.Save(tempPath, ImageFormat.Png);

        using var bitmap = new Bitmap(tempPath);
        var decoded = reader.DecodeMultiple(bitmap);
        if (decoded != null)
            results.AddRange(decoded.Select(d => d.Text));
    }
    finally
    {
        File.Delete(tempPath);
    }
}

Imports PdfiumViewer
Imports ZXing
Imports System.Drawing
Imports System.Drawing.Imaging
Imports System.IO

Using pdfDocument = PdfDocument.Load(pdfPath)

    Dim reader = New BarcodeReader()
    reader.Options.PossibleFormats = New List(Of BarcodeFormat) From {
        BarcodeFormat.QR_CODE,
        BarcodeFormat.CODE_128,
        BarcodeFormat.PDF_417
    }

    For i As Integer = 0 To pdfDocument.PageCount - 1
        Dim tempPath As String = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.png")
        Try
            Using pageImage = pdfDocument.Render(i, 200, 200, PdfRenderFlags.CorrectFromDpi)
                pageImage.Save(tempPath, ImageFormat.Png)

                Using bitmap = New Bitmap(tempPath)
                    Dim decoded = reader.DecodeMultiple(bitmap)
                    If decoded IsNot Nothing Then
                        results.AddRange(decoded.Select(Function(d) d.Text))
                    End If
                End Using
            End Using
        Finally
            File.Delete(tempPath)
        End Try
    Next
End Using

This pattern has real failure modes: DPI misconfiguration causes silent misses, temp file permissions fail in locked-down environments, the PdfiumViewer native libraries require separate deployment management, and the setup does not work on Linux without additional configuration.

IronBarcode Approach

IronBarcode reads barcodes from PDFs natively — all pages, all formats, no external dependencies. The same BarcodeReader.Read call accepts PDF paths directly:

// IronBarcode: one call, all pages, native PDF support
var results = BarcodeReader.Read("invoice.pdf");
foreach (var barcode in results)
    Console.WriteLine($"Page {barcode.PageNumber}: {barcode.Value}");

// IronBarcode: one call, all pages, native PDF support
var results = BarcodeReader.Read("invoice.pdf");
foreach (var barcode in results)
    Console.WriteLine($"Page {barcode.PageNumber}: {barcode.Value}");

Imports IronBarcode

' IronBarcode: one call, all pages, native PDF support
Dim results = BarcodeReader.Read("invoice.pdf")
For Each barcode In results
    Console.WriteLine($"Page {barcode.PageNumber}: {barcode.Value}")
Next

No page enumeration, no DPI configuration, no temp files, and no separate library to deploy alongside the application.

ZXing.Net Approach

The core ZXing.Net package provides decoding logic but no image loading. Callers must choose a binding based on their deployment target:

The practical consequence is that Windows code using System.Drawing.Bitmap does not compile or run on Linux. Containerisation requires switching binding packages and rewriting image-loading code:

// Windows path — does not compile or run on Linux
using ZXing.Windows.Compatibility;
using System.Drawing;

var reader = new BarcodeReader();
using var bitmap = new Bitmap(imagePath);
var result = reader.Decode(bitmap);

// Windows path — does not compile or run on Linux
using ZXing.Windows.Compatibility;
using System.Drawing;

var reader = new BarcodeReader();
using var bitmap = new Bitmap(imagePath);
var result = reader.Decode(bitmap);

Imports ZXing.Windows.Compatibility
Imports System.Drawing

Dim reader As New BarcodeReader()
Using bitmap As New Bitmap(imagePath)
    Dim result = reader.Decode(bitmap)
End Using

// Linux / cross-platform path — different package, different API
using ZXing.ImageSharp;
using SixLabors.ImageSharp;
using SixLabors.ImageSharp.PixelFormats;

var reader = new BarcodeReader<Rgba32>();
using var image = Image.Load<Rgba32>(imagePath);
var result = reader.Decode(image);

// Linux / cross-platform path — different package, different API
using ZXing.ImageSharp;
using SixLabors.ImageSharp;
using SixLabors.ImageSharp.PixelFormats;

var reader = new BarcodeReader<Rgba32>();
using var image = Image.Load<Rgba32>(imagePath);
var result = reader.Decode(image);

Imports ZXing.ImageSharp
Imports SixLabors.ImageSharp
Imports SixLabors.ImageSharp.PixelFormats

Dim reader As New BarcodeReader(Of Rgba32)()
Using image As Image(Of Rgba32) = Image.Load(Of Rgba32)(imagePath)
    Dim result = reader.Decode(image)
End Using

Using the Windows binding on a Linux host also requires libgdiplus in the Docker image, adding approximately 50 MB to the container.

IronBarcode Approach

IronBarcode ships one package for all platforms. The same BarcodeReader.Read(path) call compiles and runs identically on Windows, Linux, macOS, and inside Docker containers. No binding packages, no platform conditionals, and no additional system dependencies are required. For teams containerising .NET applications, the IronBarcode Docker and Linux setup guide covers the single-package deployment pattern in detail.

ZXing.Net Approach

ZXing.Net's BarcodeWriter class creates a writer object, accepts encoding options, calls Write, and returns a Bitmap that callers must save manually using System.Drawing.Imaging:

// ZXing.Net: create writer, set options, call Write, save Bitmap manually
using ZXing;
using ZXing.Common;
using ZXing.Windows.Compatibility;
using System.Drawing.Imaging;

var writer = new BarcodeWriter
{
    Format = BarcodeFormat.CODE_128,
    Options = new EncodingOptions
    {
        Width = 300,
        Height = 100,
        Margin = 10
    }
};

using var bitmap = writer.Write("PRODUCT-001");
bitmap.Save("output.png", ImageFormat.Png);

// ZXing.Net: create writer, set options, call Write, save Bitmap manually
using ZXing;
using ZXing.Common;
using ZXing.Windows.Compatibility;
using System.Drawing.Imaging;

var writer = new BarcodeWriter
{
    Format = BarcodeFormat.CODE_128,
    Options = new EncodingOptions
    {
        Width = 300,
        Height = 100,
        Margin = 10
    }
};

using var bitmap = writer.Write("PRODUCT-001");
bitmap.Save("output.png", ImageFormat.Png);

Imports ZXing
Imports ZXing.Common
Imports ZXing.Windows.Compatibility
Imports System.Drawing.Imaging

Dim writer As New BarcodeWriter With {
    .Format = BarcodeFormat.CODE_128,
    .Options = New EncodingOptions With {
        .Width = 300,
        .Height = 100,
        .Margin = 10
    }
}

Using bitmap = writer.Write("PRODUCT-001")
    bitmap.Save("output.png", ImageFormat.Png)
End Using

Saving to formats other than PNG or JPEG, saving to a PDF, or producing binary output for an HTTP response all require additional System.Drawing plumbing that the caller implements.

IronBarcode Approach

IronBarcode's BarcodeWriter.CreateBarcode returns a GeneratedBarcode object that provides built-in output methods through a fluent chain:

// IronBarcode: create and save in one fluent chain
BarcodeWriter.CreateBarcode("PRODUCT-001", BarcodeEncoding.Code128)
    .ResizeTo(300, 100)
    .SaveAsPng("output.png");

// IronBarcode: create and save in one fluent chain
BarcodeWriter.CreateBarcode("PRODUCT-001", BarcodeEncoding.Code128)
    .ResizeTo(300, 100)
    .SaveAsPng("output.png");

Imports IronBarCode

' IronBarcode: create and save in one fluent chain
BarcodeWriter.CreateBarcode("PRODUCT-001", BarcodeEncoding.Code128) _
    .ResizeTo(300, 100) _
    .SaveAsPng("output.png")

The GeneratedBarcode object also exposes .ToPngBinaryData(), .ToJpegBinaryData(), .ToStream(), and .SaveAsPdf() — output targets that ZXing.Net requires callers to implement themselves using System.Drawing.

Concurrent and High-Throughput Processing

A ZXing.Net integration that works correctly in a single-threaded console application can exhibit non-deterministic behaviour when the same code is moved into an ASP.NET Core controller handling concurrent requests, or into a background job that processes batches in parallel. The per-thread instance pattern that ZXing.Net requires means that every request or parallel task allocates a full reader object with its configured decoder set, uses it once, and discards it. As request volume grows, this allocation pressure becomes measurable. Teams that reach this point — particularly those running high-throughput scanning pipelines in logistics, warehousing, or document processing — often look for a library whose threading model does not impose this overhead on every caller.

Mixed-Format Document Scanning

Applications that accept documents from third parties frequently encounter barcode formats that were not anticipated when the format list was configured. A shipping integration built for Code 128 receives a shipment from a partner using QR codes. A medical records system configured for PDF 417 encounters Data Matrix symbologies from a new equipment vendor. In ZXing.Net, each of these cases produces a silent null rather than a decode error, meaning the miss may not surface until downstream processing fails. Teams that have been burned by silent format misses — particularly in contexts where a missed barcode has business consequences — begin to weigh the cost of format list maintenance against a library that detects formats automatically.

PDF Barcode Extraction

Many business documents arrive as PDFs: invoices, shipping manifests, patient records, compliance certificates. ZXing.Net cannot read these directly. Teams that need to extract barcodes from PDFs end up building and maintaining a rendering pipeline on top of ZXing.Net — selecting a PDF library, managing its native dependencies, implementing a page render loop, handling DPI configuration, and writing cleanup logic for temporary files. That infrastructure code is not barcode logic; it exists solely to bridge the gap between what ZXing.Net accepts (bitmaps) and what business documents actually are (PDFs). Teams that find themselves maintaining this bridge — especially when the PDF library itself has its own licensing, deployment, and platform considerations — often prefer a single library that handles the full input surface.

Reducing Binding Complexity

Projects that start on Windows and later deploy to Linux or Docker encounter ZXing.Net's binding fragmentation directly: the Windows binding package uses a different API from the cross-platform ImageSharp binding, and switching between them requires changing both the NuGet references and the image-loading code. Teams that containerise their .NET applications as a matter of practice, or that run the same codebase on developer machines (Windows or macOS) and production servers (Linux), find that maintaining two code paths for image loading adds friction to every future change in the scanning layer.

BarcodeReader Instantiation Removal

Every new BarcodeReader() call in the codebase is removed during migration. The instantiation pattern — reader creation, format configuration, image loading, decode call — collapses into a single static method call. Files that import ZXing, ZXing.Common, ZXing.Windows.Compatibility, ZXing.ImageSharp, and SixLabors.ImageSharp namespaces have those imports removed and replaced with a single using IronBarCode;.

PossibleFormats Configuration Removal

The reader.Options.PossibleFormats assignment block is deleted at each call site. IronBarcode performs automatic format detection and does not accept a format restriction list. The TryHarder flag is replaced by the ReadingSpeed property on BarcodeReaderOptions, which controls detection effort without narrowing the format scope.

Binding Package Cleanup

Migration removes ZXing.Net, ZXing.Net.Bindings.Windows, ZXing.Net.Bindings.ImageSharp, and any PdfiumViewer packages that were added to support PDF reading. If libgdiplus was added to a Dockerfile to support System.Drawing through the Windows binding on Linux, that line is also removed. IronBarcode requires no platform-specific dependencies in the Docker image.