Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronOCR
  2. IronOCR Blog
  3. Verwendung von IronOCR
  4. .NET OCR SDK
VERWENDUNG VON IRONOCR

Wie man ein .NET OCR SDK mit IronOCR erstellt

Kannaopat Udonpant
Kannapat Udonpant
Veröffentlicht:

Angenommen, Sie mussten jemals Text aus gescannten Dokumenten, PDFs oder Bildern extrahieren. In diesem Fall wissen Sie, wie schwierig es sein kann, mit verschiedenen Dateiformaten, mehreren Sprachen und minderwertigen Scans umzugehen. Hier kommt OCR (optische Zeichenerkennung) ins Spiel, das gescannte Bilder und Dokumentdateien in bearbeitbaren Text umwandelt, mit dem Sie programmatisch arbeiten können.

In diesem Leitfaden werden wir untersuchen, wie man ein leistungsstarkes .NET OCR SDK mit IronOCR erstellt, das Ihnen zeigt, wie man OCR durchführt, strukturierte Daten extrahiert und durchsuchbare PDFs über mehrere Dokumenttypen hinweg generiert. Sie lernen, wie man gescannte PDFs, Bilder und andere Textdateien verarbeitet, auf eine Weise, die schnell, zuverlässig ist und sich nahtlos in .NET-Anwendungen auf Desktops, Web- oder mobilen Geräten integriert.

Was macht IronOCR zum idealen .NET OCR SDK?

Der Aufbau einer OCR-Bibliothek von Grund auf erfordert Monate der Entwicklung, Bildvorverarbeitung und umfangreiche Tests. IronOCR eliminiert diesen Aufwand, indem es ein umfassendes .NET OCR SDK bereitstellt, das verschiedene Formate unterstützt und nahtlos in .NET-Anwendungen integriert wird.

Das SDK übernimmt die Schwerarbeit der Texterkennung, während es Eigenschaften bietet, die normalerweise nur in Unternehmenslösungen zu finden sind:

  • Hohe Leistung über verschiedene Dokumentformate und gescannte Bilder hinweg
  • Unterstützung für 125+ Sprachen und handschriftliche Texterkennung
  • Adaptive Binarisierung, Schriftinformationen und Unterstützung von Begrenzungsrahmen für zonale OCR
  • Fähigkeit zur Verarbeitung gescannter PDFs, Bildformate und Textblöcke
  • Sofortige Erstellung durchsuchbarer Dokumente mit versteckten Textschichten

Im Gegensatz zu rohen Tesseract-Implementierungen funktioniert IronOCR sofort auf Windows, Linux, macOS und Cloud-Plattformen und unterstützt OCR-APIs, KI-unterstützte Erkennung und nahtlose Integration ohne zusätzliche Konfiguration.

Einstieg mit IronOCR

Die Installation dauert Sekunden über den NuGet-Paketmanager. Ausführen:

Install-Package IronOcr

Für detaillierte Installationsanweisungen siehe die IronOCR-Dokumentation. Einmal installiert, wird die Textextraktion aus gescannten Dokumenten unkompliziert:

using IronOcr;
public class OcrService
{
    private readonly IronTesseract _ocr;
    public OcrService()
    {
        _ocr = new IronTesseract();
    }
    public string ExtractText(string imagePath)
    {
        using var input = new OcrInput();
        input.LoadImage(imagePath);
        var result = _ocr.Read(input);
        return result.Text;
    }
}
using IronOcr;
public class OcrService
{
    private readonly IronTesseract _ocr;
    public OcrService()
    {
        _ocr = new IronTesseract();
    }
    public string ExtractText(string imagePath)
    {
        using var input = new OcrInput();
        input.LoadImage(imagePath);
        var result = _ocr.Read(input);
        return result.Text;
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Dieser Code erstellt einen wiederverwendbaren OCR-Dienst, der verschiedene Bildformate, einschließlich JPEG, PNG, TIFF und BMP, sowie PDF-Dokumente und andere Dokumentformate automatisch verarbeitet.

Um es zu testen, führen wir es durch unsere Hauptklasse mit diesem Beispielbild:

class Program
{
    static void Main(string[] args)
    {
        var ocrService = new OcrService();
        string imagePath = "test.png"; // Replace with your image path
        string extractedText = ocrService.ExtractText(imagePath);
        Console.WriteLine(extractedText);
    }
}
class Program
{
    static void Main(string[] args)
    {
        var ocrService = new OcrService();
        string imagePath = "test.png"; // Replace with your image path
        string extractedText = ocrService.ExtractText(imagePath);
        Console.WriteLine(extractedText);
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Ausgabe

Wie man ein .NET OCR SDK mit IronOCR erstellt: Abbildung 2 - Beispiel Konsolenausgabe

Kern-OCR-Funktionalität aufbauen

Echte Anwendungen benötigen mehr als nur einfache Textextraktion. IronOCR bietet umfassende Dokumentverarbeitungsfähigkeiten:

// Async document processing with barcodes
 public async Task<ProcessedDocument> ProcessDocumentAsync(string filePath)
 {
     using var input = new OcrInput();
     LoadFile(input, filePath);
     input.DeNoise();
     input.Deskew();
     var result = await _ocr.ReadAsync(input);
     return new ProcessedDocument
     {
         Text = result.Text,
         Confidence = result.Confidence,
         Barcodes = result.Barcodes.Select(b => b.Value).ToList()
     };
 }
// Helper to load image or PDF
private void LoadFile(OcrInput input, string filePath)
{
    if (filePath.EndsWith(".pdf", StringComparison.OrdinalIgnoreCase))
        input.LoadPdf(filePath);
    else
        input.LoadImage(filePath);
}
// Model for processed documents with barcodes
public class ProcessedDocument
{
    public string Text { get; set; }
    public double Confidence { get; set; }
    public List<string> Barcodes { get; set; }
}
// Async document processing with barcodes
 public async Task<ProcessedDocument> ProcessDocumentAsync(string filePath)
 {
     using var input = new OcrInput();
     LoadFile(input, filePath);
     input.DeNoise();
     input.Deskew();
     var result = await _ocr.ReadAsync(input);
     return new ProcessedDocument
     {
         Text = result.Text,
         Confidence = result.Confidence,
         Barcodes = result.Barcodes.Select(b => b.Value).ToList()
     };
 }
// Helper to load image or PDF
private void LoadFile(OcrInput input, string filePath)
{
    if (filePath.EndsWith(".pdf", StringComparison.OrdinalIgnoreCase))
        input.LoadPdf(filePath);
    else
        input.LoadImage(filePath);
}
// Model for processed documents with barcodes
public class ProcessedDocument
{
    public string Text { get; set; }
    public double Confidence { get; set; }
    public List<string> Barcodes { get; set; }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Diese Implementierung verarbeitet mehrere Dokumente, wendet Bildvorverarbeitung an und extrahiert Barcodes und Text aus demselben Dokument. Das asynchrone Muster sorgt für hohe Leistung in .NET-Anwendungen.

Ausgabe

Wie man ein .NET OCR SDK mit IronOCR erstellt: Abbildung 3 - OCR-Eingabebild vs. Ausgabe-Text

Genauigkeit verbessern mit eingebauten Funktionen

IronOCRs Vorverarbeitungsfähigkeiten verbessern die Erkennungsgenauigkeit bei echten Dokumenten erheblich:

// OCR optimized for low-quality images
    public string ProcessLowQualityDocument(string filePath)
    {
        using var input = new OcrInput();
        LoadFile(input, filePath);
        // Preprocessing for low-quality documents
        input.DeNoise();
        input.Deskew();
        input.Scale(150);
        input.Binarize();
        input.EnhanceResolution(300);
        var result = _ocr.Read(input);
        return result.Text;
    }
// OCR optimized for low-quality images
    public string ProcessLowQualityDocument(string filePath)
    {
        using var input = new OcrInput();
        LoadFile(input, filePath);
        // Preprocessing for low-quality documents
        input.DeNoise();
        input.Deskew();
        input.Scale(150);
        input.Binarize();
        input.EnhanceResolution(300);
        var result = _ocr.Read(input);
        return result.Text;
    }
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Jeder Filter zielt auf spezifische Probleme der Dokumentqualität ab. DeNoise() entfernt Artefakte vom Scannen, Deskew() korrigiert geneigte Seiten, und EnhanceResolution() schärft unscharfen Text.

Diese Filter arbeiten zusammen, um von minderwertigen Quellen einen genauen Textextraktion zu erreichen. Laut Diskussionen auf Stack Overflow kann eine ordnungsgemäße Vorverarbeitung die OCR-Genauigkeit um bis zu 40% verbessern.

Erweiterte Datenextraktion-SDK-Fähigkeiten

IronOCR geht über die einfache Textextraktion hinaus mit Funktionen, die für moderne .NET OCR SDK-Anwendungen unerlässlich sind:

// Create a searchable PDF from an image or PDF
  public void CreateSearchablePdf(string inputPath, string outputPath)
  {
      using var input = new OcrInput();
      LoadFile(input, inputPath);
      _ocr.Read(input).SaveAsSearchablePdf(outputPath);
  }
  // Extract structured data (phone numbers, emails, amounts) from text
  public List<string> ExtractStructuredData(string filePath)
  {
      using var input = new OcrInput();
      LoadFile(input, filePath);
      var result = _ocr.Read(input);
      var text = result.Text;
      var phoneNumbers = Regex.Matches(text, @"\+?\d[\d\s\-]{7,}\d")
                              .Select(m => m.Value).ToList();
      var emails = Regex.Matches(text, @"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-z]{2,}")
                        .Select(m => m.Value).ToList();
      var amounts = Regex.Matches(text, @"\$\d+(?:\.\d{2})?")
                         .Select(m => m.Value).ToList();
      return phoneNumbers.Concat(emails).Concat(amounts).ToList();
  }
// Create a searchable PDF from an image or PDF
  public void CreateSearchablePdf(string inputPath, string outputPath)
  {
      using var input = new OcrInput();
      LoadFile(input, inputPath);
      _ocr.Read(input).SaveAsSearchablePdf(outputPath);
  }
  // Extract structured data (phone numbers, emails, amounts) from text
  public List<string> ExtractStructuredData(string filePath)
  {
      using var input = new OcrInput();
      LoadFile(input, filePath);
      var result = _ocr.Read(input);
      var text = result.Text;
      var phoneNumbers = Regex.Matches(text, @"\+?\d[\d\s\-]{7,}\d")
                              .Select(m => m.Value).ToList();
      var emails = Regex.Matches(text, @"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-z]{2,}")
                        .Select(m => m.Value).ToList();
      var amounts = Regex.Matches(text, @"\$\d+(?:\.\d{2})?")
                         .Select(m => m.Value).ToList();
      return phoneNumbers.Concat(emails).Concat(amounts).ToList();
  }
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Der hier geschriebene Code zeigt zwei wichtige OCR-Operationen. CreateSearchablePdf konvertiert ein eingehendes gescanntes PDF oder Bild in ein durchsuchbares Dokument mit bearbeitbarem Text, um die Texterkennung über mehrere Dokumentformate hinweg zu erleichtern.

ExtractStructuredData verarbeitet dasselbe gescannte Dokument, um Daten wie Telefonnummern, E-Mails und Beträge aus verschiedenen Dokumenttypen zu extrahieren, wodurch .NET-Anwendungen gescannte Bilder, Textdateien und PDF-Dokumente effizient behandeln können.

Produktionsreife Implementierung

IronOCR selbstbewusst mit eingebauten Produktionsfunktionen bereitstellen:

public class ProductionOcrService
{
    private readonly IronTesseract _ocr;
    private readonly ILogger _logger;
    public ProductionOcrService(ILogger logger)
    {
        _logger = logger;
        _ocr = new IronTesseract();
        // Production configuration
        _ocr.Configuration.RenderSearchablePdfsAndHocr = true;
        _ocr.Configuration.ReadBarCodes = true;
    }
    public async Task<string> ProcessBatchAsync(string[] documents)
    {
        var results = new List<string>();
        // Parallel processing for performance
        await Parallel.ForEachAsync(documents, async (doc, ct) =>
        {
            try
            {
                var text = await ExtractTextAsync(doc);
                results.Add(text);
                _logger.LogInformation($"Processed: {doc}");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, $"Failed: {doc}");
            }
        });
        return string.Join("\n", results);
    }
}
public class ProductionOcrService
{
    private readonly IronTesseract _ocr;
    private readonly ILogger _logger;
    public ProductionOcrService(ILogger logger)
    {
        _logger = logger;
        _ocr = new IronTesseract();
        // Production configuration
        _ocr.Configuration.RenderSearchablePdfsAndHocr = true;
        _ocr.Configuration.ReadBarCodes = true;
    }
    public async Task<string> ProcessBatchAsync(string[] documents)
    {
        var results = new List<string>();
        // Parallel processing for performance
        await Parallel.ForEachAsync(documents, async (doc, ct) =>
        {
            try
            {
                var text = await ExtractTextAsync(doc);
                results.Add(text);
                _logger.LogInformation($"Processed: {doc}");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, $"Failed: {doc}");
            }
        });
        return string.Join("\n", results);
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Dieses Muster demonstriert parallele Verarbeitung für Batch-Operationen, strukturierte Protokollierung zur Überwachung und handhabungssichere Fehlerbehandlung, die verhindert, dass einzelne Dokumentausfälle ganze Chargen aufhalten.

Echtweltanwendung: Rechnungsverarbeitung

So verwenden Organisationen IronOCR als ihr .NET OCR SDK, um die Rechnungsverarbeitung zu automatisieren:

// Extract structured invoice data
    public Invoice ExtractInvoiceData(string invoicePath)
    {
        using var input = new OcrInput();
        LoadFile(input, invoicePath);
        // Preprocessing for documents
        input.DeNoise();
        input.Deskew();
        var result = _ocr.Read(input);
        var text = result.Text;
        return new Invoice
        {
            InvoiceNumber = ExtractInvoiceNumber(text),
            Date = ExtractDate(text),
            TotalAmount = ExtractAmount(text),
            RawText = text
        };
    }
    // --- Helper methods for invoice parsing ---
    private string ExtractInvoiceNumber(string text)
    {
        // Example: Invoice #: 12345
        var match = Regex.Match(text, @"Invoice\s*#?:?\s*(\S+)");
        return match.Success ? match.Groups[1].Value : null;
    }
    private DateOnly? ExtractDate(string text)
    {
        // Numeric dates
        var numericMatch = Regex.Match(text, @"\b(\d{1,2}/\d{1,2}/\d{2,4})\b");
        if (numericMatch.Success && DateTime.TryParse(numericMatch.Groups[1].Value, out var numericDate))
            return DateOnly.FromDateTime(numericDate);
        // Written-out dates
        var writtenMatch = Regex.Match(text,
            @"\b(January|February|March|April|May|June|July|August|September|October|November|December)\s+(\d{1,2}),?\s+(\d{4})\b",
            RegexOptions.IgnoreCase);
        if (writtenMatch.Success && DateTime.TryParse(writtenMatch.Value, out var writtenDate))
            return DateOnly.FromDateTime(writtenDate);
        return null;
    }
    private decimal? ExtractAmount(string text)
    {
        var match = Regex.Match(text, @"\$\s*(\d+(?:\.\d{2})?)");
        if (match.Success && decimal.TryParse(match.Groups[1].Value, out var amount))
            return amount;
        return null;
    }
// Extract structured invoice data
    public Invoice ExtractInvoiceData(string invoicePath)
    {
        using var input = new OcrInput();
        LoadFile(input, invoicePath);
        // Preprocessing for documents
        input.DeNoise();
        input.Deskew();
        var result = _ocr.Read(input);
        var text = result.Text;
        return new Invoice
        {
            InvoiceNumber = ExtractInvoiceNumber(text),
            Date = ExtractDate(text),
            TotalAmount = ExtractAmount(text),
            RawText = text
        };
    }
    // --- Helper methods for invoice parsing ---
    private string ExtractInvoiceNumber(string text)
    {
        // Example: Invoice #: 12345
        var match = Regex.Match(text, @"Invoice\s*#?:?\s*(\S+)");
        return match.Success ? match.Groups[1].Value : null;
    }
    private DateOnly? ExtractDate(string text)
    {
        // Numeric dates
        var numericMatch = Regex.Match(text, @"\b(\d{1,2}/\d{1,2}/\d{2,4})\b");
        if (numericMatch.Success && DateTime.TryParse(numericMatch.Groups[1].Value, out var numericDate))
            return DateOnly.FromDateTime(numericDate);
        // Written-out dates
        var writtenMatch = Regex.Match(text,
            @"\b(January|February|March|April|May|June|July|August|September|October|November|December)\s+(\d{1,2}),?\s+(\d{4})\b",
            RegexOptions.IgnoreCase);
        if (writtenMatch.Success && DateTime.TryParse(writtenMatch.Value, out var writtenDate))
            return DateOnly.FromDateTime(writtenDate);
        return null;
    }
    private decimal? ExtractAmount(string text)
    {
        var match = Regex.Match(text, @"\$\s*(\d+(?:\.\d{2})?)");
        if (match.Success && decimal.TryParse(match.Groups[1].Value, out var amount))
            return amount;
        return null;
    }
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Dieser Ansatz verarbeitet täglich Tausende von Rechnungen und extrahiert Schlüsselfelder für die automatische Eingabe in Buchhaltungssysteme.

Ausgabe

Wie man ein .NET OCR SDK mit IronOCR erstellt: Abbildung 4 - Rechnung OCR-Ausgabe

Abschluss

IronOCR verwandelt .NET-Anwendungen in ausgeklügelte Dokumentverarbeitungslösungen ohne die Komplexität, OCR von Grund auf neu zu erstellen. Mit umfangreicher Sprachunterstützung, überlegener Genauigkeit und produktionsreifen Funktionen ist es das komplette .NET OCR SDK, dem Entwickler für Unternehmensanwendungen vertrauen.

IronOCR bietet flexible Lizenzierungsoptionen, die bei $liteLicense für die Einzelnutzer-Lizenz beginnen und sich auf Unternehmensbereitstellungen skalieren lassen. Das lizenzfreie Modell bedeutet keine zusätzlichen Kosten bei der Verteilung Ihrer OCR SDK-Anwendungen an Kunden.

Bereit, Ihr .NET OCR SDK zu erstellen? Starten Sie Ihre kostenlose Testphase, um noch heute mit dem Bau von Produktanwendungen zu beginnen.

NuGet Mit NuGet installieren

PM >  Install-Package IronOcr

Schauen Sie sich IronOCR auf NuGet für eine schnelle Installation an. Mit über 10 Millionen Downloads transformiert es die PDF-Entwicklung mit C#. Sie können auch das DLL oder den Windows Installer herunterladen.

Häufig gestellte Fragen

Was ist das .NET OCR SDK?

Das .NET OCR SDK von IronOCR ist eine Bibliothek, die entwickelt wurde, um optische Zeichenerkennung in C#-Anwendungen zu integrieren, wodurch Entwickler Text aus Bildern, PDFs und gescannten Dokumenten extrahieren können.

Was sind die Hauptmerkmale des .NET SDK von IronOCR?

Das .NET SDK von IronOCR bietet eine einfache API, Unterstützung für mehrere Sprachen, plattformübergreifende Kompatibilität und erweiterte Funktionen für die Verarbeitung verschiedener Dateiformate und schlecht gescannter Dokumente.

Wie geht IronOCR mit verschiedenen Sprachen um?

Das .NET SDK von IronOCR unterstützt mehrere Sprachen und ermöglicht die Textextraktion und -erkennung aus Dokumenten in verschiedenen Sprachen, ohne dass zusätzliche Konfigurationen erforderlich sind.

Kann IronOCR schlecht gescannte Dokumente verarbeiten?

Ja, IronOCR ist darauf ausgelegt, schlecht gescannte Dokumente effektiv zu bearbeiten und setzt fortschrittliche Algorithmen ein, um die Genauigkeit der Texterkennung auch in herausfordernden Szenarien zu verbessern.

Ist das .NET SDK von IronOCR plattformübergreifend?

Das .NET SDK von IronOCR ist plattformübergreifend, was bedeutet, dass es auf verschiedenen Betriebssystemen verwendet werden kann und somit vielseitig für verschiedene Entwicklungsumgebungen einsetzbar ist.

Welche Dateiformate unterstützt IronOCR?

IronOCR unterstützt eine breite Palette von Dateiformaten, einschließlich Bildern, PDFs und gescannten Dokumenten, und bietet Flexibilität für Texterkennungsaufgaben in verschiedenen Medien.

Wie können Entwickler IronOCR in ihre Projekte integrieren?

Entwickler können IronOCR einfach in ihre C#-Projekte integrieren, indem sie seine benutzerfreundliche API nutzen, die den Prozess der Hinzufügung von OCR-Funktionalitäten zu Anwendungen vereinfacht.

Welche Anwendungsfälle gibt es für IronOCR?

IronOCR kann in Dokumentenmanagementsystemen, automatisierter Dateneingabe, Inhaltsdigitalisierung und jeder Anwendung, die Textextraktion aus Bildern oder PDFs benötigt, eingesetzt werden.

Kannaopat Udonpant
Kannapat Udonpant
  Jetzt mit dem Ingenieurteam chatten
Software Ingenieur
Bevor er Software-Ingenieur wurde, absolvierte Kannapat ein PhD in Umweltressourcen an der Hokkaido University in Japan. Während seines Studiums wurde Kannapat auch Mitglied des Vehicle Robotics Laboratory, das Teil der Fakultät für Bioproduktionstechnik ist. Im Jahr 2022 nutzte er seine C#-Kenntnisse, um dem Engineering-Team von Iron Software ...
Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Testversion