Šiame straipsnyje parodyta, kaip įgyvendinti “Excel” formato konvertavimą atmintyje naudojant “Aspose.Cells LowCode Converters” .NET žiniatinklio programas.Šie konverteriai suteikia supaprastintą požiūrį į Excel formatų transformacijas, nereikalaujant didelio kodavimo ar laikinųjų failų išsaugojimo į diską, todėl jie idealūs interneto ir SaaS aplinkoms.

Realaus pasaulio problemos

Internetinės programos dažnai turi apdoroti naudotojų įkeltus „Excel“ failus ir konvertuoti juos į skirtingus formatus, tokius kaip PDF, HTML ar JSON, kad būtų galima peržiūrėti, dalytis ar ištraukti duomenis. Tradiciniai metodai dažnai apima laikinų failų išsaugojimą diske, kuris kelia saugumo klausimus, failo valdymą ir galimas skalavimo problemas debesyje aplinkoje.

Sprendimo apžvalga

Naudodami „Aspose.Cells LowCode Converters“, mes galime efektyviai išspręsti šią problemą atliekant visas konvertavimus atmintyje.Šis sprendimas idealus tinklų kūrėjams ir „SaaS“ architektams, kuriems reikia įgyvendinti saugias, skalavimo dokumentų apdorojimo funkcijas be sudėtingų failų sistemos operacijų.

Prerequisites

Prieš įgyvendinant sprendimą, įsitikinkite, kad turite:

  • „Visual Studio 2019“ arba vėliau
  • .NET 6.0 arba naujesnė (kompatyvi su .Net Framework 4.6.2+)
  • Aspose.Cells .NET paketui, įdiegtam naudojant NuGet
  • Interneto programos projektas (ASP.NET Core MVC, Web API ir kt.)
PM> Install-Package Aspose.Cells

Žingsnis po žingsnio įgyvendinimas

1 žingsnis: Įdiegti ir konfigūruoti Aspose.Cells

Pridėti Aspose.Cells paketą į savo tinklalapio projektą ir įtraukti reikiamus pavadinimų erdves:

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

2 žingsnis: sukurti valdytojo metodą tvarkyti failų konvertavimą

Įveskite API galutinį tašką arba valdytojo metodą, kad priimtumėte failų įkėlimus ir grąžintumėte konvertuotus formatus:

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

3 žingsnis: atminties konvertavimo logika

Perdirbti įkeltą failą ir paversti jį visiškai atmintyje:

// 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);

4 žingsnis: grąžinti konvertuotą failą klientui

Grąžinkite konvertuotą failą kaip atsisiųstamą atsakymą:

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

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

5 žingsnis: Įdiegti skirtingus konvertavimo tipus

Pridėti metodus kitiems konvertavimo formatus, pavyzdžiui, HTML, JSON ir vaizdus:

// 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;
}

6 žingsnis: įgyvendinti klaidų tvarkymą žiniatinklio scenarijų

Įveskite tinkamą klaidų tvarkymą konkrečiai žiniatinklio aplinkai:

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

7 žingsnis: optimizuokite žiniatinklio taikomųjų programų veikimą

Apsvarstykite šias optimizavimo technologijas žiniatinklio aplinkoms:

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

8 žingsnis: pilnas įgyvendinimo pavyzdys

Štai pilnas darbo pavyzdys Web API valdytojo formatų konvertavimui:

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

Naudokite atvejus ir paraiškas

Interneto dokumentų žiūrovų sistemos

Leidžia vartotojams įkelti Excel failus ir nedelsiant juos peržiūrėti kaip HTML ar PDF be reikalaujant Excel programinės įrangos.

SaaS duomenų apdorojimo platformos

Procesas įkelia Excel duomenis konvertuojant į JSON duomenų bazės integracijai, tada sukuria ataskaitas įvairiuose formatuose (PDF, HTML) skirtingiems suinteresuotosioms šalims - visi be disko operacijų, kurios sudėtintų debesų įdiegimą.

API pagrįstos dokumentų konvertavimo paslaugos

Sukurkite specializuotą mikroservice arba API galutinį tašką, kuris tvarko “Excel” formato konvertavimus kitiems jūsų ekosistemo programoms, suteikiant centralizuoto konversijos galimybę, kuri palaiko nuoseklumą visose jūsų paslaugose.

Bendrieji iššūkiai ir sprendimai

1 iššūkis: didelių failų tvarkymas

Išsprendimas: Jei failai viršija atminties apribojimus, atlikite apdorojimą arba naudokite streiką serverio pusėje:

// 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
}

2 iššūkis: konkurencinis reikalavimų valdymas

Išsprendimas: Implementavimas ir išteklių šalinimas, kad būtų užkirstas kelias serverio perkrovimui:

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

3 iššūkis: saugumo problemos

Išsprendimas: Įdiegti tinkamą įvesties failų patvirtinimą ir sanitaciją:

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

Veiksmingumo apžvalgos

  • Naudokite asynchroninį apdorojimą visoms I/O operacijoms, kad išvengtumėte tinklinio serverio juostos blokavimo
  • Apsvarstykite dažnai konvertuotų dokumentų atsargų įgyvendinimą, kad sumažintumėte apdorojimo apkrovą
  • Dėl didelio srauto taikomų programų, įgyvendinant dedikuotą fonos paslaugą konvertavimo procesams

Geriausios praktikos

  • Visada atsisakykite „MemoryStream“ objektų, kad būtų užkirstas kelias atminties bėgiams, ypač ilgalaikiuose interneto programose
  • Įdiegti failų dydžio apribojimus, kurie atitinka jūsų serverio išteklius
  • Naudokite metriką ir stebėjimą, kad stebėtumėte konvertavimo laiką ir išteklių naudojimą
  • Apsvarstykite konvertavimo galutinių taškų ribojimo mechanizmo įgyvendinimą, kad būtų išvengta piktnaudžiavimo

Išplėstiniai scenarijai

Siekiant sudėtingesnių reikalavimų, apsvarstykite šiuos pažangius įgyvendinimus:

1 scenarijus: Multi-Conversion Batch apdorojimas

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

2 scenarijus: Dynamic Spreadsheet Manipulation prieš konvertavimą

[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

Taikydami “Excel” formatų konvertavimą į atmintį su “Aspose.Cells LowCode Converters”, žiniatinklio kūrėjai gali žymiai tobulinti savo programas su tvirtomis dokumentų apdorojimo galimybėmis be failų sistemos priklausomybės. Šis metodas gerokai pagerina saugumą pašalinant laikinus failo pažeidimus, tuo pačiu išlaikant puikią našumą ir skalavimą debesų ir SaaS programoms.

Norėdami gauti daugiau informacijos ir papildomų pavyzdžių, žr. Aspose.Cells.LowCode API nuoroda.

Papildomi ištekliai

  • Įgyvendinimas Aspose.Cells SaveOptions gali padėti pritaikyti savo konvertavimo procesą, kad atitiktų jūsų konkrečius poreikius.

More in this category