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. IronTesseract automatically leverages all available threads across multiple cores, 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.

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

• Automatic CPU core utilization: IronOCR detects and uses all available cores without manual configuration
• Thread-safe operations: All OCR operations are designed to be thread-safe by default
• Optimized resource management: Memory and processing resources are efficiently allocated across threads
• 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

For advanced scenarios requiring fast OCR configuration, developers can fine-tune the multithreading behavior to match specific performance requirements while maintaining accuracy.

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.