Artikel ini menunjukkan bagaimana untuk melaksanakan dalam memori Excel format konversi menggunakan Aspose.Cells LowCode Converters dalam aplikasi web .NET. Konversi ini menyediakan pendekatan yang lancar untuk menangani transformasi format Excel tanpa memerlukan pengekodan yang luas atau penyimpanan fail sementara ke cakera, menjadikannya ideal untuk web dan SaaS persekitaran.

Masalah dunia sebenar

Aplikasi web sering perlu memproses fail Excel yang dimuat naik oleh pengguna dan menukarkan mereka ke format yang berbeza seperti PDF, HTML, atau JSON untuk melihat, berkongsi atau pengekstrakan data. pendekatan tradisional sering melibatkan penyimpanan fail sementara ke cakera, yang memperkenalkan kebimbangan keselamatan, pengurusan fail overhead, dan potensi masalah scalability dalam persekitaran awan.

Gambaran keseluruhan penyelesaian

Dengan menggunakan Aspose.Cells LowCode Converters, kita boleh menyelesaikan cabaran ini dengan cekap dengan menjalankan semua penukaran dalam memori. penyelesaian ini sesuai untuk pemaju web dan arkitek SaaS yang perlu melaksanakan fungsi pemprosesan dokumen yang selamat dan boleh diukur tanpa operasi sistem fail yang rumit.

Prerequisites

Sebelum melaksanakan penyelesaian, pastikan anda mempunyai:

  • Visual Studio 2019 atau seterusnya
  • .NET 6.0 atau seterusnya (sesuai dengan .Net Framework 4.6.2+)
  • Aspose.Cells untuk pakej .NET yang dipasang melalui NuGet
  • Projek aplikasi web (ASP.NET Core MVC, Web API, dan lain-lain)
PM> Install-Package Aspose.Cells

Pelaksanaan langkah demi langkah

Langkah 1: Pemasangan dan Konfigurasi Aspose.Cells

Tambah pakej Aspose.Cells kepada projek web anda dan termasuk ruang nama yang diperlukan:

using Aspose.Cells;
using Aspose.Cells.LowCode;
using Aspose.Cells.Rendering;
using System.IO;

Langkah 2: Mencipta kaedah pengawal untuk mengendalikan penukaran fail

Setkan titik akhir API atau kaedah pengawal untuk menerima muat naik fail dan mengembalikan format yang ditukar:

[HttpPost("convert-to-pdf")]
public IActionResult ConvertToPdf(IFormFile excelFile)
{
    if (excelFile == null || excelFile.Length == 0)
        return BadRequest("No file uploaded");
        
    // Continue with conversion process
}

Langkah 3: Mengimplementasikan logik penukaran dalam memori

Memproses fail yang dimuat naik dan mengubahnya sepenuhnya ke dalam memori:

// Read the uploaded file into memory
using var inputStream = new MemoryStream();
excelFile.CopyTo(inputStream);
inputStream.Position = 0;

// Configure the conversion options
LowCodeLoadOptions loadOptions = new LowCodeLoadOptions();
loadOptions.InputStream = inputStream;

// Create output memory stream for the converted file
using var outputStream = new MemoryStream();

// Configure save options for PDF
LowCodePdfSaveOptions saveOptions = new LowCodePdfSaveOptions();
PdfSaveOptions pdfOptions = new PdfSaveOptions();
pdfOptions.OnePagePerSheet = true;
saveOptions.PdfOptions = pdfOptions;
saveOptions.OutputStream = outputStream;

// Execute the conversion
PdfConverter.Process(loadOptions, saveOptions);

Langkah 4: Kembalikan fail yang ditukar kepada pelanggan

Kembalikan fail yang ditukar sebagai jawapan yang boleh dimuat turun:

// Reset the position of output stream
outputStream.Position = 0;

// Return as downloadable file
return File(outputStream.ToArray(), "application/pdf", "converted-document.pdf");

Langkah 5: Mengimplementasikan Jenis Konversi yang Berbeza

Tambah kaedah untuk format penukaran lain seperti HTML, JSON, dan imej:

// HTML conversion
public MemoryStream ConvertToHtml(MemoryStream inputStream)
{
    LowCodeLoadOptions loadOptions = new LowCodeLoadOptions();
    loadOptions.InputStream = inputStream;
    
    LowCodeHtmlSaveOptions saveOptions = new LowCodeHtmlSaveOptions();
    HtmlSaveOptions htmlOptions = new HtmlSaveOptions();
    htmlOptions.ExportImagesAsBase64 = true; // For fully self-contained HTML
    saveOptions.HtmlOptions = htmlOptions;
    
    var outputStream = new MemoryStream();
    saveOptions.OutputStream = outputStream;
    
    HtmlConverter.Process(loadOptions, saveOptions);
    outputStream.Position = 0;
    return outputStream;
}

// JSON conversion
public MemoryStream ConvertToJson(MemoryStream inputStream)
{
    LowCodeLoadOptions loadOptions = new LowCodeLoadOptions();
    loadOptions.InputStream = inputStream;
    
    LowCodeSaveOptions saveOptions = new LowCodeSaveOptions();
    var outputStream = new MemoryStream();
    saveOptions.OutputStream = outputStream;
    
    JsonConverter.Process(loadOptions, saveOptions);
    outputStream.Position = 0;
    return outputStream;
}

Langkah 6: Melaksanakan pemprosesan ralat untuk senario web

Menambah pemprosesan ralat yang betul khusus kepada persekitaran web:

try
{
    // Process execution code
    PdfConverter.Process(loadOptions, saveOptions);
    return File(outputStream.ToArray(), "application/pdf", "converted-document.pdf");
}
catch (Exception ex)
{
    // Log the error
    _logger.LogError(ex, "Error converting Excel file to PDF");
    
    // Return appropriate HTTP response
    return StatusCode(500, "An error occurred during file conversion. Please try again.");
}

Langkah 7: Mengoptimumkan prestasi aplikasi web

Pertimbangkan teknik pengoptimuman ini untuk persekitaran web:

// Implement an async version for better scalability
[HttpPost("convert-to-pdf-async")]
public async Task<IActionResult> ConvertToPdfAsync(IFormFile excelFile)
{
    if (excelFile == null || excelFile.Length == 0)
        return BadRequest("No file uploaded");
        
    using var inputStream = new MemoryStream();
    await excelFile.CopyToAsync(inputStream);
    inputStream.Position = 0;
    
    // Perform conversion on a background thread to free up web server threads
    return await Task.Run(() => {
        try
        {
            using var outputStream = new MemoryStream();
            // Conversion code as before
            PdfConverter.Process(loadOptions, saveOptions);
            
            return File(outputStream.ToArray(), "application/pdf", "converted-document.pdf");
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error in async conversion");
            throw;
        }
    });
}

Langkah 8: Contoh pelaksanaan lengkap

Berikut ialah contoh kerja lengkap pengawal API Web untuk penukaran format:

[ApiController]
[Route("api/[controller]")]
public class ExcelConverterController : ControllerBase
{
    private readonly ILogger<ExcelConverterController> _logger;
    
    public ExcelConverterController(ILogger<ExcelConverterController> logger)
    {
        _logger = logger;
    }
    
    [HttpPost("convert")]
    public async Task<IActionResult> ConvertExcelFile(IFormFile file, [FromQuery] string format)
    {
        if (file == null || file.Length == 0)
            return BadRequest("Please upload a file");
            
        using var inputStream = new MemoryStream();
        await file.CopyToAsync(inputStream);
        inputStream.Position = 0;
        
        // Initialize options
        LowCodeLoadOptions loadOptions = new LowCodeLoadOptions();
        loadOptions.InputStream = inputStream;
        
        using var outputStream = new MemoryStream();
        
        try
        {
            switch (format?.ToLower())
            {
                case "pdf":
                    LowCodePdfSaveOptions pdfOptions = new LowCodePdfSaveOptions();
                    pdfOptions.OutputStream = outputStream;
                    PdfConverter.Process(loadOptions, pdfOptions);
                    return ReturnFile(outputStream, "application/pdf", "converted.pdf");
                    
                case "html":
                    LowCodeHtmlSaveOptions htmlOptions = new LowCodeHtmlSaveOptions();
                    htmlOptions.OutputStream = outputStream;
                    HtmlConverter.Process(loadOptions, htmlOptions);
                    return ReturnFile(outputStream, "text/html", "converted.html");
                    
                case "json":
                    LowCodeSaveOptions jsonOptions = new LowCodeSaveOptions();
                    jsonOptions.OutputStream = outputStream;
                    JsonConverter.Process(loadOptions, jsonOptions);
                    return ReturnFile(outputStream, "application/json", "converted.json");
                    
                case "png":
                    LowCodeImageSaveOptions imgOptions = new LowCodeImageSaveOptions();
                    ImageOrPrintOptions imageTypeOptions = new ImageOrPrintOptions();
                    imageTypeOptions.ImageType = Aspose.Cells.Drawing.ImageType.Png;
                    imgOptions.ImageOptions = imageTypeOptions;
                    imgOptions.OutputStream = outputStream;
                    ImageConverter.Process(loadOptions, imgOptions);
                    return ReturnFile(outputStream, "image/png", "converted.png");
                    
                default:
                    return BadRequest("Unsupported format. Please use: pdf, html, json, or png");
            }
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error converting file to {Format}", format);
            return StatusCode(500, "An error occurred during conversion");
        }
    }
    
    private FileContentResult ReturnFile(MemoryStream stream, string contentType, string fileName)
    {
        stream.Position = 0;
        return File(stream.ToArray(), contentType, fileName);
    }
}

Penggunaan Kasus dan Permohonan

Sistem Penglihatan Dokumen Berasaskan Web

Membolehkan pengguna untuk memuat naik fail Excel dan melihat mereka dengan serta-merta sebagai HTML atau PDF tanpa memerlukan perisian Excel.

SaaS Platform Pemprosesan Data

Proses memuat naik data Excel dengan menukar kepada JSON untuk integrasi pangkalan, kemudian menghasilkan laporan dalam pelbagai format (PDF, HTML) untuk pihak berkepentingan yang berbeza - semua tanpa operasi cakera yang akan mempersulit pelaksanaan awan.

Perkhidmatan Konversi Dokumen Berasaskan API

Membina microservice khusus atau titik akhir API yang mengendalikan penukaran format Excel untuk aplikasi lain dalam ekosistem anda, menyediakan keupayaan konversi terpusat yang memelihara konsistensi di seluruh perkhidmatan anda.

Tantangan dan Penyelesaian Bersama

Tantangan 1: Menguruskan fail besar

** Penyelesaian:** Untuk fail yang melebihi sekatan memori, melaksanakan pemprosesan tertutup atau menggunakan streaming di sisi pelayan:

// For large files, consider setting timeout and memory limits
[RequestSizeLimit(100_000_000)] // 100MB limit
[RequestFormLimits(MultipartBodyLengthLimit = 100_000_000)]
public async Task<IActionResult> ConvertLargeFile(IFormFile file)
{
    // Implementation with resource monitoring
}

Tantangan 2: Pengurusan Permintaan Bersaing

** Penyelesaian:** Mengimplementasikan kuing dan penyelewengan sumber untuk mengelakkan kelebihan pelayan:

// Use a semaphore to limit concurrent conversions
private static SemaphoreSlim _conversionSemaphore = new SemaphoreSlim(5); // Max 5 concurrent

public async Task<IActionResult> ConvertWithThrottling(IFormFile file)
{
    await _conversionSemaphore.WaitAsync();
    try
    {
        // Conversion code
    }
    finally
    {
        _conversionSemaphore.Release();
    }
}

Tantangan 3 : Keselamatan

** Penyelesaian:** Melaksanakan pengesahan dan sanitasi fail input yang betul:

private bool ValidateExcelFile(IFormFile file)
{
    // Check file extension
    var extension = Path.GetExtension(file.FileName).ToLowerInvariant();
    if (extension != ".xlsx" && extension != ".xls" && extension != ".xlsm")
        return false;
        
    // Verify file signature/magic bytes
    using var headerStream = new MemoryStream();
    file.OpenReadStream().CopyTo(headerStream, 8); // Read first 8 bytes
    byte[] headerBytes = headerStream.ToArray();
    
    // Check for Excel file signatures
    return IsValidExcelFileSignature(headerBytes);
}

Pertimbangan prestasi

  • Gunakan pemprosesan asynchronous untuk semua operasi I/O untuk mengelakkan blok thread dalam pelayan web
  • Pertimbangkan pelaksanaan caching dokumen yang sering ditukar untuk mengurangkan beban pemprosesan
  • Untuk aplikasi trafik tinggi, melaksanakan perkhidmatan latar belakang khusus untuk pemprosesan penukaran

amalan terbaik

  • Sentiasa menyimpan objek MemoryStream untuk mengelakkan kebocoran memori, terutamanya dalam aplikasi web jangka panjang
  • Pelaksanaan had saiz fail yang sesuai dengan sumber-sumber pelayan anda
  • Menggunakan metrik dan pemantauan untuk memantau masa penukaran dan penggunaan sumber
  • Pertimbangkan pelaksanaan mekanisme pembatasan kadar untuk titik akhir penukaran untuk mengelakkan penyalahgunaan

Senario lanjutan

Untuk keperluan yang lebih kompleks, pertimbangkan pelaksanaan lanjutan ini:

Skenario 1: Pemprosesan batch pelbagai penukaran

[HttpPost("batch-convert")]
public async Task<IActionResult> BatchConvert(List<IFormFile> files, string format)
{
    if (files == null || !files.Any())
        return BadRequest("No files uploaded");
        
    var results = new List<ConversionResult>();
    
    foreach (var file in files)
    {
        using var inputStream = new MemoryStream();
        await file.CopyToAsync(inputStream);
        inputStream.Position = 0;
        
        using var outputStream = new MemoryStream();
        try
        {
            LowCodeLoadOptions loadOptions = new LowCodeLoadOptions();
            loadOptions.InputStream = inputStream;
            
            LowCodeSaveOptions saveOptions = new LowCodeSaveOptions();
            saveOptions.OutputStream = outputStream;
            
            switch (format.ToLower())
            {
                case "pdf":
                    PdfConverter.Process(loadOptions, saveOptions);
                    break;
                // Other formats...
            }
            
            results.Add(new ConversionResult { 
                FileName = file.FileName,
                Success = true,
                Data = Convert.ToBase64String(outputStream.ToArray())
            });
        }
        catch (Exception ex)
        {
            results.Add(new ConversionResult { 
                FileName = file.FileName,
                Success = false,
                ErrorMessage = ex.Message
            });
        }
    }
    
    return Ok(results);
}

Scenario 2: Manipulasi Spreadsheet Dinamik Sebelum Konversi

[HttpPost("modify-and-convert")]
public async Task<IActionResult> ModifyAndConvert(IFormFile file, 
    [FromQuery] string format,
    [FromBody] SpreadsheetModificationRequest modRequest)
{
    using var inputStream = new MemoryStream();
    await file.CopyToAsync(inputStream);
    inputStream.Position = 0;
    
    // First load the workbook to modify it
    Workbook workbook = new Workbook(inputStream);
    
    // Apply the requested modifications
    var worksheet = workbook.Worksheets[modRequest.WorksheetIndex];
    foreach (var cellMod in modRequest.CellModifications)
    {
        worksheet.Cells[cellMod.CellReference].PutValue(cellMod.NewValue);
    }
    
    // Now prepare for conversion
    using var modifiedStream = new MemoryStream();
    workbook.Save(modifiedStream, SaveFormat.Xlsx);
    modifiedStream.Position = 0;
    
    // Convert using LowCode converters
    LowCodeLoadOptions loadOptions = new LowCodeLoadOptions();
    loadOptions.InputStream = modifiedStream;
    
    using var outputStream = new MemoryStream();
    LowCodePdfSaveOptions saveOptions = new LowCodePdfSaveOptions();
    saveOptions.OutputStream = outputStream;
    
    PdfConverter.Process(loadOptions, saveOptions);
    
    outputStream.Position = 0;
    return File(outputStream.ToArray(), "application/pdf", "modified-and-converted.pdf");
}

Conclusion

Dengan melaksanakan dalam memori Excel format penukaran dengan Aspose.Cells LowCode Converters, pembangun web boleh secara signifikan meningkatkan aplikasi mereka dengan keupayaan pemprosesan dokumen yang kukuh tanpa ketergantungan sistem fail. pendekatan ini secara dramatik meningkatkan keselamatan dengan menghapuskan kerentanan fail sementara mengekalkan prestasi dan skala yang cemerlang untuk awan dan aplikasi SaaS.

Untuk maklumat lanjut dan contoh tambahan, rujuk kepada Aspose.Cells.LowCode API rujukan.

Sumber tambahan

  • Pelaksanaan Aspose.Cells SaveOptions boleh membantu menyesuaikan proses penukaran anda untuk memenuhi keperluan tertentu anda.

More in this category