Aspose.Medical DICOM ke Text Converter untuk .NET Knowledge Base
Cara Menggunakan Async DICOM JSON Serialisasi di ASP.NET Core Web APIs

Cara Menggunakan Async DICOM JSON Serialisasi di ASP.NET Core Web APIs

Tutorial ini menunjukkan bagaimana menggunakan serialisasi async DICOM JSON di ASP.NET Core web APIs. Operasi Asynk sangat penting untuk aplikasi web berprestasi tinggi untuk mencegah pemblokiran thread dan mengekalkan responsiveness di bawah beban.

Mengapa menggunakan Async Serialization?

  • Kekuatan Skala:- Non-blocking I/O memungkinkan untuk menangani permintaan yang lebih konvensional.

  • • Responibilitas * :- Server web tetap responsif selama pemrosesan file besar.

  • • Efisiensi sumber daya :- Ancaman dibebaskan saat menunggu operasi I/O.

Persyaratan: Persiapan Lingkungan

  • Menginstal Visual Studio atau IDE .NET yang kompatibel.
  • Buat proyek baru ASP.NET Core Web API yang menargetkan .NET 8.
  • Instal Aspose.Medical dari NuGet Package Manager.

Panduan Langkah-Langkah untuk Async DICOM JSON Serialisasi

Langkah 1: Instalasi Aspose.Medical

Tambahkan perpustakaan Aspose.Medical ke proyek Anda menggunakan NuGet.

Install-Package Aspose.Medical

Langkah 2: Menyertakan ruang nama yang diperlukan

Tambahkan referensi ke ruang nama yang diperlukan di controller Anda.

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

Langkah 3: Mencipta titik akhir deserialisasi Async

Mencipta titik akhir yang deserialisasi JSON dari badan permintaan.

[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");
}

Langkah 4: Mencipta titik akhir serialisasi Async

Buat titik akhir yang serialisasi DICOM ke JSON dalam jawaban.

[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);
}

Langkah 5: Mengendalikan token pembatalan

Lulus token pembatalan untuk pemrosesan permintaan yang tepat.

[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();
}

Cara Menggunakan ASP.NET Core Controller

Berikut adalah kontrol lengkap yang melaksanakan operasi async DICOM JSON:

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}");
        }
    }
}

Mengatur batasan ukuran permintaan

Untuk file DICOM yang besar, tetapkan batasan permintaan di 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();

Contoh Pemrosesan Stream

Memproses file DICOM tanpa muat sepenuhnya ke dalam memori:

[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
    );
}

Kesalahan Mengatasi Praktik Terbaik

Pengelolaan Kesalahan Komprehensif:

[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 });
    }
}

Praktik Terbaik Tambahan

Menggunakan Pernyataan untuk Streams

Selalu gunakan pola penyimpanan yang tepat:

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

Konfigurasi Timeout

Mengatur waktu yang tepat untuk operasi panjang:

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

Informasi Tambahan

  • Metode Async meningkatkan scalability tetapi tidak semestinya mempercepat permintaan individu.
  • Gunakan token pembatalan untuk menangani diskon klien dengan benar.
  • Memantau penggunaan memori saat memproses file DICOM yang besar.

Kesimpulan

Tutorial ini telah menunjukkan bagaimana untuk melaksanakan async DICOM JSON serialisasi dalam ASP.NET Core web APIs menggunakan Aspose.Medical. operasi Asynk adalah penting untuk membangun scalable healthcare API yang menangani data gambar medis besar secara efisien.

 Indonesia