C# Async & Multithreading Support with IronOCR

Introduction

Processing large volumes of text data efficiently requires both accuracy and speed for OCR operations. This article covers async support and multithreading in IronOCR and Tesseract. Asynchronous programming enables non-blocking OCR execution, keeping applications responsive during text recognition tasks. Multithreading provides parallelism to significantly boost OCR performance. These techniques help developers improve the efficiency and responsiveness of OCR-powered applications.

Quickstart: Use ReadAsync for Effortless Async OCR

Use IronTesseract's ReadAsync method to perform OCR without blocking your main thread. This quickly adds responsive, non-blocking OCR to your application. It works particularly well when processing PDF documents or handling multiple image files simultaneously.

How Does Multithreading Work in IronOCR?

IronOCR enhances image processing and OCR reading efficiency through seamless multithreading, requiring no specialized API from developers to get started. IronTesseract automatically leverages all available threads across multiple cores by default, optimizing system resources for swift OCR execution. This built-in multithreading simplifies development and significantly boosts performance by integrating parallelism directly into the OCR workflow. When you need to bound that parallelism - on a memory-capped container or a shared host, for example - see the section on controlling parallelism and memory usage below.

The library's multithreaded Tesseract implementation provides these key advantages:

• Automatic CPU core utilization: IronOCR detects and uses all available cores without manual configuration, and lets you cap that with MaxDegreeOfParallelism when you need to
• Thread-safe operations: OCR operations are thread-safe, and a single IronTesseract instance can be shared safely across concurrent reads
• Tunable memory footprint: Each page read in parallel uses its own native Tesseract engine, so peak memory scales with the degree of parallelism - lower it to trade throughput for a smaller working set
• Scalable performance: Processing time decreases proportionally with the number of available cores

Here is a multithreaded read example in C#:

:path=/static-assets/ocr/content-code-examples/how-to/async-simple-multithreading.cs

using IronOcr;
using System;

var ocr = new IronTesseract();

using (var input = new OcrPdfInput(@"example.pdf"))
{
    var result = ocr.Read(input);
    Console.WriteLine(result.Text);
};

Imports IronOcr
Imports System

Private ocr = New IronTesseract()

Using input = New OcrPdfInput("example.pdf")
	Dim result = ocr.Read(input)
	Console.WriteLine(result.Text)
End Using

Two properties on IronTesseract let you fine-tune this behavior to match specific performance and memory requirements, covered in the next section. For a different optimization axis - trading a little accuracy for raw speed - see fast OCR configuration.

How Do I Control Parallelism and Memory Usage?

By default, IronTesseract reads as many pages concurrently as the machine has CPU cores, and each concurrent page runs its own native Tesseract engine. Two properties let you bound that when memory matters more than raw throughput:

• MaxDegreeOfParallelism caps how many pages are OCR'd concurrently within a single Read call. Because each concurrent page costs one engine, lowering it directly lowers peak memory.
• MultiThreaded turns parallel reading off entirely when set to false, giving the lowest and most predictable footprint. It takes precedence over MaxDegreeOfParallelism.

using IronOcr;

var ocr = new IronTesseract
{
    Language = OcrLanguage.English,
    MaxDegreeOfParallelism = 2 // OCR at most 2 pages at once per Read
};

using var input = new OcrInput();
input.LoadPdf("invoice.pdf");
var result = ocr.Read(input);

using IronOcr;

var ocr = new IronTesseract
{
    Language = OcrLanguage.English,
    MaxDegreeOfParallelism = 2 // OCR at most 2 pages at once per Read
};

using var input = new OcrInput();
input.LoadPdf("invoice.pdf");
var result = ocr.Read(input);

IRON VB CONVERTER ERROR developers@ironsoftware.com

For default values, the precedence rules between the two properties, guidance on choosing a value, and details of the resolved AccessViolationException in high-volume parallel OCR, see how to limit parallel OCR memory usage.

How Do I Use Async Support in IronOCR?

Asynchronous programming optimizes OCR performance by allowing developers to execute OCR tasks without blocking the main thread. This keeps applications responsive while processing large documents or images for text recognition. Async support enables the system to handle other tasks while OCR operations run in the background. This capability is crucial when implementing OCR progress tracking in user interfaces.

This section covers async support integration in IronOCR, demonstrating different methods to make OCR services non-blocking. IronOCR's async capabilities ensure optimal performance for both desktop applications requiring responsiveness during OCR operations and web services handling multiple concurrent OCR requests.

:path=/static-assets/ocr/content-code-examples/how-to/async-ocrtask.cs

using IronOcr;

IronTesseract ocr = new IronTesseract();

OcrPdfInput largePdf = new OcrPdfInput("chapter1.pdf");

Func<OcrResult> reader = () =>
{
    return ocr.Read(largePdf);
};

OcrReadTask readTask = new OcrReadTask(reader.Invoke);
// Start the OCR task asynchronously
readTask.Start();

// Continue with other tasks while OCR is in progress
DoOtherTasks();

// Wait for the OCR task to complete and retrieve the result
OcrResult result = await Task.Run(() => readTask.Result);

Console.Write($"##### OCR RESULTS ###### \n {result.Text}");

largePdf.Dispose();
readTask.Dispose();

static void DoOtherTasks()
{
    // Simulate other tasks being performed while OCR is in progress
    Console.WriteLine("Performing other tasks...");
    Thread.Sleep(2000); // Simulating work for 2000 milliseconds
}

Imports Microsoft.VisualBasic
Imports IronOcr

Private ocr As New IronTesseract()

Private largePdf As New OcrPdfInput("chapter1.pdf")

Private reader As Func(Of OcrResult) = Function()
	Return ocr.Read(largePdf)
End Function

Private readTask As New OcrReadTask(AddressOf reader.Invoke)
' Start the OCR task asynchronously
readTask.Start()

' Continue with other tasks while OCR is in progress
DoOtherTasks()

' Wait for the OCR task to complete and retrieve the result
Dim result As OcrResult = Await Task.Run(Function() readTask.Result)

Console.Write($"##### OCR RESULTS ###### " & vbLf & " {result.Text}")

largePdf.Dispose()
readTask.Dispose()

'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'static void DoOtherTasks()
'{
'	' Simulate other tasks being performed while OCR is in progress
'	Console.WriteLine("Performing other tasks...");
'	Thread.Sleep(2000); ' Simulating work for 2000 milliseconds
'}

:path=/static-assets/ocr/content-code-examples/how-to/async-read-async.cs

using IronOcr;
using System;
using System.Threading.Tasks;

IronTesseract ocr = new IronTesseract();

using (OcrPdfInput largePdf = new OcrPdfInput("PDFs/example.pdf"))
{
    var result = await ocr.ReadAsync(largePdf);
    DoOtherTasks();
    Console.Write($"##### OCR RESULTS ###### " +
                $"\n {result.Text}");
}

static void DoOtherTasks()
{
    // Simulate other tasks being performed while OCR is in progress
    Console.WriteLine("Performing other tasks...");
    System.Threading.Thread.Sleep(2000); // Simulating work for 2000 milliseconds
}

Imports Microsoft.VisualBasic
Imports IronOcr
Imports System
Imports System.Threading.Tasks

Private ocr As New IronTesseract()

Using largePdf As New OcrPdfInput("PDFs/example.pdf")
	Dim result = Await ocr.ReadAsync(largePdf)
	DoOtherTasks()
	Console.Write($"##### OCR RESULTS ###### " & $vbLf & " {result.Text}")
End Using

'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'static void DoOtherTasks()
'{
'	' Simulate other tasks being performed while OCR is in progress
'	Console.WriteLine("Performing other tasks...");
'	System.Threading.Thread.Sleep(2000); ' Simulating work for 2000 milliseconds
'}

Why Should I Use Async and Multithreading with IronOCR?

Combining async support and multithreading in IronOCR provides numerous benefits for modern application development:

Performance Benefits:

• Improved Throughput: Process multiple documents simultaneously without blocking
• Better Resource Utilization: Maximize CPU usage across all available cores
• Reduced Latency: Start processing immediately without waiting for previous operations to complete
• Scalable Architecture: Handle increasing workloads without architectural changes

Development Benefits:

• Simplified Code: No need to manage threads manually - IronOCR handles the complexity
• Modern Patterns: Full support for async/await patterns in Tesseract 5 for .NET
• Easy Integration: Works seamlessly with existing .NET async infrastructure
• Maintainable Solutions: Clear, readable code that follows .NET best practices

Multithreading in IronOCR optimizes OCR tasks significantly. The built-in multithreading capabilities, combined with methods like ReadAsync(), simplify handling large volumes of text data. This combination ensures applications remain responsive and efficient, making IronOCR an effective tool for creating high-performance software with streamlined text recognition capabilities. To get started with the complete feature set, check our NuGet package installation guide.