Migrating from Windows.Media.Ocr to IronOCR

// Windows.Media.Ocr: language availability decided by OS admin, not the developer
// Returns null on any machine without the language pack installed
var engine = OcrEngine.TryCreateFromLanguage(
    new Windows.Globalization.Language("ja-JP"));

if (engine == null)
    throw new InvalidOperationException(
        "Japanese OCR unavailable — install the Japanese language pack in Windows Settings.");
// No recovery path. No bundled model. No fallback.

Imports Windows.Globalization
Imports Windows.Media.Ocr

' Windows.Media.Ocr: language availability decided by OS admin, not the developer
' Returns Nothing on any machine without the language pack installed
Dim engine = OcrEngine.TryCreateFromLanguage(New Language("ja-JP"))

If engine Is Nothing Then
    Throw New InvalidOperationException("Japanese OCR unavailable — install the Japanese language pack in Windows Settings.")
End If
' No recovery path. No bundled model. No fallback.

// IronOCR: language availability is a NuGet package, not an OS configuration
// dotnet add package IronOcr.Languages.Japanese
var ocr = new IronTesseract();
ocr.Language = OcrLanguage.Japanese;
var result = ocr.Read("invoice.jpg"); // Works on any OS, any machine
Console.WriteLine(result.Text);

Imports IronOcr

' IronOCR: language availability is a NuGet package, not an OS configuration
' dotnet add package IronOcr.Languages.Japanese
Dim ocr As New IronTesseract()
ocr.Language = OcrLanguage.Japanese
Dim result = ocr.Read("invoice.jpg") ' Works on any OS, any machine
Console.WriteLine(result.Text)

# Audit all files referencing Windows OCR namespaces
grep -r "Windows.Media.Ocr\|Windows.Graphics.Imaging\|Windows.Storage" --include="*.cs" .

// Before (Windows.Media.Ocr)
using Windows.Media.Ocr;
using Windows.Graphics.Imaging;
using Windows.Storage;
using Windows.Globalization;

// After (IronOCR)
using IronOcr;

Imports IronOcr
Imports Windows.Graphics.Imaging
Imports Windows.Storage
Imports Windows.Globalization

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

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

// Windows.Media.Ocr: full async chain required per document
// Requires net8.0-windows10.0.19041.0 TFM — cannot deploy to Linux workers
public async Task<List<string>> ProcessQueueAsync(IEnumerable<string> imagePaths)
{
    var engine = OcrEngine.TryCreateFromUserProfileLanguages();
    if (engine == null)
        throw new InvalidOperationException("No OCR language pack installed on this machine.");

    var results = new List<string>();

    foreach (var path in imagePaths)
    {
        // Each document: 4 async steps before RecognizeAsync
        var file = await StorageFile.GetFileFromPathAsync(path);
        using var stream = await file.OpenAsync(FileAccessMode.Read);
        var decoder = await BitmapDecoder.CreateAsync(stream);
        var bitmap = await decoder.GetSoftwareBitmapAsync();

        var ocrResult = await engine.RecognizeAsync(bitmap);
        results.Add(ocrResult.Text);

        bitmap.Dispose();
    }

    return results;
}

Imports System
Imports System.Collections.Generic
Imports System.Threading.Tasks
Imports Windows.Graphics.Imaging
Imports Windows.Media.Ocr
Imports Windows.Storage
Imports Windows.Storage.Streams

Public Class OcrProcessor
    Public Async Function ProcessQueueAsync(imagePaths As IEnumerable(Of String)) As Task(Of List(Of String))
        Dim engine = OcrEngine.TryCreateFromUserProfileLanguages()
        If engine Is Nothing Then
            Throw New InvalidOperationException("No OCR language pack installed on this machine.")
        End If

        Dim results As New List(Of String)()

        For Each path In imagePaths
            ' Each document: 4 async steps before RecognizeAsync
            Dim file = Await StorageFile.GetFileFromPathAsync(path)
            Using stream = Await file.OpenAsync(FileAccessMode.Read)
                Dim decoder = Await BitmapDecoder.CreateAsync(stream)
                Dim bitmap = Await decoder.GetSoftwareBitmapAsync()

                Dim ocrResult = Await engine.RecognizeAsync(bitmap)
                results.Add(ocrResult.Text)

                bitmap.Dispose()
            End Using
        Next

        Return results
    End Function
End Class

// IronOCR: one call per document, no WinRT, no SoftwareBitmap, no null checks
// Runs on Windows, Linux, macOS, Docker — same binary, no TFM change
public List<string> ProcessQueue(IEnumerable<string> imagePaths)
{
    var results = new List<string>();

    foreach (var path in imagePaths)
    {
        var result = new IronTesseract().Read(path);
        results.Add(result.Text);
    }

    return results;
}

Imports System.Collections.Generic

' IronOCR: one call per document, no WinRT, no SoftwareBitmap, no null checks
' Runs on Windows, Linux, macOS, Docker — same binary, no TFM change
Public Function ProcessQueue(imagePaths As IEnumerable(Of String)) As List(Of String)
    Dim results As New List(Of String)()

    For Each path In imagePaths
        Dim result = New IronTesseract().Read(path)
        results.Add(result.Text)
    Next

    Return results
End Function

// Windows.Media.Ocr: byte array must travel through WinRT stream → BitmapDecoder → SoftwareBitmap
public async Task<string> RecognizeFromBytesAsync(byte[] imageBytes)
{
    var engine = OcrEngine.TryCreateFromUserProfileLanguages();
    if (engine == null)
        throw new InvalidOperationException("No OCR language available.");

    // Copy byte array into InMemoryRandomAccessStream (WinRT type)
    using var ras = new Windows.Storage.Streams.InMemoryRandomAccessStream();
    using var writer = new Windows.Storage.Streams.DataWriter(ras);
    writer.WriteBytes(imageBytes);
    await writer.StoreAsync();
    ras.Seek(0);

    var decoder = await BitmapDecoder.CreateAsync(ras);
    var bitmap = await decoder.GetSoftwareBitmapAsync();

    var result = await engine.RecognizeAsync(bitmap);
    bitmap.Dispose();
    return result.Text;
}

Imports System
Imports System.Threading.Tasks
Imports Windows.Media.Ocr
Imports Windows.Storage.Streams
Imports Windows.Graphics.Imaging

Public Class OcrHelper
    Public Async Function RecognizeFromBytesAsync(imageBytes As Byte()) As Task(Of String)
        Dim engine = OcrEngine.TryCreateFromUserProfileLanguages()
        If engine Is Nothing Then
            Throw New InvalidOperationException("No OCR language available.")
        End If

        ' Copy byte array into InMemoryRandomAccessStream (WinRT type)
        Using ras As New InMemoryRandomAccessStream()
            Using writer As New DataWriter(ras)
                writer.WriteBytes(imageBytes)
                Await writer.StoreAsync()
                ras.Seek(0)

                Dim decoder = Await BitmapDecoder.CreateAsync(ras)
                Dim bitmap = Await decoder.GetSoftwareBitmapAsync()

                Dim result = Await engine.RecognizeAsync(bitmap)
                bitmap.Dispose()
                Return result.Text
            End Using
        End Using
    End Function
End Class

// IronOCR: byte array loads directly into OcrInput — no conversion, no WinRT types
public string RecognizeFromBytes(byte[] imageBytes)
{
    using var input = new OcrInput();
    input.LoadImage(imageBytes); // direct byte array load

    var result = new IronTesseract().Read(input);
    return result.Text;
}

Imports IronOcr

Public Function RecognizeFromBytes(imageBytes As Byte()) As String
    Using input As New OcrInput()
        input.LoadImage(imageBytes) ' direct byte array load

        Dim result = New IronTesseract().Read(input)
        Return result.Text
    End Using
End Function

// Windows.Media.Ocr: one language per engine, no simultaneous multi-language support
// Each language requires a separate language pack installed on the machine
public async Task<string> RecognizeMultiLanguageAsync(SoftwareBitmap bitmap)
{
    // Must pick ONE language — no simultaneous recognition
    var engine = OcrEngine.TryCreateFromLanguage(
        new Windows.Globalization.Language("en-US"));
    if (engine == null)
        throw new InvalidOperationException("English language pack not installed.");

    // French and German text on the same document will be misrecognized
    var result = await engine.RecognizeAsync(bitmap);
    return result.Text;
}

Imports System
Imports System.Threading.Tasks
Imports Windows.Media.Ocr
Imports Windows.Graphics.Imaging
Imports Windows.Globalization

Public Class OcrRecognizer
    ' Windows.Media.Ocr: one language per engine, no simultaneous multi-language support
    ' Each language requires a separate language pack installed on the machine
    Public Async Function RecognizeMultiLanguageAsync(bitmap As SoftwareBitmap) As Task(Of String)
        ' Must pick ONE language — no simultaneous recognition
        Dim engine = OcrEngine.TryCreateFromLanguage(New Language("en-US"))
        If engine Is Nothing Then
            Throw New InvalidOperationException("English language pack not installed.")
        End If

        ' French and German text on the same document will be misrecognized
        Dim result = Await engine.RecognizeAsync(bitmap)
        Return result.Text
    End Function
End Class

// IronOCR: simultaneous multi-language recognition in a single pass
// Language packs are NuGet packages — no OS coordination required
// dotnet add package IronOcr.Languages.French
// dotnet add package IronOcr.Languages.German
public string RecognizeMultiLanguage(string documentPath)
{
    var ocr = new IronTesseract();
    ocr.Language = OcrLanguage.English + OcrLanguage.French + OcrLanguage.German;

    var result = ocr.Read(documentPath);

    // Structured output: walk paragraphs with location data
    foreach (var page in result.Pages)
    {
        foreach (var paragraph in page.Paragraphs)
        {
            Console.WriteLine($"[{paragraph.X},{paragraph.Y}] {paragraph.Text}");
        }
    }

    return result.Text;
}

Imports IronOcr

Public Function RecognizeMultiLanguage(documentPath As String) As String
    Dim ocr As New IronTesseract()
    ocr.Language = OcrLanguage.English + OcrLanguage.French + OcrLanguage.German

    Dim result = ocr.Read(documentPath)

    ' Structured output: walk paragraphs with location data
    For Each page In result.Pages
        For Each paragraph In page.Paragraphs
            Console.WriteLine($"[{paragraph.X},{paragraph.Y}] {paragraph.Text}")
        Next
    Next

    Return result.Text
End Function

// Windows.Media.Ocr: cannot run on Linux, Docker, or Azure Functions on Linux
// UWP/WinRT assumptions about thread context cause failures in ASP.NET pipelines
// The entire approach below is non-deployable outside Windows with Desktop Experience

[HttpPost("ocr")]
public async Task<IActionResult> RecognizeDocument(IFormFile file)
{
    // WinRT requires STA thread context in some scenarios — not guaranteed in ASP.NET
    // Cannot deploy this controller to a Linux App Service plan
    using var stream = file.OpenReadStream();
    // InMemoryRandomAccessStream is a WinRT type — does not exist on Linux
    // var ras = new InMemoryRandomAccessStream(); // compile error on net8.0 TFM
    return StatusCode(503, "Windows-only — cannot deploy cross-platform.");
}

Imports Microsoft.AspNetCore.Mvc

<HttpPost("ocr")>
Public Async Function RecognizeDocument(file As IFormFile) As Task(Of IActionResult)
    ' WinRT requires STA thread context in some scenarios — not guaranteed in ASP.NET
    ' Cannot deploy this controller to a Linux App Service plan
    Using stream = file.OpenReadStream()
        ' InMemoryRandomAccessStream is a WinRT type — does not exist on Linux
        ' Dim ras = New InMemoryRandomAccessStream() ' compile error on net8.0 TFM
        Return StatusCode(503, "Windows-only — cannot deploy cross-platform.")
    End Using
End Function

// IronOCR: ASP.NET Core controller running on Linux, Docker, or Windows — same code
[HttpPost("ocr")]
public async Task<IActionResult> RecognizeDocument(IFormFile file)
{
    if (file == null || file.Length == 0)
        return BadRequest("No file provided.");

    using var memoryStream = new MemoryStream();
    await file.CopyToAsync(memoryStream);
    var imageBytes = memoryStream.ToArray();

    using var input = new OcrInput();
    input.LoadImage(imageBytes);
    input.Deskew();   // straighten uploaded scans automatically
    input.DeNoise();  // remove mobile camera noise

    var result = new IronTesseract().Read(input);

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

Imports System.IO
Imports Microsoft.AspNetCore.Mvc

<HttpPost("ocr")>
Public Async Function RecognizeDocument(file As IFormFile) As Task(Of IActionResult)
    If file Is Nothing OrElse file.Length = 0 Then
        Return BadRequest("No file provided.")
    End If

    Using memoryStream As New MemoryStream()
        Await file.CopyToAsync(memoryStream)
        Dim imageBytes = memoryStream.ToArray()

        Using input As New OcrInput()
            input.LoadImage(imageBytes)
            input.Deskew()   ' straighten uploaded scans automatically
            input.DeNoise()  ' remove mobile camera noise

            Dim result = New IronTesseract().Read(input)

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

// Windows.Media.Ocr: plain text output only
// Searchable PDF requires external PDF library + manual text layer construction
public async Task<string> GetTextOnlyAsync(SoftwareBitmap bitmap)
{
    var engine = OcrEngine.TryCreateFromUserProfileLanguages();
    if (engine == null)
        throw new InvalidOperationException("No OCR language available.");

    var result = await engine.RecognizeAsync(bitmap);

    // result.Text is all you get
    // Producing a searchable PDF requires an entirely separate library
    return result.Text;
}

Imports Windows.Media.Ocr
Imports Windows.Graphics.Imaging
Imports System.Threading.Tasks

Public Class OcrHelper
    Public Async Function GetTextOnlyAsync(bitmap As SoftwareBitmap) As Task(Of String)
        Dim engine = OcrEngine.TryCreateFromUserProfileLanguages()
        If engine Is Nothing Then
            Throw New InvalidOperationException("No OCR language available.")
        End If

        Dim result = Await engine.RecognizeAsync(bitmap)

        ' result.Text is all you get
        ' Producing a searchable PDF requires an entirely separate library
        Return result.Text
    End Function
End Class

// IronOCR: searchable PDF output is one method call on OcrResult
public void ProcessScannedArchive(IEnumerable<string> pdfPaths, string outputDirectory)
{
    foreach (var sourcePdf in pdfPaths)
    {
        var ocr = new IronTesseract();

        using var input = new OcrInput();
        input.LoadPdf(sourcePdf);   // native PDF input — no external renderer
        input.Deskew();             // correct scan misalignment per page
        input.DeNoise();            // remove scanner speckle

        var result = ocr.Read(input);

        var outputFileName = Path.Combine(
            outputDirectory,
            Path.GetFileNameWithoutExtension(sourcePdf) + "-searchable.pdf");

        result.SaveAsSearchablePdf(outputFileName);

        Console.WriteLine($"Processed: {sourcePdf} → {outputFileName} " +
                          $"({result.Pages.Count} pages, {result.Confidence:F1}% confidence)");
    }
}

Imports System
Imports System.Collections.Generic
Imports System.IO
Imports IronOcr

Public Sub ProcessScannedArchive(pdfPaths As IEnumerable(Of String), outputDirectory As String)
    For Each sourcePdf In pdfPaths
        Dim ocr As New IronTesseract()

        Using input As New OcrInput()
            input.LoadPdf(sourcePdf)   ' native PDF input — no external renderer
            input.Deskew()             ' correct scan misalignment per page
            input.DeNoise()            ' remove scanner speckle

            Dim result = ocr.Read(input)

            Dim outputFileName = Path.Combine(outputDirectory, Path.GetFileNameWithoutExtension(sourcePdf) & "-searchable.pdf")

            result.SaveAsSearchablePdf(outputFileName)

            Console.WriteLine($"Processed: {sourcePdf} → {outputFileName} " &
                              $"({result.Pages.Count} pages, {result.Confidence:F1}% confidence)")
        End Using
    Next
End Sub

// Windows.Media.Ocr: line-level geometry, no paragraph grouping, no confidence scores
public async Task<List<string>> ExtractLineTextAsync(SoftwareBitmap bitmap)
{
    var engine = OcrEngine.TryCreateFromUserProfileLanguages();
    if (engine == null)
        throw new InvalidOperationException("No OCR language available.");

    var result = await engine.RecognizeAsync(bitmap);

    var lineTexts = new List<string>();
    foreach (var line in result.Lines)
    {
        // Line text + word bounding rects — no paragraph grouping, no confidence
        lineTexts.Add(line.Text);
    }
    return lineTexts;
}

Imports System
Imports System.Collections.Generic
Imports System.Threading.Tasks
Imports Windows.Graphics.Imaging
Imports Windows.Media.Ocr

Public Class OcrHelper
    Public Async Function ExtractLineTextAsync(bitmap As SoftwareBitmap) As Task(Of List(Of String))
        Dim engine = OcrEngine.TryCreateFromUserProfileLanguages()
        If engine Is Nothing Then
            Throw New InvalidOperationException("No OCR language available.")
        End If

        Dim result = Await engine.RecognizeAsync(bitmap)

        Dim lineTexts As New List(Of String)()
        For Each line In result.Lines
            ' Line text + word bounding rects — no paragraph grouping, no confidence
            lineTexts.Add(line.Text)
        Next
        Return lineTexts
    End Function
End Class

// IronOCR: full hierarchy — pages, paragraphs, lines, words, characters
// Each element carries coordinates and confidence for downstream validation
public void ExtractStructuredData(string documentPath)
{
    var result = new IronTesseract().Read(documentPath);

    Console.WriteLine($"Overall confidence: {result.Confidence:F1}%");

    foreach (var page in result.Pages)
    {
        Console.WriteLine($"\n--- Page {page.PageNumber} ---");

        foreach (var paragraph in page.Paragraphs)
        {
            Console.WriteLine($"Paragraph at ({paragraph.X},{paragraph.Y}): {paragraph.Text}");

            // Filter words below confidence threshold for validation workflows
            var lowConfidence = paragraph.Words
                .Where(w => w.Confidence < 70)
                .ToList();

            if (lowConfidence.Any())
            {
                Console.WriteLine($"  Low-confidence words: " +
                    string.Join(", ", lowConfidence.Select(w => $"'{w.Text}' ({w.Confidence:F0}%)")));
            }
        }
    }
}

Imports System
Imports System.Linq
Imports IronOcr

Public Sub ExtractStructuredData(documentPath As String)
    Dim result = New IronTesseract().Read(documentPath)

    Console.WriteLine($"Overall confidence: {result.Confidence:F1}%")

    For Each page In result.Pages
        Console.WriteLine(vbCrLf & $"--- Page {page.PageNumber} ---")

        For Each paragraph In page.Paragraphs
            Console.WriteLine($"Paragraph at ({paragraph.X},{paragraph.Y}): {paragraph.Text}")

            ' Filter words below confidence threshold for validation workflows
            Dim lowConfidence = paragraph.Words _
                .Where(Function(w) w.Confidence < 70) _
                .ToList()

            If lowConfidence.Any() Then
                Console.WriteLine($"  Low-confidence words: " &
                    String.Join(", ", lowConfidence.Select(Function(w) $"'{w.Text}' ({w.Confidence:F0}%)")))
            End If
        Next
    Next
End Sub

# Find remaining WinRT API usage before removing the Windows TFM
grep -r "Windows\." --include="*.cs" .
grep -r "WinRT\|IAsyncOperation\|StorageFile\|SoftwareBitmap" --include="*.cs" .

<TargetFramework>net8.0-windows10.0.19041.0</TargetFramework>

<TargetFramework>net8.0</TargetFramework>

// Before: null-check pattern
var engine = OcrEngine.TryCreateFromUserProfileLanguages();
if (engine == null)
    throw new InvalidOperationException("OCR unavailable.");

// After: no null — IronTesseract throws if misconfigured
try
{
    var result = new IronTesseract().Read("document.jpg");
}
catch (IronOcr.Exceptions.OcrException ex)
{
    // structured exception with diagnostic message
    logger.LogError("OCR failed: {Message}", ex.Message);
}

Imports IronOcr.Exceptions

' Before: null-check pattern
Dim engine = OcrEngine.TryCreateFromUserProfileLanguages()
If engine Is Nothing Then
    Throw New InvalidOperationException("OCR unavailable.")
End If

' After: no null — IronTesseract throws if misconfigured
Try
    Dim result = New IronTesseract().Read("document.jpg")
Catch ex As OcrException
    ' structured exception with diagnostic message
    logger.LogError("OCR failed: {Message}", ex.Message)
End Try

// Before: SoftwareBitmap parameter — cannot compile cross-platform
public async Task<string> RecognizeAsync(SoftwareBitmap bitmap) { ... }

// After: byte array parameter — compiles on all platforms
public string Recognize(byte[] imageBytes)
{
    using var input = new OcrInput();
    input.LoadImage(imageBytes);
    return new IronTesseract().Read(input).Text;
}

Imports System.Threading.Tasks

' Before: SoftwareBitmap parameter — cannot compile cross-platform
Public Async Function RecognizeAsync(bitmap As SoftwareBitmap) As Task(Of String)
    ' ...
End Function

' After: byte array parameter — compiles on all platforms
Public Function Recognize(imageBytes As Byte()) As String
    Using input As New OcrInput()
        input.LoadImage(imageBytes)
        Return New IronTesseract().Read(input).Text
    End Using
End Function

// Option A: wrap synchronous call in Task.Run for async callers
public async Task<string> RecognizeAsync(string imagePath)
{
    return await Task.Run(() => new IronTesseract().Read(imagePath).Text);
}

// Option B: IronOCR async path
// See: https://ironsoftware.com/csharp/ocr/how-to/async/

Imports System.Threading.Tasks

' Option A: wrap synchronous call in Task.Run for async callers
Public Async Function RecognizeAsync(imagePath As String) As Task(Of String)
    Return Await Task.Run(Function() New IronTesseract().Read(imagePath).Text)
End Function

' Option B: IronOCR async path
' See: https://ironsoftware.com/csharp/ocr/how-to/async/

// Before: BCP-47 string tags
var engine = OcrEngine.TryCreateFromLanguage(
    new Windows.Globalization.Language("fr-FR"));

// After: OcrLanguage enum
var ocr = new IronTesseract();
ocr.Language = OcrLanguage.French;
// Also: OcrLanguage.German, OcrLanguage.Japanese, OcrLanguage.Arabic, etc.

Imports Windows.Globalization
Imports IronTesseract

' Before: BCP-47 string tags
Dim engine = OcrEngine.TryCreateFromLanguage(New Language("fr-FR"))

' After: OcrLanguage enum
Dim ocr = New IronTesseract()
ocr.Language = OcrLanguage.French
' Also: OcrLanguage.German, OcrLanguage.Japanese, OcrLanguage.Arabic, etc.

// Before: WinRT file access
using var stream = await file.OpenAsync(FileAccessMode.Read);

// After: standard .NET
var imageBytes = File.ReadAllBytes(imagePath);
using var input = new OcrInput();
input.LoadImage(imageBytes);

Imports System.IO

' Before: WinRT file access
Using stream = Await file.OpenAsync(FileAccessMode.Read)
    ' Code to work with the stream
End Using

' After: standard .NET
Dim imageBytes = File.ReadAllBytes(imagePath)
Using input As New OcrInput()
    input.LoadImage(imageBytes)
End Using

# Find all Windows OCR namespace usages
grep -rn "using Windows.Media.Ocr" --include="*.cs" .
grep -rn "using Windows.Graphics.Imaging" --include="*.cs" .
grep -rn "using Windows.Storage" --include="*.cs" .
grep -rn "using Windows.Globalization" --include="*.cs" .

# Find WinRT type usages
grep -rn "OcrEngine\|SoftwareBitmap\|BitmapDecoder\|StorageFile" --include="*.cs" .
grep -rn "TryCreateFromLanguage\|TryCreateFromUserProfileLanguages\|RecognizeAsync" --include="*.cs" .
grep -rn "InMemoryRandomAccessStream\|DataWriter\|FileAccessMode" --include="*.cs" .

# Find project files with Windows TFM
grep -rn "net.*-windows" --include="*.csproj" .

# Count files requiring changes
grep -rl "Windows.Media.Ocr\|Windows.Graphics.Imaging\|SoftwareBitmap" --include="*.cs" . | wc -l