Aspose.Medical DICOM to Text Converter за .NET Knowledge Base
Kako koristiti Async DICOM JSON serialization u ASP.NET Core Web API-ima

Kako koristiti Async DICOM JSON serialization u ASP.NET Core Web API-ima

Овај туториал показује како да користите асинц ДИЦОМ ЈСОН серијализацију у АСП.НЕТ Цоре веб АПИ. Асинк операције су од суштинског значаја за веб апликације са високим проширењем како би се спречило блокирање нијанса и одржавање одговорности под оптерећењем.

Зашто користити Асинц Серијализација?

  • Смањивост:- Не-блокирање И/О омогућава обраду више конкурентних захтева.

  • • Одговорност * :- Веб сервер остаје одговоран током велике обраде датотека.

    • Ефикасност ресурса *:- Огрозе се ослобађају док чекају операције И/О.

Принципи: Припрема за животну средину

  • Инсталирајте Visual Studio или било који компатибилан .NET IDE.
  • Kreirajte novi ASP.NET Core Web API projekat usmeren na .NET 8.
  • Инсталирајте Aspose.Medical из менаџера пакета NuGet.

Корак по корак водич за Асинц Дицом ЈСОН Серијализација

Корак 1: Инсталирајте Aspose.Medical

Додајте Аппосе.Медицинска библиотека у свој пројекат користећи НуГет.

Install-Package Aspose.Medical

Корак 2: Укључите неопходне имена

Додајте референце на потребне имена простора у вашем контролеру.

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

Корак 3: Креирање Асинц Десеријализација крајње тачке

Креирајте крајњу тачку која детерилише ЈСОН из тела за захтев.

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

Корак 4: Успостављање Асинц серијализације крајњег тачка

Креирајте крајњу тачку која серијализује ДИКОМ-ом на ЈСОН-у у одговору.

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

Корак 5: Управљање токенима за отклањање

Прођите токене за отказивање за правилно обраду захтева за отклањање.

[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 Controller Пример

Ево комплетног контролера који имплементира асинц ДИКОМ ЈСОН операције:

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

Конфигурисање ограничења величине захтева

За велике ДИКОМ датотеке, конфигуришете ограничења захтева у 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();

Пример обраде струје

Процесирајте ДИКОМ датотеке без пуњења у потпуност у меморију:

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

Најбоља пракса управљања грешкама

Увођење свеобухватне грешке управљања:

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

Додатне најбоље праксе

Коришћење изјава за струје

Увек користите одговарајуће распореде:

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

Timeout конфигурација

Подесите одговарајуће временске излазе за дуге операције:

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

Додатне информације

  • Асинц методе побољшавају скалабилност, али не морају неопходно убрзати појединачне захтеве.
  • Користите токене за отказивање како бисте правилно управљали раздвајањима клијента.
  • Мониторинг употребе меморије приликом обраде великих ДИКОМ датотека.

Закључак

Овај туториал је показао како имплементирати асинц ДИЦОМ ЈСОН серијализацију у АСП.НЕТ Цоре веб АПИ користећи Аспасе.Медицински.Асинц операције су од суштинског значаја за изградњу скалабилне здравствене АПИС који ефикасно управљају великим медицинским сликама података.

 Српски