Aspose.Medical DICOM .NET Bilgi Bankası için Metin Dönüştürücü
ASP.NET Core Web APIs'te Async DICOM JSON Serializasyonu Nasıl Kullanılır

ASP.NET Core Web APIs'te Async DICOM JSON Serializasyonu Nasıl Kullanılır

Bu öğretici, async DICOM JSON serializasyonunu ASP.NET Core web APIs’lerde nasıl kullanılacağını gösterir. Asynk operasyonları, yüksek performanslı web uygulamaları için çubuk engellemeyi önlemek ve yük altında tepki vericiliğini korumak için gereklidir.

Async Serialization Neden Kullanılır?

  • Sıcaklık:- I/O’nun engellenmemesi, daha fazla eşzamanlı taleplerin işlenmesine olanak tanır.

  • • Sorumluluk * :- Web sunucusu büyük dosya işleme sırasında yanıt verici kalır.

  • • Kaynak verimliliği:- I/O operasyonları beklerken tehditler serbest bırakılır.

Etiket Arşivi: çevreyi hazırlamak

  • Visual Studio veya herhangi bir uyumlu .NET IDE ayarlayın.
  • Yeni bir ASP.NET Core Web API projesi oluşturun .NET 8 hedeflenir.
  • Aspose.Medical’ı NuGet Paket Yöneticisi’nden kurun.

Async DICOM JSON serializasyonu için adım adım rehber

Adım 1: Aspose.Medical yükleme

Projenize Aspose.Medical kütüphanesini NuGet kullanarak ekleyin.

Install-Package Aspose.Medical

2. Adım: İhtiyacınız olan alanları içerir

Kontrolörünüzde gerekli isim alanlarına referanslar ekleyin.

using Aspose.Medical.Dicom;
using Aspose.Medical.Dicom.Serialization;
using Microsoft.AspNetCore.Mvc;

Adım 3: Async Deserialization Endpoint oluşturun

Başvuru organından JSON’u deserialize eden bir son nokta oluşturun.

[HttpPost("import")]
public async Task<IActionResult> ImportDicomJson()
{
    Dataset? dataset = await DicomJsonSerializer.DeserializeAsync(Request.Body);
    
    if (dataset == null)
        return BadRequest("Invalid DICOM JSON");
    
    return Ok("DICOM data imported successfully");
}

Adım 4: Async Serialization Endpoint oluşturun

Cevapta DICOM’u JSON’a serialize eden bir son nokta oluşturun.

[HttpGet("export/{filename}")]
public async Task ExportDicomJson(string filename)
{
    DicomFile dcm = DicomFile.Open($"storage/{filename}");
    
    Response.ContentType = "application/json";
    await DicomJsonSerializer.SerializeAsync(Response.Body, dcm.Dataset);
}

Adım 5: iptal tokenleri işlemek

İzin iptal işlemleri için geçerli iğrenme tokenleri.

[HttpPost("process")]
public async Task<IActionResult> ProcessDicomAsync(CancellationToken cancellationToken)
{
    Dataset? dataset = await DicomJsonSerializer.DeserializeAsync(
        Request.Body, 
        cancellationToken
    );
    
    if (cancellationToken.IsCancellationRequested)
        return StatusCode(499, "Client Closed Request");
    
    // Process dataset...
    return Ok();
}

ASP.NET Core Kontrol Cihazı

İşte async DICOM JSON operasyonlarını gerçekleştiren tam bir denetleyici:

using Aspose.Medical.Dicom;
using Aspose.Medical.Dicom.Serialization;
using Microsoft.AspNetCore.Mvc;

namespace DicomApi.Controllers;

[ApiController]
[Route("api/[controller]")]
public class DicomController : ControllerBase
{
    private readonly string _storagePath = "dicom_storage";

    public DicomController()
    {
        Directory.CreateDirectory(_storagePath);
    }

    /// <summary>
    /// Import DICOM JSON and save as DICOM file
    /// </summary>
    [HttpPost("import")]
    public async Task<IActionResult> ImportDicomJson(CancellationToken cancellationToken)
    {
        try
        {
            Dataset? dataset = await DicomJsonSerializer.DeserializeAsync(
                Request.Body, 
                cancellationToken
            );

            if (dataset == null)
                return BadRequest("Failed to deserialize DICOM JSON");

            // Generate unique filename
            string filename = $"{Guid.NewGuid()}.dcm";
            string filepath = Path.Combine(_storagePath, filename);

            // Save as DICOM file
            DicomFile dcm = new DicomFile(dataset);
            dcm.Save(filepath);

            return Ok(new { message = "DICOM imported successfully", filename });
        }
        catch (OperationCanceledException)
        {
            return StatusCode(499, "Request cancelled");
        }
        catch (Exception ex)
        {
            return BadRequest($"Import failed: {ex.Message}");
        }
    }

    /// <summary>
    /// Export DICOM file as JSON stream
    /// </summary>
    [HttpGet("export/{filename}")]
    public async Task ExportDicomJson(string filename, CancellationToken cancellationToken)
    {
        string filepath = Path.Combine(_storagePath, filename);

        if (!System.IO.File.Exists(filepath))
        {
            Response.StatusCode = 404;
            await Response.WriteAsync("File not found");
            return;
        }

        try
        {
            DicomFile dcm = DicomFile.Open(filepath);
            
            Response.ContentType = "application/json";
            Response.Headers["Content-Disposition"] = $"attachment; filename=\"{filename}.json\"";
            
            await DicomJsonSerializer.SerializeAsync(
                Response.Body, 
                dcm.Dataset, 
                writeIndented: true
            );
        }
        catch (OperationCanceledException)
        {
            // Client disconnected
        }
        catch (Exception ex)
        {
            Response.StatusCode = 500;
            await Response.WriteAsync($"Export failed: {ex.Message}");
        }
    }

    /// <summary>
    /// Convert uploaded DICOM file to JSON
    /// </summary>
    [HttpPost("convert")]
    [RequestSizeLimit(100_000_000)] // 100MB limit
    public async Task ConvertDicomToJson(IFormFile file, CancellationToken cancellationToken)
    {
        if (file == null || file.Length == 0)
        {
            Response.StatusCode = 400;
            await Response.WriteAsync("No file uploaded");
            return;
        }

        try
        {
            // Save uploaded file temporarily
            string tempPath = Path.GetTempFileName();
            using (var stream = System.IO.File.Create(tempPath))
            {
                await file.CopyToAsync(stream, cancellationToken);
            }

            // Load and convert
            DicomFile dcm = DicomFile.Open(tempPath);
            
            Response.ContentType = "application/json";
            await DicomJsonSerializer.SerializeAsync(
                Response.Body, 
                dcm.Dataset, 
                writeIndented: true
            );

            // Cleanup temp file
            System.IO.File.Delete(tempPath);
        }
        catch (OperationCanceledException)
        {
            // Client disconnected
        }
        catch (Exception ex)
        {
            Response.StatusCode = 500;
            await Response.WriteAsync($"Conversion failed: {ex.Message}");
        }
    }
}

İhtiyaç Boyutu Sınırları

Büyük DICOM dosyaları için, talep sınırlarını ayarlayın Program.cs:

var builder = WebApplication.CreateBuilder(args);

// Configure Kestrel for large uploads
builder.WebHost.ConfigureKestrel(options =>
{
    options.Limits.MaxRequestBodySize = 500_000_000; // 500MB
});

// Configure form options
builder.Services.Configure<FormOptions>(options =>
{
    options.MultipartBodyLengthLimit = 500_000_000;
});

var app = builder.Build();

Akım İşleme Örneği

DICOM dosyalarını tamamen hafıza içine yüklemeden işler:

[HttpPost("stream-process")]
public async Task StreamProcessDicom(CancellationToken cancellationToken)
{
    // Read JSON from request body stream
    using var reader = new StreamReader(Request.Body);
    string json = await reader.ReadToEndAsync(cancellationToken);
    
    // Deserialize
    Dataset? dataset = DicomJsonSerializer.Deserialize(json);
    
    if (dataset == null)
    {
        Response.StatusCode = 400;
        await Response.WriteAsync("Invalid JSON");
        return;
    }
    
    // Process and stream response
    Response.ContentType = "application/json";
    await DicomJsonSerializer.SerializeAsync(
        Response.Body, 
        dataset, 
        writeIndented: true
    );
}

Hatalarla Mücadele En İyi Uygulamalar

Gelişmiş hata işleme uygulama:

[HttpPost("safe-import")]
public async Task<IActionResult> SafeImportDicomJson(CancellationToken cancellationToken)
{
    try
    {
        Dataset? dataset = await DicomJsonSerializer.DeserializeAsync(
            Request.Body, 
            cancellationToken
        );

        if (dataset == null)
            return BadRequest(new { error = "Invalid DICOM JSON format" });

        // Process dataset...
        return Ok(new { success = true });
    }
    catch (OperationCanceledException)
    {
        return StatusCode(499, new { error = "Request cancelled by client" });
    }
    catch (JsonException ex)
    {
        return BadRequest(new { error = "JSON parsing error", details = ex.Message });
    }
    catch (OutOfMemoryException)
    {
        return StatusCode(507, new { error = "File too large to process" });
    }
    catch (Exception ex)
    {
        return StatusCode(500, new { error = "Internal server error", details = ex.Message });
    }
}

En İyi Uygulamalar

Streams için ifadeler kullanın

Her zaman doğru düzenleme modellerini kullanın:

using (FileStream fs = System.IO.File.OpenRead(filepath))
{
    // Process stream
}

Timeout konfigürasyonu

Uzun işlemler için uygun zamanlamaları ayarlayın:

builder.WebHost.ConfigureKestrel(options =>
{
    options.Limits.RequestHeadersTimeout = TimeSpan.FromMinutes(2);
    options.Limits.KeepAliveTimeout = TimeSpan.FromMinutes(5);
});

Ek Bilgiler

  • Async yöntemleri ölçeklenebilirliği arttırır, ancak bireysel talepleri hızlandırmaz.
  • Müşteri bağlantılarını düzgün bir şekilde ele almak için iptal tokenleri kullanın.
  • Büyük DICOM dosyalarını işlerken hafıza kullanımını izlemek.

Sonuç

Bu öğretici, async DICOM JSON serializasyonunu Aspose.Medical kullanılarak ASP.NET çekirdek web APIs’te nasıl uygulayacağınızı göstermiştir.

 Türkçe