Aspose.Medical DICOM a Converter di testo per .NET Knowledge Base
Come usare Async DICOM JSON Serializzazione in ASP.NET Core Web API

Come usare Async DICOM JSON Serializzazione in ASP.NET Core Web API

Questo tutorial dimostra come utilizzare la serializzazione Async DICOM JSON in ASP.NET Core web APIs. Le operazioni Asynec sono essenziali per le applicazioni web ad alta potenza per prevenire il blocco del filo e mantenere la risposta sotto carico.

Perché usare Async Serialization?

  • Scalabilità:- Il non-blocco I/O consente di gestire richieste più concorrenti.

  • • Responsabilità *:- Il server web rimane responsivo durante il trattamento dei file di grandi dimensioni.

    • Efficienza delle risorse:- Le minacce sono rilasciate in attesa di operazioni I/O.

Prerequisiti: preparare l’ambiente

  • Inserisci Visual Studio o qualsiasi compatibile .NET IDE.
  • Creare un nuovo progetto ASP.NET Core Web API che mira a .NET 8.
  • Installare Aspose.Medical dal NuGet Package Manager.

Guida passo dopo passo per Async DICOM JSON Serializzazione

Passo 1: Installare Aspose.Medical

Aggiungi la biblioteca medica Aspose al tuo progetto utilizzando NuGet.

Install-Package Aspose.Medical

Passo 2: Includere gli spazi di nome necessari

Aggiungi riferimenti agli spazi di nome richiesti nel tuo controller.

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

Passo 3: Creare il punto di fine di deserializzazione Async

Crea un punto di fine che deserializza JSON dal corpo di richiesta.

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

Passo 4: Creare Async Serialization Endpoint

Crea un punto finale che serializza DICOM a JSON nella risposta.

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

Passo 5: Gestire i token di cancellazione

Passare i token di cancellazione per il corretto trattamento della richiesta di annullamento.

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

Esempio completo di ASP.NET Core Controller

Ecco un controller completo che implementa le operazioni di 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}");
        }
    }
}

Configurare limiti di dimensioni di richiesta

Per i file DICOM di grandi dimensioni, impostare limiti di richiesta in 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();

Esempio di elaborazione del flusso

Processare i file DICOM senza caricare completamente nella memoria:

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

Le migliori pratiche per il trattamento degli errori

Implementazione completa di errori di gestione:

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

Le migliori pratiche aggiuntive

Utilizzare le dichiarazioni per i flussi

Utilizzare sempre correttamente i modelli di distribuzione:

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

Configurazione Timeout

Configurare gli orari adeguati per lunghe operazioni:

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

Informazioni aggiuntive

  • I metodi Async migliorano la scalabilità ma non necessariamente accelerano le richieste individuali.
  • Utilizzare i token di cancellazione per gestire correttamente le disconnessioni del cliente.
  • Monitorare l’uso della memoria durante il trattamento di grandi file DICOM.

conclusione

Questo tutorial ha dimostrato come implementare la serializzazione di async DICOM JSON in ASP.NET Core web APIs utilizzando Aspose.Medical. le operazioni di ASINC sono essenziali per la costruzione di API di assistenza sanitaria scalabile che gestiscono i grandi dati di immagine medica in modo efficiente.

 Italiano