Aspose.Medical DICOM à Converteur de texte pour la base de connaissances .NET
Comment utiliser Async DICOM JSON Sérialisation dans ASP.NET Core Web APIs

Comment utiliser Async DICOM JSON Sérialisation dans ASP.NET Core Web APIs

Ce tutoriel démontre comment utiliser la sérialisation Async DICOM JSON dans les APIs web ASP.NET Core. Les opérations Asymc sont essentielles pour les applications Web de haute puissance pour empêcher le blocage du fil et maintenir la réactivité sous charge.

Pourquoi utiliser Async sérialisation ?

  • La scalabilité:- Le non-blocage I/O permet de traiter des demandes plus concurrentes.

  • « Responsabilité » :- Le serveur Web reste réactif pendant le traitement de fichiers importants.

    • Efficacité des ressources :- Les menaces sont libérées en attendant les opérations I/O.

Étiquette : Préparer l’environnement

  • Configurez Visual Studio ou tout IDE .NET compatible.
  • Créer un nouveau projet ASP.NET Core Web API ciblant .NET 8.
  • Installez Aspose.Medical à partir du NuGet Package Manager.

Guide pas à pas pour la sérialisation Async DICOM JSON

Étape 1 : Installer Aspose.Medical

Ajoutez la bibliothèque Aspose.Medical à votre projet en utilisant NuGet.

Install-Package Aspose.Medical

Étape 2 : Inclure les espaces de nom nécessaires

Ajouter des références aux espaces de nom requis dans votre contrôleur.

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

Étape 3 : Créer un endpoint de désertification Async

Créez un endpoint qui désérialisera JSON du corps de demande.

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

Étape 4 : Créer un endpoint de sérialisation Async

Créez un endpoint qui sérialisera DICOM à JSON dans la réponse.

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

Étape 5: Travailler avec les tokens d’annulation

Passez les tokens d’annulation pour le traitement approprié de la demande de annulation.

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

Complet ASP.NET Core Controller Exemple

Voici un contrôleur complet qui met en œuvre les opérations d’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}");
        }
    }
}

Configurer les limites de taille de la demande

Pour les fichiers DICOM de grande taille, configurez les limites de demande dans 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();

Exemple de traitement de flux

Traitement des fichiers DICOM sans charger complètement dans la mémoire:

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

Les meilleures pratiques d’erreur

Traitement d’erreurs complètes :

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

Des meilleures pratiques supplémentaires

Utiliser des déclarations pour les courants

Utilisez toujours les modèles de détachement appropriés :

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

Configuration Timeout

Configurez les horaires appropriés pour des opérations longues:

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

Informations supplémentaires

  • Les méthodes Async améliorent l’escalabilité mais ne accélèrent pas nécessairement les demandes individuelles.
  • Utilisez les tokens d’annulation pour gérer correctement les disconnexions client.
  • Surveiller l’utilisation de la mémoire lors du traitement de grands fichiers DICOM.

Conclusion

Ce tutoriel a démontré comment mettre en œuvre la sérialisation d’async DICOM JSON dans les APIs web de base ASP.NET en utilisant Aspose.Medical. Les opérations d’asynec sont essentielles pour construire des API médicaux scalables qui gèrent efficacement les données de grande image médicale.

 Français