Asynchronne programowanie C# i wsparcie dla wielu wątków w IronOCR

Updated: 29 czerwca 2026

IronOCR automatycznie zarządza wielowątkowością na wszystkich rdzeniach CPU i dostarcza asynchroniczne metody jak ReadAsync(), aby wykonywać OCR bez blokowania głównego wątku, zapewniając odpowiedzialne aplikacje przy przetwarzaniu dużych dokumentów.

Wprowadzenie

Efektywne przetwarzanie duzych ilosci danych tekstowych wymaga zarowno dokładności, jak i szybkości dla operacji OCR. Ten artykuł omawia wsparcie asynchroniczne i wykonywanie wielu wątków w IronOCR i Tesseract. Programowanie asynchroniczne umożliwia nieblokujace wykonywanie OCR, co utrzymuje responsywność aplikacji podczas zadań rozpoznawania tekstu. Wielowątkowość zapewnia równoległość działania, co znacznie zwiększa wydajność OCR. Techniki te pomagają programistom poprawić wydajność i szybkość działania aplikacji opartych na technologii OCR.

Szybki start: Użyj ReadAsync dla łatwego asynchronicznego OCR

Użyj metody IronTesseract's ReadAsync, aby wykonać OCR bez blokowania głównego wątku. Dzięki temu szybko dodasz do swojej aplikacji responsywne, nieblokujące OCR. Sprawdza się szczególnie dobrze podczas przetwarzania dokumentów PDF lub jednoczesnej obsługi wielu plików graficznych.

1Install IronOCR with NuGet Package Manager
PM > Install-Package IronOcr
```
Install-Package IronOcr
```

2Skopiuj i uruchom ten fragment kodu.

var result = await new IronOcr.IronTesseract().ReadAsync("image.png");

var result = await new IronOcr.IronTesseract().ReadAsync("image.png");

3Wdrożenie do testowania w środowisku produkcyjnym

Rozpocznij używanie IronOCR w swoim projekcie już dziś z darmową wersją próbną

Minimalny proces (5 kroków)

Pobierz bibliotekę C# obsługującą Tesseract z asynchronicznością i wielowątkowością
Wykorzystaj wielowątkowość zarządzaną przez IronOCR
Przygotuj dokument PDF i obraz do odczytu
Wykorzystaj obiekt OcrReadTask, aby skorzystać z asynchronicznej współbieżności
Użyj metody ReadAsync, aby ułatwić korzystanie z aplikacji

Jak działa wielowątkowość w IronOCR?

IronOCR poprawia przetwarzanie obrazów i wydajność odczytu OCR dzięki płynnej wielowątkowości, nie wymagając od programistów specjalistycznego API. IronTesseract automatycznie wykorzystuje wszystkie dostępne wątki na wielu rdzeniach, optymalizując zasoby systemowe dla szybkiego wykonania OCR. Ta wbudowana obsługa wielowątkowości upraszcza programowanie i znacznie zwiększa wydajność poprzez integrację równoległości bezpośrednio z procesem OCR.

Wielowątkowa implementacja Tesseract w bibliotece zapewnia następujące kluczowe zalety:

Automatyczne wykorzystanie rdzeni procesora: IronOCR wykrywa i wykorzystuje wszystkie dostępne rdzenie bez konieczności ręcznej konfiguracji
Operacje bezpieczne dla wątków: Wszystkie operacje OCR są domyślnie zaprojektowane jako bezpieczne dla wątków
Zoptymalizowane zarządzanie zasobami: zasoby pamięci i mocy obliczeniowej są efektywnie przydzielane między wątki
Skalowalna wydajność: czas przetwarzania zmniejsza się proporcjonalnie do liczby dostępnych rdzeni

Oto przykład wielowątkowego odczytu w języku C#:

using IronOcr;
using System;

var ocr = new IronTesseract();

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

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

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

W zaawansowanych scenariuszach wymagających szybkiej konfiguracji OCR programiści mogą precyzyjnie dostosować zachowanie wielowątkowości, aby spełnić konkretne wymagania dotyczące wydajności przy zachowaniu dokładności.

Jak korzystać z obsługi asynchronicznej w IronOCR?

Programowanie asynchroniczne optymalizuje wydajność OCR, umożliwiając programistom wykonywanie zadań OCR bez blokowania głównego wątku. Dzięki temu aplikacje zachowują responsywność podczas przetwarzania dużych dokumentów lub obrazów w celu rozpoznania tekstu. Obsługa asynchroniczna pozwala systemowi wykonywać inne zadania, podczas gdy operacje OCR działają w tle. Ta funkcja ma kluczowe znaczenie podczas wdrażania śledzenia postępu OCR w interfejsach użytkownika.

W tej sekcji omówiono integrację obsługi asynchronicznej w IronOCR, pokazując różne metody, dzięki którym usługi OCR nie blokują działania. Funkcje asynchroniczne IronOCR zapewniają optymalną wydajność zarówno dla aplikacji desktopowych wymagających responsywności podczas operacji OCR, jak i usług internetowych obsługujących wiele równoczesnych żądań OCR.

Kiedy powinienem używać obiektów `OcrReadTask`?

Obiekty OcrReadTask zwiększają kontrolę i elastyczność w procesach OCR z IronOCR. Obiekty te hermetyzują operacje OCR, umożliwiając efektywne zarządzanie zadaniami rozpoznawania tekstu. Ta sekcja demonstruje wykorzystanie obiektów OcrReadTask w twoim przepływie pracy IronOCR i pokazuje, jak inicjują i optymalizują zadania OCR. Obiekty OcrReadTask pomagają wykorzystać maksymalne możliwości IronOCR, gdy organizujesz złożone przetwarzanie dokumentów lub dostrajasz odpowiedzialność aplikacji.

Obiekty OcrReadTask najlepiej działają, gdy:

Potrzebujesz precyzyjnej kontroli nad wykonywaniem zadań
Wdrożenie funkcji tokenu przerwania dla operacji, które można anulować
Zarządzanie wieloma równoczesnymi operacjami OCR o różnych priorytetach
Integracja z niestandardowymi harmonogramami zadań lub silnikami przepływu pracy

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
}

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
'}

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
'}

Jak używać metody `ReadAsync`?

ReadAsync() zapewnia bezpośredni mechanizm do inicjowania operacji OCR asynchronicznie. Bez skomplikowanego wątkowania lub zarządzania zadaniami programiści mogą zintegrować asynchroniczne OCR ze swoimi aplikacjami. Metoda ta zapobiega blokowaniu głównego wątku podczas zadań OCR, zapewniając, że aplikacje pozostają responsywne.

Metoda ReadAsync sprawdza się:

Aplikacje desktopowe, które muszą zachować responsywność interfejsu użytkownika
Aplikacje internetowe obsługujące wiele jednoczesnych żądań OCR
Scenariusze przetwarzania wsadowego, w których niezbędne jest śledzenie postępów
Integracja z nowoczesnymi wzorcami async/await w aplikacjach .NET

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
}

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
'}

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
'}

Dlaczego warto korzystać z asynchroniczności i wielowątkowości w IronOCR?

Połączenie obsługi asynchronicznej i wielowątkowości w IronOCR zapewnia liczne korzyści dla nowoczesnego tworzenia aplikacji:

Korzyści związane z wydajnością:

Zwiększona przepustowość: przetwarzaj wiele dokumentów jednocześnie bez blokowania
Lepsze wykorzystanie zasobów: maksymalizacja wykorzystania procesora we wszystkich dostępnych rdzeniach
Zmniejszone opóźnienia: Rozpocznij przetwarzanie natychmiast, bez czekania na zakończenie poprzednich operacji
Skalowalna architektura: Obsługa rosnącego obciążenia bez zmian architektonicznych

Korzyści dla programistów:

Uproszczony kod: Nie ma potrzeby ręcznego zarządzania wątkami — IronOCR radzi sobie z tą złożonością
Nowoczesne wzorce: Pełna obsługa wzorców async/await w Tesseract 5 dla .NET
Łatwa integracja: płynnie współpracuje z istniejącą infrastrukturą asynchroniczną .NET
Rozwiązania łatwe w utrzymaniu: przejrzysty, czytelny kod zgodny z najlepszymi praktykami .NET

Wielowątkowość w IronOCR znacznie optymalizuje zadania OCR. Wbudowane możliwości wielowątkowości, w połączeniu z metodami jak ReadAsync(), upraszczają obsługę dużych ilości danych tekstowych. To połączenie zapewnia, że aplikacje pozostają responsywne i wydajne, co sprawia, że IronOCR jest skutecznym narzędziem do tworzenia wysokowydajnego oprogramowania z usprawnionymi funkcjami rozpoznawania tekstu. Aby rozpocząć korzystanie z pełnego zestawu funkcji, zapoznaj się z naszym przewodnikiem instalacji pakietu NuGet.

Często Zadawane Pytania

Jak wykonać OCR asynchronicznie w C# bez blokowania głównego wątku?

IronOCR oferuje metodę ReadAsync, która umożliwia wykonywanie OCR bez blokowania. Możesz po prostu użyć `var result = await new IronOcr.IronTesseract().ReadAsync("image.png");`, aby wykonać OCR asynchronicznie, zachowując responsywność aplikacji podczas przetwarzania dokumentów.

Czy OCR automatycznie wykorzystuje wiele rdzeni CPU dla lepszej wydajności?

Tak, IronOCR automatycznie korzysta z wszystkich dostępnych rdzeni CPU dzięki wbudowanej wielowątkowości. Implementacja IronTesseract wykrywa i wykorzystuje wszystkie rdzenie bez potrzeby ręcznej konfiguracji, oferując zoptymalizowane zarządzanie zasobami i skalowalną wydajność.

Jakie są główne korzyści z wielowątkowości w przetwarzaniu OCR?

Wielowątkowa implementacja IronOCR oferuje automatyczne wykorzystanie rdzeni CPU, operacje bezpieczne dla wątków w domyśle, zoptymalizowane zarządzanie zasobami dla pamięci i przetwarzania oraz skalowalną wydajność, gdzie czas przetwarzania zmniejsza się proporcjonalnie do dostępnych rdzeni.

Czy mogę przetwarzać wiele dokumentów PDF jednocześnie za pomocą async OCR?

Tak, metoda ReadAsync od IronOCR szczególnie dobrze sprawdza się przy przetwarzaniu dokumentów PDF lub obsługi wielu plików graficznych jednocześnie, pozwalając na przetwarzanie wielu dokumentów równocześnie bez blokowania aplikacji.

Czy muszę pisać specjalny kod, aby umożliwić wielowątkowość dla OCR?

Nie, IronOCR nie wymaga specjalistycznego API ani ręcznej konfiguracji do wielowątkowości. Biblioteka bezproblemowo integruje równoległość bezpośrednio w przepływie pracy OCR, automatycznie zarządzając wątkami na wielu rdzeniach dla optymalnej wydajności.

Co to jest Obiekt OcrReadTask i jak pomaga w asynchronicznym przetwarzaniu?

Obiekt OcrReadTask w IronOCR umożliwia wykorzystanie asynchronicznej współbieżności podczas przetwarzania dokumentów. Pozwala zarządzać operacjami OCR asynchronicznie, podczas gdy biblioteka zarządza podstawową złożonością wielowątkowości.

Czy IronOCR jest w pełni zgodny z .NET 10?

.NET 10 jest obsługiwany przez IronOCR w najnowszej wersji 2025.12. Możesz zainstalować bibliotekę używając NuGet (Install-Package IronOcr) i uruchamiać metody asynchroniczne jak ReadAsync() pod .NET 10 bez specjalnej konfiguracji.

Does setting MultiThreaded to false actually change anything?

Yes. MultiThreaded had no effect in earlier releases but is now a live setting. Setting it to false reads pages sequentially on a single thread, giving the lowest and most predictable memory footprint, and it overrides MaxDegreeOfParallelism. Code that set this property expecting it to be inert will read sequentially after upgrading.

Is IronOCR fully compatible with .NET 10?

.NET 10 is supported by IronOCR via its latest release version 2025.12. You can install the library using NuGet (Install-Package IronOcr) and run async methods like ReadAsync() under .NET 10 without special configuration.