IronBarcode 与 Open Source Barcode Reader .NET 的比较

// Example: Handling poor quality barcodes with image correction
using IronBarCode;

BarcodeReaderOptions options = new BarcodeReaderOptions
{
    // Apply multiple image filters to improve readability
    ImageFilters = new ImageFilterCollection
    {
        new AdaptiveThresholdFilter(),  // Handles varying lighting
        new ContrastFilter(1.5f),       // Improves contrast
        new DenoiseFilter(),            // Removes noise
        new SharpenFilter()             // Reduces blur
    },
    AutoRotate = true,                  // Corrects orientation
    Speed = ReadingSpeed.Detailed       // Thorough analysis
};

BarcodeResults results = BarcodeReader.Read("poor-quality-scan.jpg", options);

' Example: Handling poor quality barcodes with image correction
Imports IronBarCode

Dim options As New BarcodeReaderOptions With {
    .ImageFilters = New ImageFilterCollection From {
        New AdaptiveThresholdFilter(),  ' Handles varying lighting
        New ContrastFilter(1.5F),       ' Improves contrast
        New DenoiseFilter(),            ' Removes noise
        New SharpenFilter()             ' Reduces blur
    },
    .AutoRotate = True,                 ' Corrects orientation
    .Speed = ReadingSpeed.Detailed      ' Thorough analysis
}

Dim results As BarcodeResults = BarcodeReader.Read("poor-quality-scan.jpg", options)

// Example: Creating and customizing barcodes with full documentation support
using IronBarCode;

// Create a barcode with extensive customization options
GeneratedBarcode myBarcode = BarcodeWriter.CreateBarcode("SKU-123456", BarcodeEncoding.Code128);

// Apply styling with documented methods
myBarcode.ChangeBarCodeColor(System.Drawing.Color.DarkBlue);
myBarcode.SetMargins(10);
myBarcode.ResizeTo(300, 150);
myBarcode.AddBarcodeValueTextBelowBarcode();
myBarcode.AddAnnotationTextAboveBarcode("Product Label");

// Export in various formats
myBarcode.SaveAsPng("barcode.png");
myBarcode.SaveAsPdf("barcode.pdf");
byte[] barcodeBytes = myBarcode.ToPngBinaryData();

' Example: Creating and customizing barcodes with full documentation support
Imports IronBarCode

' Create a barcode with extensive customization options
Dim myBarcode As GeneratedBarcode = BarcodeWriter.CreateBarcode("SKU-123456", BarcodeEncoding.Code128)

' Apply styling with documented methods
myBarcode.ChangeBarCodeColor(System.Drawing.Color.DarkBlue)
myBarcode.SetMargins(10)
myBarcode.ResizeTo(300, 150)
myBarcode.AddBarcodeValueTextBelowBarcode()
myBarcode.AddAnnotationTextAboveBarcode("Product Label")

' Export in various formats
myBarcode.SaveAsPng("barcode.png")
myBarcode.SaveAsPdf("barcode.pdf")
Dim barcodeBytes As Byte() = myBarcode.ToPngBinaryData()

using IronBarCode;
using System;
// Read a barcode with a single line
BarcodeResults results = BarcodeReader.Read("barcode-image.png");
// Process the results
foreach (BarcodeResult result in results)
{
    Console.WriteLine($"Barcode Type: {result.BarcodeType}");
    Console.WriteLine($"Barcode Value: {result.Text}");
}

Imports IronBarCode
Imports System

' Read a barcode with a single line
Dim results As BarcodeResults = BarcodeReader.Read("barcode-image.png")

' Process the results
For Each result As BarcodeResult In results
    Console.WriteLine($"Barcode Type: {result.BarcodeType}")
    Console.WriteLine($"Barcode Value: {result.Text}")
Next

using IronBarCode;
// Extract barcodes from PDF documents
BarcodeResults pdfResults = BarcodeReader.ReadPdf("shipping-manifest.pdf");
foreach (BarcodeResult barcode in pdfResults)
{
    Console.WriteLine($"Page {barcode.PageNumber}: {barcode.Text}");
}
// Read specific pages for efficiency
var specificPages = new int[] { 1, 3, 5 };
BarcodeResults selectedResults = BarcodeReader.ReadPdf("document.pdf", specificPages);
// Apply PDF-specific options
PdfBarcodeReaderOptions pdfOptions = new PdfBarcodeReaderOptions
{
    PageNumbers = new int[] { 1, 2, 3 },
    Scale = 3.5,  // Higher scale for better quality
    DPI = 300,    // Resolution for rasterization
    Password = "secure123"  // For encrypted PDFs
};
BarcodeResults secureResults = BarcodeReader.ReadPdf("encrypted.pdf", pdfOptions);

Imports IronBarCode
' Extract barcodes from PDF documents
Dim pdfResults As BarcodeResults = BarcodeReader.ReadPdf("shipping-manifest.pdf")
For Each barcode As BarcodeResult In pdfResults
    Console.WriteLine($"Page {barcode.PageNumber}: {barcode.Text}")
Next
' Read specific pages for efficiency
Dim specificPages As Integer() = New Integer() {1, 3, 5}
Dim selectedResults As BarcodeResults = BarcodeReader.ReadPdf("document.pdf", specificPages)
' Apply PDF-specific options
Dim pdfOptions As New PdfBarcodeReaderOptions With {
    .PageNumbers = New Integer() {1, 2, 3},
    .Scale = 3.5,  ' Higher scale for better quality
    .DPI = 300,    ' Resolution for rasterization
    .Password = "secure123"  ' For encrypted PDFs
}
Dim secureResults As BarcodeResults = BarcodeReader.ReadPdf("encrypted.pdf", pdfOptions)

// Example: Advanced PDF barcode extraction with filtering
using IronBarCode;
using System.Linq;

PdfBarcodeReaderOptions advancedPdfOptions = new PdfBarcodeReaderOptions
{
    PageNumbers = Enumerable.Range(1, 50).ToArray(), // First 50 pages
    Scale = 2.0,
    DPI = 200,
    MaxParallelThreads = 8,
    ExpectBarcodeTypes = BarcodeEncoding.Code128 | BarcodeEncoding.QRCode,
    ImageFilters = new ImageFilterCollection
    {
        new ContrastFilter(1.2f),
        new SharpenFilter()
    }
};

// Process large PDF with progress tracking
var pdfPath = "large-document.pdf";
BarcodeResults results = BarcodeReader.ReadPdf(pdfPath, advancedPdfOptions);

// Group results by page
var pageGroups = results.GroupBy(r => r.PageNumber);
foreach (var group in pageGroups)
{
    Console.WriteLine($"Page {group.Key}: Found {group.Count()} barcodes");
    foreach (var barcode in group)
    {
        Console.WriteLine($"  - {barcode.BarcodeType}: {barcode.Text}");
    }
}

' Example: Advanced PDF barcode extraction with filtering
Imports IronBarCode
Imports System.Linq

Dim advancedPdfOptions As New PdfBarcodeReaderOptions With {
    .PageNumbers = Enumerable.Range(1, 50).ToArray(), ' First 50 pages
    .Scale = 2.0,
    .DPI = 200,
    .MaxParallelThreads = 8,
    .ExpectBarcodeTypes = BarcodeEncoding.Code128 Or BarcodeEncoding.QRCode,
    .ImageFilters = New ImageFilterCollection From {
        New ContrastFilter(1.2F),
        New SharpenFilter()
    }
}

' Process large PDF with progress tracking
Dim pdfPath = "large-document.pdf"
Dim results As BarcodeResults = BarcodeReader.ReadPdf(pdfPath, advancedPdfOptions)

' Group results by page
Dim pageGroups = results.GroupBy(Function(r) r.PageNumber)
For Each group In pageGroups
    Console.WriteLine($"Page {group.Key}: Found {group.Count()} barcodes")
    For Each barcode In group
        Console.WriteLine($"  - {barcode.BarcodeType}: {barcode.Text}")
    Next
Next

using IronBarCode;
using System.Threading.Tasks;
using System.Linq;
// Process multiple documents simultaneously
string[] documents = new string[]
{
    "invoice1.pdf",
    "shipping-label.png",
    "inventory-report.pdf",
    "product-catalog.tiff"
};
BarcodeReaderOptions batchOptions = new BarcodeReaderOptions
{
    Multithreaded = true,
    MaxParallelThreads = 4,
    Speed = ReadingSpeed.Balanced
};
// Process all documents in parallel
BarcodeResults allResults = BarcodeReader.Read(documents, batchOptions);
// Or use async for non-blocking operations
async Task<BarcodeResults> ProcessBatchAsync()
{
    var tasks = documents.Select(doc => 
        Task.Run(() => BarcodeReader.Read(doc, batchOptions))
    ).ToArray();

    var results = await Task.WhenAll(tasks);

    // Combine all results
    var combined = new BarcodeResults();
    foreach (var result in results)
    {
        combined.AddRange(result);
    }

    return combined;
}
// Process with progress reporting
async Task ProcessWithProgress(IProgress<int> progress)
{
    int processed = 0;
    var tasks = documents.Select(async (doc, index) =>
    {
        var result = await Task.Run(() => BarcodeReader.Read(doc, batchOptions));
        Interlocked.Increment(ref processed);
        progress.Report((processed * 100) / documents.Length);
        return result;
    }).ToArray();

    await Task.WhenAll(tasks);
}

Imports IronBarCode
Imports System.Threading.Tasks
Imports System.Linq
Imports System.Threading

' Process multiple documents simultaneously
Dim documents As String() = New String() {
    "invoice1.pdf",
    "shipping-label.png",
    "inventory-report.pdf",
    "product-catalog.tiff"
}

Dim batchOptions As New BarcodeReaderOptions With {
    .Multithreaded = True,
    .MaxParallelThreads = 4,
    .Speed = ReadingSpeed.Balanced
}

' Process all documents in parallel
Dim allResults As BarcodeResults = BarcodeReader.Read(documents, batchOptions)

' Or use async for non-blocking operations
Async Function ProcessBatchAsync() As Task(Of BarcodeResults)
    Dim tasks = documents.Select(Function(doc) 
                                     Return Task.Run(Function() BarcodeReader.Read(doc, batchOptions))
                                 End Function).ToArray()

    Dim results = Await Task.WhenAll(tasks)

    ' Combine all results
    Dim combined As New BarcodeResults()
    For Each result In results
        combined.AddRange(result)
    Next

    Return combined
End Function

' Process with progress reporting
Async Function ProcessWithProgress(progress As IProgress(Of Integer)) As Task
    Dim processed As Integer = 0
    Dim tasks = documents.Select(Function(doc, index)
                                     Return Task.Run(Async Function()
                                                         Dim result = Await Task.Run(Function() BarcodeReader.Read(doc, batchOptions))
                                                         Interlocked.Increment(processed)
                                                         progress.Report((processed * 100) \ documents.Length)
                                                         Return result
                                                     End Function)
                                 End Function).ToArray()

    Await Task.WhenAll(tasks)
End Function