Cet article démontre comment mettre en œuvre la conversion de format Excel en mémoire en utilisant les Aspose.Cells LowCode Converters dans les applications web .NET. Ces convertis fournissent une approche simplifiée pour gérer les transformations des formats Excel sans nécessiter un codage étendu ou économiser des fichiers temporaires sur le disque, ce qui les rend idéaux pour les environnements Web et SaaS.

Problème du monde réel

Les applications Web ont souvent besoin de traiter les fichiers Excel téléchargés par les utilisateurs et de les convertir en différents formats tels que PDF, HTML ou JSON pour la visualisation, le partage ou l’extraction de données. Les approches traditionnelles impliquent souvent le sauvegarde temporaire des ficher sur le disque, ce qui introduit des préoccupations de sécurité, la gestion du fichier, et des problèmes potentiels d’escalabilité dans les environnements en nuage.

Vue de la solution

Avec Aspose.Cells LowCode Converters, nous pouvons résoudre ce défi efficacement en effectuant toutes les conversions dans la mémoire. Cette solution est idéale pour les développeurs web et les architectes SaaS qui doivent mettre en œuvre des fonctionnalités de traitement de documents sécurisées et scalables sans opérations de système de fichiers complexes.

Principaux

Avant de mettre en œuvre la solution, assurez-vous que vous avez :

  • Visual Studio 2019 ou ultérieur
  • .NET 6.0 ou ultérieur (compatible avec le framework 4.6.2+)
  • Aspose.Cells pour le package .NET installé via NuGet
  • Un projet d’application Web (ASP.NET Core MVC, Web API, etc.)
PM> Install-Package Aspose.Cells

La mise en œuvre étape par étape

Étape 1 : Installer et configurer Aspose.Cells

Ajouter le paquet Aspose.Cells à votre projet web et inclure les espaces de nom nécessaires:

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

Étape 2: Créer une méthode de contrôleur pour gérer la conversion de fichiers

Configurez une méthode de bouton API ou de contrôleur pour accepter les téléchargements de fichiers et retourner les formats convertis :

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

Étape 3: Implémentation de la logique de conversion en mémoire

Traiter le fichier téléchargé et le convertir entièrement en mémoire :

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

Étape 4 : Retourner le fichier converti au client

Retourner le fichier converti en réponse téléchargable :

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

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

Étape 5: Implémenter différents types de conversion

Ajouter des méthodes pour d’autres formats de conversion tels que HTML, JSON et images:

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

Étape 6 : Traitement des erreurs pour les scénarios Web

Ajoutez le traitement d’erreur approprié spécifique aux environnements 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.");
}

Étape 7 : Optimiser la performance des applications Web

Considérons ces techniques d’optimisation pour les environnements 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;
        }
    });
}

Étape 8: Exemple complet de la mise en œuvre

Voici un exemple de travail complet d’un contrôleur Web API pour la conversion de 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);
    }
}

Utiliser les cas et les applications

Système Web Document Viewer

Permet aux utilisateurs de télécharger les fichiers Excel et de les visualiser instantanément en tant que HTML ou PDF sans nécessiter le logiciel Excel. Cela permet la compatibilité cross-platform et la visualisation de document mobile directement dans le navigateur.

Plateformes de traitement de données SaaS

Le processus a téléchargé les données d’Excel en convertissant à JSON pour l’intégration de la base de données, puis génère des rapports dans différents formats (PDF, HTML) pour différentes parties prenantes - toutes sans opérations sur le disque qui compliqueraient les déploiements dans le cloud.

Services de conversion de documents API

Construisez un microservice spécialisé ou un endpoint API qui gère les conversions de format Excel pour d’autres applications dans votre écosystème, offrant une capacité de conversion centralisée qui maintient la cohérence à travers vos services.

Défis communs et solutions

Défi 1 : Traitement des fichiers

Résolution: Pour les fichiers qui dépassent les limites de mémoire, mettre en œuvre un processus chunked ou utiliser le streaming sur le côté du serveur:

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

Défi 2 : Gestion des demandes concurrentielles

Solution: Implémentation de la couverture et de l’échappement des ressources pour empêcher le surcharge du serveur:

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

Défi 3 : les préoccupations en matière de sécurité

Solution: Implémenter la validation et la sanitation appropriées des fichiers d’entrée:

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

Considérations de performance

  • Utilisez le traitement asynchronique pour toutes les opérations I/O pour empêcher le blocage de fil dans le serveur web
  • Considérer la mise en œuvre du caching de documents fréquemment convertis pour réduire la charge de traitement
  • Pour les applications à trafic élevé, mettre en œuvre un service de fond dédié pour le traitement des conversions

Migliori pratiche

  • Disposez toujours des objets MemoryStream pour éviter les fuites de mémoire, en particulier dans les applications web à long terme
  • Implémenter les limites de taille de fichier appropriées aux ressources de votre serveur
  • Utilisez les métrics et le suivi pour suivre les temps de conversion et l’utilisation des ressources
  • Considérer la mise en œuvre d’un mécanisme de limitation des taux pour les points de conversion pour prévenir l’abus

Scénarios avancés

Pour des exigences plus complexes, considérez ces applications avancées :

Scénario 1 : Traitement des conversions multiples

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

Scénario 2 : Manipulation dynamique avant la conversion

[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

En implémentant la conversion de format Excel en mémoire avec Aspose.Cells LowCode Converters, les développeurs web peuvent améliorer considérablement leurs applications avec des capacités de traitement de documents robustes sans dépendances du système de fichiers. Cette approche améliore considérativement la sécurité en éliminant les vulnérabilités temporelles du fichier tout en préservant une excellente performance et l’escalabilité pour les applications cloud et SaaS.

Pour plus d’informations et de exemples supplémentaires, consultez le Aspose.Cells.LowCode API de référence.

Ressources supplémentaires

  • La mise en œuvre de Aspose.Cells SaveOptions peut vous aider à personnaliser votre processus de conversion pour répondre à vos besoins spécifiques.

More in this category