Migrating from TesseractOcrMaui to IronOCR

// TesseractOcrMaui: wired to MAUI host — cannot escape to a shared library
// This code compiles only inside a .NET MAUI application
public class OcrService
{
    private readonly ITesseract _tesseract; // resolved from MAUI DI — no other source exists

    public OcrService(ITesseract tesseract) { _tesseract = tesseract; }

    public async Task<string> ReadAsync(string imagePath)
    {
        await _tesseract.InitAsync("eng"); // traineddata must be bundled as MauiAsset
        var result = await _tesseract.RecognizeTextAsync(imagePath);
        return result.Success ? result.RecognizedText : string.Empty;
    }
    // Cannot reference this class from ASP.NET Core, Azure Functions, or Docker
}

Imports System.Threading.Tasks

' TesseractOcrMaui: wired to MAUI host — cannot escape to a shared library
' This code compiles only inside a .NET MAUI application
Public Class OcrService
    Private ReadOnly _tesseract As ITesseract ' resolved from MAUI DI — no other source exists

    Public Sub New(tesseract As ITesseract)
        _tesseract = tesseract
    End Sub

    Public Async Function ReadAsync(imagePath As String) As Task(Of String)
        Await _tesseract.InitAsync("eng") ' traineddata must be bundled as MauiAsset
        Dim result = Await _tesseract.RecognizeTextAsync(imagePath)
        Return If(result.Success, result.RecognizedText, String.Empty)
    End Function
    ' Cannot reference this class from ASP.NET Core, Azure Functions, or Docker
End Class

// IronOCR: plain instantiable class — compiles in any .NET project type
public class OcrService
{
    private readonly IronTesseract _ocr = new IronTesseract(); // no DI, no MAUI host

    public string Read(string imagePath)
    {
        using var input = new OcrInput();
        input.LoadImage(imagePath);
        return _ocr.Read(input).Text;
    }
    // Place this in a netstandard2.1 library — reference from MAUI, API, and Functions together
}

Imports IronOcr

Public Class OcrService
    Private ReadOnly _ocr As New IronTesseract() ' no DI, no MAUI host

    Public Function Read(imagePath As String) As String
        Using input As New OcrInput()
            input.LoadImage(imagePath)
            Return _ocr.Read(input).Text
        End Using
    End Function
    ' Place this in a netstandard2.1 library — reference from MAUI, API, and Functions together
End Class

dotnet remove package TesseractOcrMaui

// Before (TesseractOcrMaui)
using TesseractOcrMaui;
using TesseractOcrMaui.Results;
using Microsoft.Maui.Storage;

// After (IronOCR)
using IronOcr;

Imports IronOcr

IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";

IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY"

// MauiProgram.cs — OCR engine registered here; nowhere else resolves it
public static class MauiProgram
{
    public static MauiApp CreateMauiApp()
    {
        var builder = MauiApp.CreateBuilder();
        builder.UseMauiApp<App>();

        // Binds OCR to MAUI DI — no standalone path exists after this
        builder.Services.AddTesseractOcr();

        return builder.Build();
    }
}

// Any class that needs OCR must receive ITesseract from the MAUI container
public class InvoicePageViewModel
{
    private readonly ITesseract _tesseract;

    public InvoicePageViewModel(ITesseract tesseract)
    {
        _tesseract = tesseract; // fails to construct outside MAUI host
    }

    public async Task<string> ScanInvoiceAsync(string imagePath)
    {
        await _tesseract.InitAsync("eng");
        var result = await _tesseract.RecognizeTextAsync(imagePath);
        return result.RecognizedText ?? string.Empty;
    }
}

Imports Microsoft.Maui
Imports Microsoft.Extensions.DependencyInjection

' MauiProgram.vb — OCR engine registered here; nowhere else resolves it
Public Module MauiProgram
    Public Function CreateMauiApp() As MauiApp
        Dim builder = MauiApp.CreateBuilder()
        builder.UseMauiApp(Of App)()

        ' Binds OCR to MAUI DI — no standalone path exists after this
        builder.Services.AddTesseractOcr()

        Return builder.Build()
    End Function
End Module

' Any class that needs OCR must receive ITesseract from the MAUI container
Public Class InvoicePageViewModel
    Private ReadOnly _tesseract As ITesseract

    Public Sub New(tesseract As ITesseract)
        _tesseract = tesseract ' fails to construct outside MAUI host
    End Sub

    Public Async Function ScanInvoiceAsync(imagePath As String) As Task(Of String)
        Await _tesseract.InitAsync("eng")
        Dim result = Await _tesseract.RecognizeTextAsync(imagePath)
        Return If(result.RecognizedText, String.Empty)
    End Function
End Class

// MauiProgram.cs — license only; no DI registration needed
public static class MauiProgram
{
    public static MauiApp CreateMauiApp()
    {
        var builder = MauiApp.CreateBuilder();
        builder.UseMauiApp<App>();

        // One-line initialization — works for all project types
        IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";

        return builder.Build();
    }
}

// No constructor injection needed — IronTesseract instantiates directly
public class InvoicePageViewModel
{
    public string ScanInvoice(string imagePath)
    {
        var ocr = new IronTesseract();
        using var input = new OcrInput();
        input.LoadImage(imagePath);
        return ocr.Read(input).Text;
    }
}

Imports Microsoft.Maui
Imports IronOcr

Public Module MauiProgram
    Public Function CreateMauiApp() As MauiApp
        Dim builder = MauiApp.CreateBuilder()
        builder.UseMauiApp(Of App)()

        ' One-line initialization — works for all project types
        IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY"

        Return builder.Build()
    End Function
End Module

Public Class InvoicePageViewModel
    Public Function ScanInvoice(imagePath As String) As String
        Dim ocr = New IronTesseract()
        Using input As New OcrInput()
            input.LoadImage(imagePath)
            Return ocr.Read(input).Text
        End Using
    End Function
End Class

// This service CANNOT be extracted to a shared library.
// It compiles only in a project that references TesseractOcrMaui,
// which only has MAUI platform targets.
//
// Result: every non-MAUI project must use a different OCR library,
// duplicating language config, error handling, and accuracy tuning.

public class DocumentOcrService
{
    private readonly ITesseract _tesseract; // MAUI DI only

    public DocumentOcrService(ITesseract tesseract)
    {
        _tesseract = tesseract;
    }

    public async Task<string> ProcessDocumentAsync(string imagePath)
    {
        await _tesseract.InitAsync("eng");
        var result = await _tesseract.RecognizeTextAsync(imagePath);
        return result.Success ? result.RecognizedText : string.Empty;
    }
    // Server team writes their own version using a different library
    // Two codebases, two accuracy profiles, two maintenance tracks
}

Imports System.Threading.Tasks

' This service CANNOT be extracted to a shared library.
' It compiles only in a project that references TesseractOcrMaui,
' which only has MAUI platform targets.
'
' Result: every non-MAUI project must use a different OCR library,
' duplicating language config, error handling, and accuracy tuning.

Public Class DocumentOcrService
    Private ReadOnly _tesseract As ITesseract ' MAUI DI only

    Public Sub New(tesseract As ITesseract)
        _tesseract = tesseract
    End Sub

    Public Async Function ProcessDocumentAsync(imagePath As String) As Task(Of String)
        Await _tesseract.InitAsync("eng")
        Dim result = Await _tesseract.RecognizeTextAsync(imagePath)
        Return If(result.Success, result.RecognizedText, String.Empty)
    End Function
    ' Server team writes their own version using a different library
    ' Two codebases, two accuracy profiles, two maintenance tracks
End Class

// Place this in: MyCompany.OcrCore (net8.0 or netstandard2.1 class library)
// Reference from: MyCompany.MauiApp, MyCompany.Api, MyCompany.BatchWorker

using IronOcr;

namespace MyCompany.OcrCore
{
    public class DocumentOcrService
    {
        private readonly IronTesseract _ocr;

        public DocumentOcrService()
        {
            _ocr = new IronTesseract();
        }

        public string ProcessDocument(string imagePath)
        {
            using var input = new OcrInput();
            input.LoadImage(imagePath);
            input.Deskew();
            input.DeNoise();
            return _ocr.Read(input).Text;
        }

        public string ProcessDocumentFromBytes(byte[] imageData)
        {
            using var input = new OcrInput();
            input.LoadImage(imageData);
            input.Deskew();
            input.DeNoise();
            return _ocr.Read(input).Text;
        }

        public string ProcessDocumentFromStream(Stream imageStream)
        {
            using var input = new OcrInput();
            input.LoadImage(imageStream);
            return _ocr.Read(input).Text;
        }
    }
}

Imports IronOcr

Namespace MyCompany.OcrCore

    Public Class DocumentOcrService
        Private ReadOnly _ocr As IronTesseract

        Public Sub New()
            _ocr = New IronTesseract()
        End Sub

        Public Function ProcessDocument(imagePath As String) As String
            Using input As New OcrInput()
                input.LoadImage(imagePath)
                input.Deskew()
                input.DeNoise()
                Return _ocr.Read(input).Text
            End Using
        End Function

        Public Function ProcessDocumentFromBytes(imageData As Byte()) As String
            Using input As New OcrInput()
                input.LoadImage(imageData)
                input.Deskew()
                input.DeNoise()
                Return _ocr.Read(input).Text
            End Using
        End Function

        Public Function ProcessDocumentFromStream(imageStream As Stream) As String
            Using input As New OcrInput()
                input.LoadImage(imageStream)
                Return _ocr.Read(input).Text
            End Using
        End Function
    End Class

End Namespace

// ASP.NET Core Web API — TesseractOcrMaui CANNOT be used here.
// The package has no net8.0 or netstandard target.
// Referencing it produces: "The given project does not support targeting net8.0-ios/android/windows."
//
// Team is forced to add a second OCR library — Tesseract charlesw wrapper,
// a cloud API, or another solution — creating a split codebase.

[ApiController]
[Route("api/[controller]")]
public class DocumentsController : ControllerBase
{
    // Cannot inject ITesseract here — no MAUI host, no MAUI DI container
    // Must use a completely different OCR library for server-side processing
}

Imports Microsoft.AspNetCore.Mvc

' ASP.NET Core Web API — TesseractOcrMaui CANNOT be used here.
' The package has no net8.0 or netstandard target.
' Referencing it produces: "The given project does not support targeting net8.0-ios/android/windows."
'
' Team is forced to add a second OCR library — Tesseract charlesw wrapper,
' a cloud API, or another solution — creating a split codebase.

<ApiController>
<Route("api/[controller]")>
Public Class DocumentsController
    Inherits ControllerBase

    ' Cannot inject ITesseract here — no MAUI host, no MAUI DI container
    ' Must use a completely different OCR library for server-side processing
End Class

// ASP.NET Core — IronOCR works without modification
using IronOcr;
using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("api/[controller]")]
public class DocumentsController : ControllerBase
{
    [HttpPost("extract-text")]
    public async Task<IActionResult> ExtractText(IFormFile file)
    {
        if (file == null || file.Length == 0)
            return BadRequest("No file uploaded.");

        var ocr = new IronTesseract();
        using var input = new OcrInput();

        // Load directly from the upload stream — no temp files
        using var stream = file.OpenReadStream();

        if (file.ContentType == "application/pdf")
            input.LoadPdf(stream);
        else
            input.LoadImage(stream);

        input.Deskew();
        input.DeNoise();

        var result = ocr.Read(input);

        return Ok(new
        {
            text = result.Text,
            confidence = result.Confidence,
            pageCount = result.Pages.Count()
        });
    }

    [HttpPost("extract-text-batch")]
    public async Task<IActionResult> ExtractTextBatch(List<IFormFile> files)
    {
        var results = new List<object>();

        // Thread-safe: create one IronTesseract per thread
        await Parallel.ForEachAsync(files, async (file, ct) =>
        {
            var ocr = new IronTesseract();
            using var input = new OcrInput();
            using var stream = file.OpenReadStream();
            input.LoadImage(stream);
            var result = ocr.Read(input);

            lock (results)
            {
                results.Add(new { file = file.FileName, text = result.Text });
            }
        });

        return Ok(results);
    }
}

Imports IronOcr
Imports Microsoft.AspNetCore.Mvc

<ApiController>
<Route("api/[controller]")>
Public Class DocumentsController
    Inherits ControllerBase

    <HttpPost("extract-text")>
    Public Async Function ExtractText(file As IFormFile) As Task(Of IActionResult)
        If file Is Nothing OrElse file.Length = 0 Then
            Return BadRequest("No file uploaded.")
        End If

        Dim ocr As New IronTesseract()
        Using input As New OcrInput()
            ' Load directly from the upload stream — no temp files
            Using stream = file.OpenReadStream()
                If file.ContentType = "application/pdf" Then
                    input.LoadPdf(stream)
                Else
                    input.LoadImage(stream)
                End If

                input.Deskew()
                input.DeNoise()

                Dim result = ocr.Read(input)

                Return Ok(New With {
                    .text = result.Text,
                    .confidence = result.Confidence,
                    .pageCount = result.Pages.Count()
                })
            End Using
        End Using
    End Function

    <HttpPost("extract-text-batch")>
    Public Async Function ExtractTextBatch(files As List(Of IFormFile)) As Task(Of IActionResult)
        Dim results As New List(Of Object)()

        ' Thread-safe: create one IronTesseract per thread
        Await Task.Run(Sub()
                           Parallel.ForEach(files, Sub(file)
                                                       Dim ocr As New IronTesseract()
                                                       Using input As New OcrInput()
                                                           Using stream = file.OpenReadStream()
                                                               input.LoadImage(stream)
                                                               Dim result = ocr.Read(input)

                                                               SyncLock results
                                                                   results.Add(New With {
                                                                       .file = file.FileName,
                                                                       .text = result.Text
                                                                   })
                                                               End SyncLock
                                                           End Using
                                                       End Using
                                                   End Sub)
                       End Sub)

        Return Ok(results)
    End Function
End Class

// Attempting to share OCR logic across MAUI and non-MAUI targets
// requires platform-conditional compilation — a maintenance hazard

#if ANDROID || IOS || WINDOWS
// Only compile this block in MAUI targets
// Non-MAUI targets cannot reference TesseractOcrMaui at all
using TesseractOcrMaui;

public class PlatformOcrHandler
{
    private readonly ITesseract _tesseract;

    public PlatformOcrHandler(ITesseract tesseract)
    {
        _tesseract = tesseract;
    }

    public async Task<string> ProcessAsync(string imagePath)
    {
        await _tesseract.InitAsync("eng");
        var r = await _tesseract.RecognizeTextAsync(imagePath);
        return r.RecognizedText ?? string.Empty;
    }
}
#else
// Server targets need a completely different implementation
public class PlatformOcrHandler
{
    public string ProcessAsync(string imagePath)
    {
        // Duplicate logic using a different library
        throw new PlatformNotSupportedException("Use server OCR library here");
    }
}
#endif

#If ANDROID Or IOS Or WINDOWS Then
Imports TesseractOcrMaui

Public Class PlatformOcrHandler
    Private ReadOnly _tesseract As ITesseract

    Public Sub New(tesseract As ITesseract)
        _tesseract = tesseract
    End Sub

    Public Async Function ProcessAsync(imagePath As String) As Task(Of String)
        Await _tesseract.InitAsync("eng")
        Dim r = Await _tesseract.RecognizeTextAsync(imagePath)
        Return If(r.RecognizedText, String.Empty)
    End Function
End Class
#Else
Public Class PlatformOcrHandler
    Public Function ProcessAsync(imagePath As String) As String
        Throw New PlatformNotSupportedException("Use server OCR library here")
    End Function
End Class
#End If

// One implementation — no conditional compilation, no duplicate logic
using IronOcr;

public class PlatformOcrHandler
{
    // This class compiles identically for:
    // net8.0-android, net8.0-ios, net8.0-windows (MAUI targets)
    // net8.0 (server targets)
    // netstandard2.1 (shared library targets)

    public string Process(string imagePath)
    {
        var ocr = new IronTesseract();
        using var input = new OcrInput();
        input.LoadImage(imagePath);
        input.Deskew();
        return ocr.Read(input).Text;
    }
}

// Multi-target .csproj — no conditional package references needed
// <TargetFrameworks>net8.0;net8.0-android;net8.0-ios</TargetFrameworks>
// IronOcr resolves correctly for all three targets from one package reference

Imports IronOcr

Public Class PlatformOcrHandler
    ' This class compiles identically for:
    ' net8.0-android, net8.0-ios, net8.0-windows (MAUI targets)
    ' net8.0 (server targets)
    ' netstandard2.1 (shared library targets)

    Public Function Process(imagePath As String) As String
        Dim ocr As New IronTesseract()
        Using input As New OcrInput()
            input.LoadImage(imagePath)
            input.Deskew()
            Return ocr.Read(input).Text
        End Using
    End Function
End Class

' Multi-target .csproj — no conditional package references needed
' <TargetFrameworks>net8.0;net8.0-android;net8.0-ios</TargetFrameworks>
' IronOcr resolves correctly for all three targets from one package reference

// TesseractOcrMaui: flat text string only — no structure, no coordinates
public class TesseractMauiFormParser
{
    private readonly ITesseract _tesseract;

    public TesseractMauiFormParser(ITesseract tesseract)
    {
        _tesseract = tesseract;
    }

    public async Task<Dictionary<string, string>> ParseFormAsync(string imagePath)
    {
        await _tesseract.InitAsync("eng");
        var result = await _tesseract.RecognizeTextAsync(imagePath);

        // result.RecognizedText is one flat string — no field positions
        // Parsing requires fragile line-splitting and regex heuristics
        var fields = new Dictionary<string, string>();
        var lines = result.RecognizedText?.Split('\n') ?? Array.Empty<string>();

        foreach (var line in lines)
        {
            // Hope the layout stays consistent enough to parse
            var parts = line.Split(':');
            if (parts.Length == 2)
                fields[parts[0].Trim()] = parts[1].Trim();
        }

        return fields;
        // No way to validate against expected field positions
        // No confidence per word — only document-level confidence
    }
}

Imports System.Threading.Tasks

' TesseractOcrMaui: flat text string only — no structure, no coordinates
Public Class TesseractMauiFormParser
    Private ReadOnly _tesseract As ITesseract

    Public Sub New(tesseract As ITesseract)
        _tesseract = tesseract
    End Sub

    Public Async Function ParseFormAsync(imagePath As String) As Task(Of Dictionary(Of String, String))
        Await _tesseract.InitAsync("eng")
        Dim result = Await _tesseract.RecognizeTextAsync(imagePath)

        ' result.RecognizedText is one flat string — no field positions
        ' Parsing requires fragile line-splitting and regex heuristics
        Dim fields As New Dictionary(Of String, String)()
        Dim lines = If(result.RecognizedText?.Split(ControlChars.Lf), Array.Empty(Of String)())

        For Each line In lines
            ' Hope the layout stays consistent enough to parse
            Dim parts = line.Split(":"c)
            If parts.Length = 2 Then
                fields(parts(0).Trim()) = parts(1).Trim()
            End If
        Next

        Return fields
        ' No way to validate against expected field positions
        ' No confidence per word — only document-level confidence
    End Function
End Class

// IronOCR: full document structure with bounding boxes per word
using IronOcr;

public class IronOcrFormParser
{
    public List<WordLocation> ExtractWordsWithPositions(string imagePath)
    {
        var ocr = new IronTesseract();
        using var input = new OcrInput();
        input.LoadImage(imagePath);

        var result = ocr.Read(input);
        var wordLocations = new List<WordLocation>();

        foreach (var page in result.Pages)
        {
            foreach (var word in page.Words)
            {
                wordLocations.Add(new WordLocation
                {
                    Text = word.Text,
                    Confidence = word.Confidence,
                    X = word.X,
                    Y = word.Y,
                    Width = word.Width,
                    Height = word.Height
                });
            }
        }

        return wordLocations;
    }

    public FormData ParseStructuredForm(string imagePath)
    {
        var ocr = new IronTesseract();
        using var input = new OcrInput();
        input.LoadImage(imagePath);
        input.Deskew();

        var result = ocr.Read(input);
        var form = new FormData();

        foreach (var page in result.Pages)
        {
            foreach (var paragraph in page.Paragraphs)
            {
                // Use Y coordinate to identify form regions
                if (paragraph.Y < 200)
                    form.HeaderText += paragraph.Text + " ";
                else if (paragraph.Y > 800)
                    form.FooterText += paragraph.Text + " ";
                else
                    form.BodyLines.Add(paragraph.Text);
            }
        }

        form.OverallConfidence = result.Confidence;
        return form;
    }
}

public class WordLocation
{
    public string Text { get; set; }
    public float Confidence { get; set; }
    public int X { get; set; }
    public int Y { get; set; }
    public int Width { get; set; }
    public int Height { get; set; }
}

public class FormData
{
    public string HeaderText { get; set; } = string.Empty;
    public string FooterText { get; set; } = string.Empty;
    public List<string> BodyLines { get; set; } = new();
    public float OverallConfidence { get; set; }
}

Imports IronOcr

Public Class IronOcrFormParser
    Public Function ExtractWordsWithPositions(imagePath As String) As List(Of WordLocation)
        Dim ocr = New IronTesseract()
        Using input = New OcrInput()
            input.LoadImage(imagePath)

            Dim result = ocr.Read(input)
            Dim wordLocations = New List(Of WordLocation)()

            For Each page In result.Pages
                For Each word In page.Words
                    wordLocations.Add(New WordLocation With {
                        .Text = word.Text,
                        .Confidence = word.Confidence,
                        .X = word.X,
                        .Y = word.Y,
                        .Width = word.Width,
                        .Height = word.Height
                    })
                Next
            Next

            Return wordLocations
        End Using
    End Function

    Public Function ParseStructuredForm(imagePath As String) As FormData
        Dim ocr = New IronTesseract()
        Using input = New OcrInput()
            input.LoadImage(imagePath)
            input.Deskew()

            Dim result = ocr.Read(input)
            Dim form = New FormData()

            For Each page In result.Pages
                For Each paragraph In page.Paragraphs
                    ' Use Y coordinate to identify form regions
                    If paragraph.Y < 200 Then
                        form.HeaderText &= paragraph.Text & " "
                    ElseIf paragraph.Y > 800 Then
                        form.FooterText &= paragraph.Text & " "
                    Else
                        form.BodyLines.Add(paragraph.Text)
                    End If
                Next
            Next

            form.OverallConfidence = result.Confidence
            Return form
        End Using
    End Function
End Class

Public Class WordLocation
    Public Property Text As String
    Public Property Confidence As Single
    Public Property X As Integer
    Public Property Y As Integer
    Public Property Width As Integer
    Public Property Height As Integer
End Class

Public Class FormData
    Public Property HeaderText As String = String.Empty
    Public Property FooterText As String = String.Empty
    Public Property BodyLines As List(Of String) = New List(Of String)()
    Public Property OverallConfidence As Single
End Class

// Background processing is impossible with TesseractOcrMaui.
// IHostedService runs in a server context — TesseractOcrMaui has no server target.
// The MAUI async API exists, but there is nowhere to run it outside the MAUI app host.

public class DocumentBatchWorker : BackgroundService
{
    // ITesseract cannot be injected here — no MAUI DI in a hosted service
    // Attempting to reference TesseractOcrMaui will fail to compile:
    // error: Package TesseractOcrMaui does not support target net8.0
    protected override Task ExecuteAsync(CancellationToken stoppingToken)
    {
        throw new PlatformNotSupportedException(
            "TesseractOcrMaui has no server target. Use a different OCR library.");
    }
}

' Background processing is impossible with TesseractOcrMaui.
' IHostedService runs in a server context — TesseractOcrMaui has no server target.
' The MAUI async API exists, but there is nowhere to run it outside the MAUI app host.

Public Class DocumentBatchWorker
    Inherits BackgroundService

    ' ITesseract cannot be injected here — no MAUI DI in a hosted service
    ' Attempting to reference TesseractOcrMaui will fail to compile:
    ' error: Package TesseractOcrMaui does not support target net8.0
    Protected Overrides Function ExecuteAsync(stoppingToken As CancellationToken) As Task
        Throw New PlatformNotSupportedException(
            "TesseractOcrMaui has no server target. Use a different OCR library.")
    End Function
End Class

// IronOCR: hosted service background batch processor
using IronOcr;
using Microsoft.Extensions.Hosting;

public class DocumentBatchWorker : BackgroundService
{
    private readonly ILogger<DocumentBatchWorker> _logger;
    private readonly string _inputFolder;
    private readonly string _outputFolder;

    public DocumentBatchWorker(ILogger<DocumentBatchWorker> logger, IConfiguration config)
    {
        _logger = logger;
        _inputFolder = config["Ocr:InputFolder"];
        _outputFolder = config["Ocr:OutputFolder"];
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            var pendingFiles = Directory.GetFiles(_inputFolder, "*.pdf")
                .Concat(Directory.GetFiles(_inputFolder, "*.jpg"))
                .ToList();

            if (pendingFiles.Count > 0)
            {
                _logger.LogInformation("Processing {Count} documents.", pendingFiles.Count);

                // Thread-safe parallel processing — one IronTesseract per thread
                await Parallel.ForEachAsync(pendingFiles,
                    new ParallelOptions { MaxDegreeOfParallelism = 4, CancellationToken = stoppingToken },
                    async (filePath, ct) =>
                    {
                        await ProcessDocumentAsync(filePath, ct);
                    });
            }

            await Task.Delay(TimeSpan.FromSeconds(30), stoppingToken);
        }
    }

    private async Task ProcessDocumentAsync(string filePath, CancellationToken ct)
    {
        try
        {
            var ocr = new IronTesseract();
            using var input = new OcrInput();

            if (Path.GetExtension(filePath).Equals(".pdf", StringComparison.OrdinalIgnoreCase))
                input.LoadPdf(filePath);
            else
                input.LoadImage(filePath);

            input.Deskew();
            input.DeNoise();

            var result = await Task.Run(() => ocr.Read(input), ct);

            // Produce searchable PDF from the same OCR pass
            var outputPath = Path.Combine(_outputFolder,
                Path.GetFileNameWithoutExtension(filePath) + "_searchable.pdf");
            result.SaveAsSearchablePdf(outputPath);

            File.Delete(filePath); // move from input queue
            _logger.LogInformation("Processed {File}: {Confidence:F1}% confidence.", filePath, result.Confidence);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Failed to process {File}.", filePath);
        }
    }
}

Imports IronOcr
Imports Microsoft.Extensions.Hosting
Imports System.IO
Imports System.Threading
Imports System.Threading.Tasks
Imports Microsoft.Extensions.Logging
Imports Microsoft.Extensions.Configuration

Public Class DocumentBatchWorker
    Inherits BackgroundService

    Private ReadOnly _logger As ILogger(Of DocumentBatchWorker)
    Private ReadOnly _inputFolder As String
    Private ReadOnly _outputFolder As String

    Public Sub New(logger As ILogger(Of DocumentBatchWorker), config As IConfiguration)
        _logger = logger
        _inputFolder = config("Ocr:InputFolder")
        _outputFolder = config("Ocr:OutputFolder")
    End Sub

    Protected Overrides Async Function ExecuteAsync(stoppingToken As CancellationToken) As Task
        While Not stoppingToken.IsCancellationRequested
            Dim pendingFiles = Directory.GetFiles(_inputFolder, "*.pdf").Concat(Directory.GetFiles(_inputFolder, "*.jpg")).ToList()

            If pendingFiles.Count > 0 Then
                _logger.LogInformation("Processing {Count} documents.", pendingFiles.Count)

                ' Thread-safe parallel processing — one IronTesseract per thread
                Await Parallel.ForEachAsync(pendingFiles,
                    New ParallelOptions With {.MaxDegreeOfParallelism = 4, .CancellationToken = stoppingToken},
                    Async Function(filePath, ct)
                        Await ProcessDocumentAsync(filePath, ct)
                    End Function)
            End If

            Await Task.Delay(TimeSpan.FromSeconds(30), stoppingToken)
        End While
    End Function

    Private Async Function ProcessDocumentAsync(filePath As String, ct As CancellationToken) As Task
        Try
            Dim ocr = New IronTesseract()
            Using input = New OcrInput()

                If Path.GetExtension(filePath).Equals(".pdf", StringComparison.OrdinalIgnoreCase) Then
                    input.LoadPdf(filePath)
                Else
                    input.LoadImage(filePath)
                End If

                input.Deskew()
                input.DeNoise()

                Dim result = Await Task.Run(Function() ocr.Read(input), ct)

                ' Produce searchable PDF from the same OCR pass
                Dim outputPath = Path.Combine(_outputFolder, Path.GetFileNameWithoutExtension(filePath) & "_searchable.pdf")
                result.SaveAsSearchablePdf(outputPath)

                File.Delete(filePath) ' move from input queue
                _logger.LogInformation("Processed {File}: {Confidence:F1}% confidence.", filePath, result.Confidence)
            End Using
        Catch ex As Exception
            _logger.LogError(ex, "Failed to process {File}.", filePath)
        End Try
    End Function
End Class

// Option A: Direct instantiation (recommended for most cases)
public class ScanPageViewModel
{
    public string ScanDocument(string imagePath)
    {
        var ocr = new IronTesseract();
        using var input = new OcrInput();
        input.LoadImage(imagePath);
        return ocr.Read(input).Text;
    }
}

// Option B: Register IronTesseract in DI if your architecture requires it
// In MauiProgram.cs or Program.cs:
builder.Services.AddSingleton<IronTesseract>();

// Then inject normally:
public class ScanPageViewModel
{
    private readonly IronTesseract _ocr;
    public ScanPageViewModel(IronTesseract ocr) { _ocr = ocr; }

    public string ScanDocument(string imagePath)
    {
        using var input = new OcrInput();
        input.LoadImage(imagePath);
        return _ocr.Read(input).Text;
    }
}

Imports IronTesseract

' Option A: Direct instantiation (recommended for most cases)
Public Class ScanPageViewModel
    Public Function ScanDocument(imagePath As String) As String
        Dim ocr As New IronTesseract()
        Using input As New OcrInput()
            input.LoadImage(imagePath)
            Return ocr.Read(input).Text
        End Using
    End Function
End Class

' Option B: Register IronTesseract in DI if your architecture requires it
' In MauiProgram.vb or Program.vb:
' builder.Services.AddSingleton(Of IronTesseract)()

' Then inject normally:
Public Class ScanPageViewModel
    Private ReadOnly _ocr As IronTesseract

    Public Sub New(ocr As IronTesseract)
        _ocr = ocr
    End Sub

    Public Function ScanDocument(imagePath As String) As String
        Using input As New OcrInput()
            input.LoadImage(imagePath)
            Return _ocr.Read(input).Text
        End Using
    End Function
End Class

# Delete traineddata assets
rm -rf Resources/Raw/tessdata

# Remove from .csproj (delete the MauiAsset ItemGroup):
# <ItemGroup>
#   <MauiAsset Include="Resources\Raw\tessdata\*.traineddata" />
# </ItemGroup>

# Install IronOCR language pack (if non-English language was needed)
dotnet add package IronOcr.Languages.French
dotnet add package IronOcr.Languages.German

// Before: initialization guard required before every OCR call
private bool _isInitialized = false;
private readonly SemaphoreSlim _initLock = new SemaphoreSlim(1, 1);

public async Task<string> GetTextAsync(string imagePath)
{
    await _initLock.WaitAsync();
    try
    {
        if (!_isInitialized)
        {
            await _tesseract.InitAsync("eng");
            _isInitialized = true;
        }
    }
    finally { _initLock.Release(); }

    var result = await _tesseract.RecognizeTextAsync(imagePath);
    return result.RecognizedText ?? string.Empty;
}

// After: no initialization, no guard, no semaphore
public string GetText(string imagePath)
{
    var ocr = new IronTesseract();
    using var input = new OcrInput();
    input.LoadImage(imagePath);
    return ocr.Read(input).Text;
}

Imports System.Threading
Imports System.Threading.Tasks

' Before: initialization guard required before every OCR call
Private _isInitialized As Boolean = False
Private ReadOnly _initLock As New SemaphoreSlim(1, 1)

Public Async Function GetTextAsync(imagePath As String) As Task(Of String)
    Await _initLock.WaitAsync()
    Try
        If Not _isInitialized Then
            Await _tesseract.InitAsync("eng")
            _isInitialized = True
        End If
    Finally
        _initLock.Release()
    End Try

    Dim result = Await _tesseract.RecognizeTextAsync(imagePath)
    Return If(result.RecognizedText, String.Empty)
End Function

' After: no initialization, no guard, no semaphore
Public Function GetText(imagePath As String) As String
    Dim ocr As New IronTesseract()
    Using input As New OcrInput()
        input.LoadImage(imagePath)
        Return ocr.Read(input).Text
    End Using
End Function

// Before: success-flag pattern
var result = await _tesseract.RecognizeTextAsync(imagePath);
if (!result.Success)
{
    logger.LogError("OCR failed: {Status}", result.Status);
    return string.Empty;
}
return result.RecognizedText ?? string.Empty;

// After: exception pattern
try
{
    var ocr = new IronTesseract();
    using var input = new OcrInput();
    input.LoadImage(imagePath);
    var result = ocr.Read(input);
    return result.Text; // empty string if no text found — never null
}
catch (Exception ex)
{
    logger.LogError(ex, "OCR failed for {Path}.", imagePath);
    return string.Empty;
}

Imports IronOcr

' Before: success-flag pattern
Dim result = Await _tesseract.RecognizeTextAsync(imagePath)
If Not result.Success Then
    logger.LogError("OCR failed: {Status}", result.Status)
    Return String.Empty
End If
Return If(result.RecognizedText, String.Empty)

' After: exception pattern
Try
    Dim ocr = New IronTesseract()
    Using input As New OcrInput()
        input.LoadImage(imagePath)
        Dim result = ocr.Read(input)
        Return result.Text ' empty string if no text found — never null
    End Using
Catch ex As Exception
    logger.LogError(ex, "OCR failed for {Path}.", imagePath)
    Return String.Empty
End Try

<TargetFramework>net8.0-android</TargetFramework>
<PackageReference Include="TesseractOcrMaui" Version="*" />

<TargetFramework>net8.0</TargetFramework>
<PackageReference Include="IronOcr" Version="*" />

// Before: PDF library + manual temp file management (50+ lines)
using var pdfDoc = PdfDocument.Open(pdfPath);
var results = new List<string>();
foreach (var page in pdfDoc.GetPages())
{
    var tempImagePath = Path.Combine(FileSystem.CacheDirectory, $"page_{page.Number}.png");
    RenderPageToImage(page, tempImagePath, dpi: 300);
    await _tesseract.InitAsync("eng");
    var r = await _tesseract.RecognizeTextAsync(tempImagePath);
    results.Add(r.RecognizedText ?? string.Empty);
    File.Delete(tempImagePath);
}
return string.Join("\n", results);

// After: native PDF support — 5 lines
var ocr = new IronTesseract();
using var input = new OcrInput();
input.LoadPdf(pdfPath);
var result = ocr.Read(input);
return result.Text;

Imports System.IO

' Before: PDF library + manual temp file management (50+ lines)
Using pdfDoc = PdfDocument.Open(pdfPath)
    Dim results As New List(Of String)()
    For Each page In pdfDoc.GetPages()
        Dim tempImagePath = Path.Combine(FileSystem.CacheDirectory, $"page_{page.Number}.png")
        RenderPageToImage(page, tempImagePath, dpi:=300)
        Await _tesseract.InitAsync("eng")
        Dim r = Await _tesseract.RecognizeTextAsync(tempImagePath)
        results.Add(If(r.RecognizedText, String.Empty))
        File.Delete(tempImagePath)
    Next
    Return String.Join(vbLf, results)
End Using

' After: native PDF support — 5 lines
Dim ocr As New IronTesseract()
Using input As New OcrInput()
    input.LoadPdf(pdfPath)
    Dim result = ocr.Read(input)
    Return result.Text
End Using

# Find all files that reference TesseractOcrMaui namespaces
grep -r "TesseractOcrMaui" --include="*.cs" .

# Find all ITesseract injection points
grep -r "ITesseract" --include="*.cs" .

# Find all AddTesseractOcr registrations
grep -r "AddTesseractOcr" --include="*.cs" .

# Find all InitAsync calls
grep -r "InitAsync" --include="*.cs" .

# Find all RecognizeTextAsync calls
grep -r "RecognizeTextAsync" --include="*.cs" .

# Find traineddata asset declarations in project files
grep -r "tessdata" --include="*.csproj" .

# Find MauiAsset traineddata declarations
grep -r "MauiAsset" --include="*.csproj" .

# Identify projects with MAUI-only target frameworks that hold OCR logic
grep -r "net8.0-android\|net8.0-ios\|net8.0-windows" --include="*.csproj" .