.NET'te Çizgikodu Okuyucu SDK'sı Nasıl Oluşturulur?

using IronBarCode;
using System.IO;
using System.Collections.Concurrent;
using System.Threading.Tasks;

namespace BarcodeIntegration
{
    public class BarcodeScanner
    {
        private static readonly ConcurrentDictionary<string, BarcodeReaderOptions> _optionsCache = new();

        static BarcodeScanner()
        {
            // Set the license key
            IronBarCode.License.LicenseKey = "Your-License-Key";
        }

        // Method to read a barcode from an image file with performance optimization
        public string ReadBarcodeFromImage(string imagePath, BarcodeReadingSpeed speed = BarcodeReadingSpeed.Balanced)
        {
            try
            {
                var options = GetCachedOptions(speed);
                // Try to read the barcode from the given image path
                var barcode = BarcodeReader.Read(imagePath, options);
                return barcode?.ToString() ?? "No Barcode Found"; // Return the barcode string or indicate no barcode was found
            }
            catch (Exception ex)
            {
                // Return an error message if an exception occurs
                return $"Error reading barcode: {ex.Message}";
            }
        }

        // Method to read a barcode from a stream (e.g., file upload or memory stream)
        public async Task<string> ReadBarcodeFromStreamAsync(Stream inputStream)
        {
            try
            {
                var options = GetCachedOptions(BarcodeReadingSpeed.Detailed);
                // Enable image correction for better accuracy
                options.ImageFilters = new[] { 
                    new SharpenFilter(), 
                    new ContrastFilter() 
                };

                // Try to read the barcode from the given stream
                var barcode = await Task.Run(() => BarcodeReader.Read(inputStream, options));
                return barcode?.ToString() ?? "No barcode found";
            }
            catch (Exception ex)
            {
                return $"Error reading barcode: {ex.Message}";
            }
        }

        // Method to read a barcode from a PDF file with batch processing support
        public async Task<List<string>> ReadBarcodesFromPdfAsync(string filePath)
        {
            try
            {
                var options = new BarcodeReaderOptions
                {
                    ExpectMultipleBarcodes = true,
                    Speed = BarcodeReadingSpeed.Detailed
                };

                // Try to read barcodes from the given PDF file path
                var barcodes = await Task.Run(() => BarcodeReader.ReadPdf(filePath, options));
                return barcodes.Select(b => b.ToString()).ToList();
            }
            catch (Exception ex)
            {
                return new List<string> { $"Error reading barcode: {ex.Message}" };
            }
        }

        // Cache reader options for performance
        private BarcodeReaderOptions GetCachedOptions(BarcodeReadingSpeed speed)
        {
            return _optionsCache.GetOrAdd(speed.ToString(), _ => new BarcodeReaderOptions
            {
                Speed = speed,
                AutoRotate = true,
                RemoveFalsePositive = true
            });
        }
    }
}

Imports IronBarCode
Imports System.IO
Imports System.Collections.Concurrent
Imports System.Threading.Tasks

Namespace BarcodeIntegration
    Public Class BarcodeScanner
        Private Shared ReadOnly _optionsCache As New ConcurrentDictionary(Of String, BarcodeReaderOptions)()

        Shared Sub New()
            ' Set the license key
            IronBarCode.License.LicenseKey = "Your-License-Key"
        End Sub

        ' Method to read a barcode from an image file with performance optimization
        Public Function ReadBarcodeFromImage(imagePath As String, Optional speed As BarcodeReadingSpeed = BarcodeReadingSpeed.Balanced) As String
            Try
                Dim options = GetCachedOptions(speed)
                ' Try to read the barcode from the given image path
                Dim barcode = BarcodeReader.Read(imagePath, options)
                Return If(barcode?.ToString(), "No Barcode Found") ' Return the barcode string or indicate no barcode was found
            Catch ex As Exception
                ' Return an error message if an exception occurs
                Return $"Error reading barcode: {ex.Message}"
            End Try
        End Function

        ' Method to read a barcode from a stream (e.g., file upload or memory stream)
        Public Async Function ReadBarcodeFromStreamAsync(inputStream As Stream) As Task(Of String)
            Try
                Dim options = GetCachedOptions(BarcodeReadingSpeed.Detailed)
                ' Enable image correction for better accuracy
                options.ImageFilters = {New SharpenFilter(), New ContrastFilter()}

                ' Try to read the barcode from the given stream
                Dim barcode = Await Task.Run(Function() BarcodeReader.Read(inputStream, options))
                Return If(barcode?.ToString(), "No barcode found")
            Catch ex As Exception
                Return $"Error reading barcode: {ex.Message}"
            End Try
        End Function

        ' Method to read a barcode from a PDF file with batch processing support
        Public Async Function ReadBarcodesFromPdfAsync(filePath As String) As Task(Of List(Of String))
            Try
                Dim options = New BarcodeReaderOptions With {
                    .ExpectMultipleBarcodes = True,
                    .Speed = BarcodeReadingSpeed.Detailed
                }

                ' Try to read barcodes from the given PDF file path
                Dim barcodes = Await Task.Run(Function() BarcodeReader.ReadPdf(filePath, options))
                Return barcodes.Select(Function(b) b.ToString()).ToList()
            Catch ex As Exception
                Return New List(Of String) From {$"Error reading barcode: {ex.Message}"}
            End Try
        End Function

        ' Cache reader options for performance
        Private Function GetCachedOptions(speed As BarcodeReadingSpeed) As BarcodeReaderOptions
            Return _optionsCache.GetOrAdd(speed.ToString(), Function(_) New BarcodeReaderOptions With {
                .Speed = speed,
                .AutoRotate = True,
                .RemoveFalsePositive = True
            })
        End Function
    End Class
End Namespace

using Microsoft.AspNetCore.Mvc;
using System.IO;
using Microsoft.AspNetCore.Http;
using BarcodeIntegration;

[ApiController]
[Route("api/barcode")]
public class BarcodeController : ControllerBase
{
    private readonly BarcodeScanner _barcodeScanner;
    private readonly ILogger<BarcodeController> _logger;

    public BarcodeController(ILogger<BarcodeController> logger)
    {
        _barcodeScanner = new BarcodeScanner();
        _logger = logger;
    }

    // POST endpoint to read barcode from an uploaded image
    [HttpPost("read-from-image")]
    public async Task<IActionResult> ReadFromImage(IFormFile file)
    {
        if (file == null || file.Length == 0)
            return BadRequest(new { Error = "No file uploaded" });

        // Validate file type
        var allowedTypes = new[] { "image/jpeg", "image/png", "image/gif", "image/bmp", "image/tiff" };
        if (!allowedTypes.Contains(file.ContentType.ToLower()))
            return BadRequest(new { Error = "Unsupported file type" });

        try
        {
            using var stream = file.OpenReadStream();
            var result = await _barcodeScanner.ReadBarcodeFromStreamAsync(stream);

            _logger.LogInformation($"Barcode read successfully from {file.FileName}");
            return Ok(new { Barcode = result, FileName = file.FileName });
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error processing barcode");
            return StatusCode(500, new { Error = "Internal server error" });
        }
    }

    // POST endpoint for batch processing
    [HttpPost("read-batch")]
    public async Task<IActionResult> ReadBatch(List<IFormFile> files)
    {
        var results = new List<object>();

        foreach (var file in files)
        {
            using var stream = file.OpenReadStream();
            var result = await _barcodeScanner.ReadBarcodeFromStreamAsync(stream);
            results.Add(new { FileName = file.FileName, Barcode = result });
        }

        return Ok(new { Results = results, Count = results.Count });
    }

    // POST endpoint to generate barcode from data
    [HttpPost("generate")]
    public IActionResult GenerateBarcode([FromBody] BarcodeGenerationRequest request)
    {
        try
        {
            // Create barcode with specified data and format
            var barcode = BarcodeWriter.CreateBarcode(request.Data, request.Format ?? BarcodeWriterEncoding.Code128);

            // Apply custom styling if requested
            if (request.Width.HasValue && request.Height.HasValue)
                barcode.ResizeTo(request.Width.Value, request.Height.Value);

            if (!string.IsNullOrEmpty(request.ForegroundColor))
                barcode.ChangeBarCodeColor(System.Drawing.ColorTranslator.FromHtml(request.ForegroundColor));

            // Return as base64 encoded image
            using var ms = barcode.ToStream();
            var bytes = ms.ToArray();
            return Ok(new { 
                Image = Convert.ToBase64String(bytes),
                Format = request.Format?.ToString() ?? "Code128",
                Data = request.Data 
            });
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error generating barcode");
            return BadRequest(new { Error = "Failed to generate barcode" });
        }
    }
}

public class BarcodeGenerationRequest
{
    public string Data { get; set; }
    public BarcodeWriterEncoding? Format { get; set; }
    public int? Width { get; set; }
    public int? Height { get; set; }
    public string ForegroundColor { get; set; }
}

Imports Microsoft.AspNetCore.Mvc
Imports System.IO
Imports Microsoft.AspNetCore.Http
Imports BarcodeIntegration

<ApiController>
<Route("api/barcode")>
Public Class BarcodeController
    Inherits ControllerBase

    Private ReadOnly _barcodeScanner As BarcodeScanner
    Private ReadOnly _logger As ILogger(Of BarcodeController)

    Public Sub New(logger As ILogger(Of BarcodeController))
        _barcodeScanner = New BarcodeScanner()
        _logger = logger
    End Sub

    ' POST endpoint to read barcode from an uploaded image
    <HttpPost("read-from-image")>
    Public Async Function ReadFromImage(file As IFormFile) As Task(Of IActionResult)
        If file Is Nothing OrElse file.Length = 0 Then
            Return BadRequest(New With {.Error = "No file uploaded"})
        End If

        ' Validate file type
        Dim allowedTypes = New String() {"image/jpeg", "image/png", "image/gif", "image/bmp", "image/tiff"}
        If Not allowedTypes.Contains(file.ContentType.ToLower()) Then
            Return BadRequest(New With {.Error = "Unsupported file type"})
        End If

        Try
            Using stream = file.OpenReadStream()
                Dim result = Await _barcodeScanner.ReadBarcodeFromStreamAsync(stream)

                _logger.LogInformation($"Barcode read successfully from {file.FileName}")
                Return Ok(New With {.Barcode = result, .FileName = file.FileName})
            End Using
        Catch ex As Exception
            _logger.LogError(ex, "Error processing barcode")
            Return StatusCode(500, New With {.Error = "Internal server error"})
        End Try
    End Function

    ' POST endpoint for batch processing
    <HttpPost("read-batch")>
    Public Async Function ReadBatch(files As List(Of IFormFile)) As Task(Of IActionResult)
        Dim results = New List(Of Object)()

        For Each file In files
            Using stream = file.OpenReadStream()
                Dim result = Await _barcodeScanner.ReadBarcodeFromStreamAsync(stream)
                results.Add(New With {.FileName = file.FileName, .Barcode = result})
            End Using
        Next

        Return Ok(New With {.Results = results, .Count = results.Count})
    End Function

    ' POST endpoint to generate barcode from data
    <HttpPost("generate")>
    Public Function GenerateBarcode(<FromBody> request As BarcodeGenerationRequest) As IActionResult
        Try
            ' Create barcode with specified data and format
            Dim barcode = BarcodeWriter.CreateBarcode(request.Data, If(request.Format, BarcodeWriterEncoding.Code128))

            ' Apply custom styling if requested
            If request.Width.HasValue AndAlso request.Height.HasValue Then
                barcode.ResizeTo(request.Width.Value, request.Height.Value)
            End If

            If Not String.IsNullOrEmpty(request.ForegroundColor) Then
                barcode.ChangeBarCodeColor(System.Drawing.ColorTranslator.FromHtml(request.ForegroundColor))
            End If

            ' Return as base64 encoded image
            Using ms = barcode.ToStream()
                Dim bytes = ms.ToArray()
                Return Ok(New With {
                    .Image = Convert.ToBase64String(bytes),
                    .Format = If(request.Format?.ToString(), "Code128"),
                    .Data = request.Data
                })
            End Using
        Catch ex As Exception
            _logger.LogError(ex, "Error generating barcode")
            Return BadRequest(New With {.Error = "Failed to generate barcode"})
        End Try
    End Function
End Class

Public Class BarcodeGenerationRequest
    Public Property Data As String
    Public Property Format As BarcodeWriterEncoding?
    Public Property Width As Integer?
    Public Property Height As Integer?
    Public Property ForegroundColor As String
End Class