Wie man asynchrone und Multithreading-Verfahren für QR-Code-Operationen in C# verwendet
Das Scannen von QR-Codes mit nur einem Thread blockiert den aufrufenden Thread für die Dauer jedes Bilddekodierungsvorgangs.
In einem WPF-Button-Handler friert dies die Benutzeroberfläche ein, bis die Dekodierung abgeschlossen ist. Bei der Verarbeitung von Hunderten von Bildern in einem Batch-Job bleiben CPU-Kerne ungenutzt, anstatt parallel zu arbeiten. Die ReadAsync-Methode von IronQR verlagert einzelne Lesevorgänge auf eine wartbare Aufgabe, und die Standardmethode Read arbeitet mit Parallel.ForEach und Task.WhenAll für Batch-Durchsatz.
Dieser Leitfaden zeigt, wie man QR-Codes asynchron verarbeitet, Batch-Lesevorgänge auf die CPU-Kerne verteilt und beide Vorgehensweisen für Pipelines mit hohem Datenvolumen kombiniert.
Schnellstart: QR-Codes asynchron verarbeitenLaden Sie ein Bild und warten Sie auf die Dekodierungsergebnisse, ohne den aufrufenden Thread zu blockieren.
-
1Install IronQR with NuGet Package Manager
-
2Kopieren Sie diesen Codeausschnitt und führen Sie ihn aus.
using IronQr; using IronSoftware.Drawing; var input = new QrImageInput(AnyBitmap.FromFile("ticket.png")); IEnumerable<QrResult> results = await new QrReader().ReadAsync(input); Console.WriteLine(results.First().Value);C# -
3Bereitstellen zum Testen in Ihrer Live-Umgebung
Beginnen Sie noch heute, IronQR in Ihrem Projekt zu verwenden, mit einer kostenlosen Testversion
Minimaler Arbeitsablauf (5 Schritte)
- Laden Sie die IronQR C#-Bibliothek für die asynchrone QR-Code-Verarbeitung herunter.
- Verwenden Sie
ReadAsyncfür nicht blockierende Einzellesevorgänge. - Verwenden Sie
Parallel.ForEachfür die CPU-intensive Stapelverarbeitung. - Kombinieren Sie dies mit
SemaphoreSlimfür Pipelines mit begrenzter Parallelität. - Sammle die Ergebnisse von
IEnumerable<QrResult>und gib die dekodierten Werte aus.
Asynchrones Lesen von QR-Codes
ReadAsync gibt eine wartbare Aufgabe zurück, wodurch sie mit WPF/MAUI-Ereignishandlern, ASP.NET-Controlleraktionen oder jeder asynchronen Methode kompatibel ist. Die Eingabe muss aus einer Bildbitmap erstellt werden; eine Überladung mit Dateipfaden ist nicht möglich.
Die Schreibseite ist synchron und verfügt über keine asynchronen Varianten. Um den Thread während der Datei-I/O nicht zu blockieren, umwickeln Sie den Speichervorgang in File.WriteAllBytesAsync() mit den rohen Bytes, die aus dem Bitmap exportiert werden.
Eingabe
Ein QR-Code-Event-Badge wurde gescannt und neu generiert, um das asynchrone Lese- und Schreibmuster zu demonstrieren.

using IronQr;
using IronQr.Enum;
using IronSoftware.Drawing;
// --- Async read: non-blocking QR decode ---
var inputBmp = AnyBitmap.FromFile("event-badge.png");
var imageInput = new QrImageInput(inputBmp, QrScanMode.Auto);
var reader = new QrReader();
IEnumerable<QrResult> results = await reader.ReadAsync(imageInput);
foreach (QrResult result in results)
{
Console.WriteLine($"[{result.QrType}] {result.Value}");
}
// --- Async-wrapped save: QrWriter.Write() and QrCode.Save() are synchronous ---
QrCode qrCode = QrWriter.Write("https://ironsoftware.com");
AnyBitmap qrImage = qrCode.Save();
// Save the bitmap bytes asynchronously (not an IronQR API — standard .NET async I/O)
byte[] pngBytes = qrImage.ExportBytes();
await File.WriteAllBytesAsync("output-qr.png", pngBytes);
Ausgabe
Das Terminal zeigt den dekodierten QR-Typ und Wert im Format [QrType] Value an und bestätigt dann, dass output-qr.png gespeichert wurde.
![Terminalausgabe mit Anzeige des dekodierten [QRCode]-Werts und Bestätigung zum Speichern der Datei output-qr.png](/static-assets/qr/how-to/async-and-multithreading/test1-async-out.webp)
QrScanMode.Auto führt sowohl eine ML-Erkennung als auch einen grundlegenden Scanvorgang durch, wobei in jedem Ergebnis der dekodierte Wert und der QR-Typ ausgefüllt werden. OnlyDetectionModel ist schneller, gibt jedoch nur die Koordinaten des Begrenzungsrahmens zurück und lässt das Wertfeld leer. Verwenden Sie Auto, wann immer der kodierte Inhalt benötigt wird.
Verarbeitung von QR-Codes mit Multithreading
Für Bilder, die unabhängig dekodiert werden können, verteilt Parallel.ForEach die Arbeit über die verfügbaren CPU-Kerne. Eine separate QrReader-Instanz pro Iteration ist die sichere Standardvorgabe, da IronQR keine explizite Thread-Sicherheitsgarantie für gemeinsam genutzte Leserinstanzen gibt.
Eingabe
Vier der zehn QR-Code-Testbilder, die beim parallelen Stapelscan verwendet wurden. Jedes Bild kodiert eine URL und wird in der Laufzeit aus dem qr-images/-Ordner gelesen.

Bild 1 (Charge 1 von 10)

Bild 2 (Charge 2 von 10)

Bild 3 (Charge 3 von 10)

Bild 4 (Charge 4 von 10)
using IronQr;
using IronQr.Enum;
using IronSoftware.Drawing;
using System.Collections.Concurrent;
using System.Diagnostics;
string[] files = Directory.GetFiles("qr-images/", "*.png");
var allResults = new ConcurrentBag<(string File, string Value)>();
int failCount = 0;
var sw = Stopwatch.StartNew();
Parallel.ForEach(files, new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount }, file =>
{
try
{
var input = new QrImageInput(
AnyBitmap.FromFile(file),
QrScanMode.Auto);
// Per-thread QrReader instance — safe default
var results = new QrReader().Read(input);
foreach (QrResult result in results)
{
allResults.Add((Path.GetFileName(file), result.Value));
}
}
catch (Exception ex)
{
Interlocked.Increment(ref failCount);
Console.Error.WriteLine($"[ERROR] {Path.GetFileName(file)}: {ex.Message}");
}
});
sw.Stop();
Console.WriteLine($"Processed {files.Length} files in {sw.Elapsed.TotalSeconds:F1}s");
Console.WriteLine($"QR codes found: {allResults.Count} | Failures: {failCount}");
Console.WriteLine($"Throughput: {files.Length / sw.Elapsed.TotalSeconds:F1} files/sec");
Ausgabe
Die Konsole zeigt eine Zusammenfassung des Batch-Verarbeitungsvorgangs an, einschließlich der Anzahl der verarbeiteten Dateien, der Verarbeitungszeit, der gefundenen QR-Codes, etwaiger Fehler und des Durchsatzes. Anschließend werden alle Dateinamen mit ihren dekodierten URLs aufgelistet.

Laden Sie alle 10 Test-QR-Code-Eingabebilder herunter (batch-qr-images.zip).
ConcurrentBag<t> sammelt Ergebnisse von allen Threads ohne Sperren zu benötigen. Ein threadsicherer Zähler verfolgt Fehler, und die Verwendung von try-catch für jede Datei stellt sicher, dass ein fehlerhaftes Bild nicht den gesamten Stapel unterbricht. Dieser Ansatz folgt dem im Leitfaden zur Fehlerbehandlung beschriebenen Fehlerisolierungsmuster.
Setzen Sie MaxDegreeOfParallelism auf Environment.ProcessorCount, um die Anzahl der CPU-Kerne abzugleichen. Die Verwendung zusätzlicher Threads erhöht den Overhead und verbessert die Leistung nicht, insbesondere bei CPU-intensiven ML-Modellen.
Kombination von asynchroner und paralleler Verarbeitung
Für hochvolumige Pipelines kombinieren Sie SemaphoreSlim mit Task.WhenAll, um die Parallelität zu begrenzen. Im Gegensatz zu Parallel.ForEach hält dieses Muster I/O nicht blockierend, während es steuert, wie viele Dekodierungen gleichzeitig ablaufen, und verhindert die Auslastung des Thread-Pools bei großen Arbeitslasten.
Eingabe
Von den zwanzig QR-Code-Testbildern wurden vier durch die parallele Pipeline verarbeitet. Jedes Bild kodiert eine URL und wird parallel mit begrenzter Parallelität über SemaphoreSlim dekodiert.

Abbildung 1 (Pipeline 1 von 20)

Bild 2 (Pipeline 2 von 20)

Abbildung 3 (Pipeline 3 von 20)

Abbildung 4 (Pipeline 4 von 20)
using IronQr;
using IronQr.Enum;
using IronSoftware.Drawing;
using System.Collections.Concurrent;
using System.Diagnostics;
string[] files = Directory.GetFiles("high-volume/", "*.png");
var results = new ConcurrentBag<(string File, string Value)>();
int maxConcurrency = Environment.ProcessorCount;
using var semaphore = new SemaphoreSlim(maxConcurrency);
var sw = Stopwatch.StartNew();
var tasks = files.Select(async file =>
{
await semaphore.WaitAsync();
try
{
var bmp = AnyBitmap.FromFile(file);
// Auto: runs ML detection plus a basic scan so result.Value is populated
var input = new QrImageInput(bmp, QrScanMode.Auto);
var qrResults = await new QrReader().ReadAsync(input);
foreach (var qr in qrResults)
{
results.Add((Path.GetFileName(file), qr.Value));
}
}
catch (Exception ex)
{
Console.Error.WriteLine($"{{\"file\":\"{Path.GetFileName(file)}\",\"error\":\"{ex.Message}\"}}");
}
finally
{
semaphore.Release();
}
});
await Task.WhenAll(tasks);
sw.Stop();
Console.WriteLine($"Pipeline complete: {results.Count} QR codes from {files.Length} files in {sw.Elapsed.TotalSeconds:F1}s");
Ausgabe
Die Konsole zeigt nach Abschluss der Pipeline eine Zusammenfassung an: Gesamtzahl der dekodierten QR-Codes, Anzahl der Quelldateien und verstrichene Zeit, gefolgt von jedem Dateinamen und seiner dekodierten URL.

Laden Sie alle 20 QR-Code-Eingabebilder der Testpipeline herunter (high-volume-qr-images.zip).
Passen Sie das Semaphorlimit an die Anzahl der verfügbaren Kerne an, um einen hohen Durchsatz zu erzielen, oder verringern Sie es, wenn der Speicherdruck bei großen Images ein Problem darstellt.
Weiterführende Literatur
- Beispiel für ML-Scanning : Vergleich des Scanmodus mit Codebeispielen.
- Anleitung zum Lesen von QR-Codes : Eingabeaufbau und grundlegende Lesemuster.
- QR-Code-Generator-Tutorial : Generierung mit Styling.
- QrReader API-Referenz : Methodensignaturen und Anmerkungen.
- QrWriter API-Referenz : alle Schreibüberladungen.
- Anleitung zur Fehlerbehandlung : Fehlerisolierung und Protokollierungsmuster pro Datei.
Die Lizenzierungsoptionen können Sie einsehen , sobald die Pipeline produktionsbereit ist.
Häufig gestellte Fragen
Was ist die asynchrone QR-Code-Verarbeitung in C#?
Asynchrone QR-Code-Verarbeitung in C# ermöglicht es Ihnen, QR-Code-Operationen durchzuführen, ohne den Hauptthread zu blockieren, indem Funktionen wie IronQRs ReadAsync-Methode verwendet werden, um Leistung und Reaktionsfähigkeit zu verbessern.
Wie kann Multithreading die QR-Code-Verarbeitung verbessern?
Multithreading kann die QR-Code-Verarbeitung erheblich verbessern, indem es ermöglicht, dass mehrere Operationen gleichzeitig ablaufen, was zu schnelleren Verarbeitungszeiten und einer verbesserten Anwendungseffizienz durch die Nutzung von IronQR führt.
Was ist die ReadAsync-Methode in IronQR?
Die ReadAsync-Methode in IronQR ermöglicht ein asynchrones Lesen von QR-Codes, sodass Ihre C#-Anwendung QR-Code-Daten verarbeiten kann, ohne andere Aufgaben zu verzögern.
Wie hilft Parallel.ForEach bei der QR-Code-Verarbeitung?
Parallel.ForEach ermöglicht die gleichzeitige Verarbeitung mehrerer QR-Codes, indem Aufgaben auf mehrere Threads verteilt werden, was effizient mit IronQR genutzt werden kann, um QR-Code-Operationen zu beschleunigen.
Welche Rolle spielt SemaphoreSlim bei QR-Code-Operationen?
SemaphoreSlim wird verwendet, um die Anzahl der gleichzeitigen Aufgaben zu begrenzen und die Ressourcen effektiv während der parallelen Verarbeitung von QR-Codes mit IronQR zu verwalten.
Kann IronQR zur Verarbeitung von QR-Codes in einer begrenzten Pipeline verwendet werden?
Ja, IronQR kann zur Verarbeitung von QR-Codes in einer begrenzten Pipeline verwendet werden, indem Konstrukte wie SemaphoreSlim genutzt werden, um die Konkurrenz und Ressourcenverteilung effektiv zu steuern.
Welche Vorteile bietet die Verwendung von IronQR für asynchrone QR-Code-Operationen?
Die Verwendung von IronQR für asynchrone QR-Code-Operationen verbessert die Anwendungsreaktionsfähigkeit, reduziert Blockierungen des Hauptthreads und ermöglicht eine effiziente Verarbeitung großer Datenmengen von QR-Codes.
Ist es möglich, QR-Code-Operationen parallel mit IronQR auszuführen?
Ja, IronQR unterstützt die parallele Verarbeitung von QR-Code-Operationen, sodass Sie die Multithreading-Fähigkeiten in C# für eine schnellere und effizientere QR-Code-Verarbeitung nutzen können.
Wie verbessert IronQR die QR-Code-Verarbeitung in C#-Anwendungen?
IronQR verbessert die QR-Code-Verarbeitung durch robuste asynchrone und Multithreading-Fähigkeiten, die die Verarbeitungszeiten reduzieren und die Skalierbarkeit von C#-Anwendungen verbessern.
Welche C#-Funktionen ergänzen die Verwendung von IronQR für die QR-Code-Verarbeitung?
C#-Funktionen wie async/await, Parallel.ForEach und SemaphoreSlim ergänzen IronQR und bieten ein Framework für eine effiziente und leistungsstarke QR-Code-Verarbeitung.

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender Handbücher.