Aspose.Medical DICOM to Text Converter cho .NET Knowledge Base
Cách sử dụng Async DICOM JSON Serialization trong ASP.NET Core Web APIs

Cách sử dụng Async DICOM JSON Serialization trong ASP.NET Core Web APIs

Hướng dẫn này cho thấy làm thế nào để sử dụng async DICOM JSON serialization trong ASP.NET Core web APIs. hoạt động Asynk là điều cần thiết cho các ứng dụng web có công suất cao để ngăn chặn chìa khóa và duy trì phản ứng dưới tải.

Tại sao nên sử dụng Async Serialization?

  • Khả năng:- Không chặn I/O cho phép xử lý các yêu cầu cạnh tranh hơn.

    • Trách nhiệm *:- Web server vẫn phản ứng trong quá trình xử lý tệp lớn.
    • Hiệu quả nguồn lực *:- Các mối đe dọa được phát hành trong khi chờ đợi các hoạt động I/O.

Chủ đề: Chuẩn bị môi trường

  • Cài đặt Visual Studio hoặc bất kỳ IDE .NET tương thích nào.
  • Tạo một dự án ASP.NET Core Web API mới nhằm mục đích .NET 8.
  • Cài đặt Aspose.Medical từ NuGet Package Manager.

Hướng dẫn từng bước để Async DICOM JSON Serialization

Bước 1: Cài đặt Aspose.Medical

Thêm thư viện Aspose.Medical vào dự án của bạn bằng NuGet.

Install-Package Aspose.Medical

Bước 2: Thêm các không gian tên cần thiết

Thêm tham chiếu đến các không gian tên cần thiết trong bộ điều khiển của bạn.

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

Bước 3: Tạo Async Deserialization Endpoint

Tạo một điểm kết thúc xóa JSON từ cơ quan yêu cầu.

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

Bước 4: Tạo Async Serialization Endpoint

Tạo một điểm kết thúc mà serializes DICOM to JSON trong câu trả lời.

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

Bước 5: Quản lý token hủy bỏ

Đi qua token hủy bỏ để xử lý yêu cầu hối hận thích hợp.

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

Hướng dẫn cài đặt ASP.NET Core Controller

Dưới đây là một bộ điều khiển hoàn chỉnh thực hiện các hoạt động 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}");
        }
    }
}

Thiết lập yêu cầu kích thước giới hạn

Đối với các tệp DICOM lớn, thiết lập giới hạn yêu cầu trong 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();

Phương pháp xử lý dòng chảy ví dụ

Xử lý các tệp DICOM mà không tải đầy đủ vào bộ nhớ:

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

Cách xử lý sai lầm tốt nhất

Thực hiện toàn diện lỗi xử lý:

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

Thêm thực hành tốt nhất

Sử dụng tuyên bố cho Streams

Luôn sử dụng các mô hình xử lý thích hợp:

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

Timeout cấu hình

Thiết lập thời gian thích hợp cho các hoạt động dài:

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

Thông tin bổ sung

  • Các phương pháp Async cải thiện khả năng quy mô nhưng không nhất thiết phải tăng tốc các yêu cầu cá nhân.
  • Sử dụng token hủy bỏ để xử lý sai lệch khách hàng một cách chính xác.
  • Kiểm tra việc sử dụng bộ nhớ khi xử lý các tệp DICOM lớn.

Kết luận

Hướng dẫn này đã chứng minh làm thế nào để thực hiện async DICOM JSON serialization trong ASP.NET Core web APIs bằng cách sử dụng Aspose.Medical. hoạt động Asynk là cần thiết cho việc xây dựng API chăm sóc sức khỏe quy mô mà xử lý dữ liệu hình ảnh y tế lớn một cách hiệu quả.

 Tiếng Việt