Comment convertir les fichiers Excel en PDF en .NET

Cet article montre comment combiner la conversion de plusieurs fichiers Excel en PDF en utilisant l’Aspose.Cells LowCode PDF Converter dans les applications .NET. Le convertisseur PDF fournit une approche simplifiée de la transformation de documents sans nécessiter un codage extérieur ou une connaissance approfondie des structures intérieures d’Excel - parfait pour les analystes et les développeurs de rapports qui doivent automatiser leurs flux de travail de rapport.

Problème du monde réel

Dans les environnements d’entreprise, les équipes de rapports ont souvent besoin de convertir des dizaines ou même des centaines de livres de travail Excel dans le format PDF sur une base régulière. Faire cela manuellement est temps-consommant, erreur-prote, et distingue des ressources précieuses des tâches analytiques plus importantes.

Vue de la solution

En utilisant Aspose.Cells LowCode PDF Converter, nous pouvons résoudre ce défi efficacement avec un code minimum. Cette solution est idéale pour les analystes d’affaires et les développeurs de rapports qui ont besoin de rationaliser leurs processus de reporting, assurer la cohérence des documents, et libérer le temps pour un travail plus précieux. Notre approche se concentrera sur la création d’un système de traitement de lots robuste qui peut gérer de grands volumes de fichiers Excel avec des paramètres de conversion personnalisés.

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
Comprendre la programmation C#

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 et inclure les espaces de nom nécessaires:

using Aspose.Cells;
using Aspose.Cells.LowCode;
using System;
using System.IO;
using System.Collections.Generic;
using System.Threading.Tasks;

Étape 2: Créer une structure de directory pour le traitement de batch

Configurez une structure de catégorie pour organiser vos fichiers d’entrée Excel et de sortie PDF:

// Create directories if they don't exist
string inputDirectory = @"C:\Reports\ExcelFiles";
string outputDirectory = @"C:\Reports\PDFOutput";
string logDirectory = @"C:\Reports\Logs";

Directory.CreateDirectory(inputDirectory);
Directory.CreateDirectory(outputDirectory);
Directory.CreateDirectory(logDirectory);

Étape 3: Implémentation de la logique de découverte des fichiers

Créez une méthode pour découvrir tous les fichiers Excel qui doivent être convertis:

private List<string> GetExcelFilesToProcess(string directoryPath, string searchPattern = "*.xlsx")
{
    List<string> excelFiles = new List<string>();
    
    try
    {
        // Get all Excel files (.xlsx) in the directory
        string[] files = Directory.GetFiles(directoryPath, searchPattern);
        excelFiles.AddRange(files);
        
        // Optionally, you can also search for .xls files
        string[] oldFormatFiles = Directory.GetFiles(directoryPath, "*.xls");
        excelFiles.AddRange(oldFormatFiles);
        
        Console.WriteLine($"Found {excelFiles.Count} Excel files to process.");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Error searching for Excel files: {ex.Message}");
    }
    
    return excelFiles;
}

Étape 4 : Configurez les options de convertisseur PDF

Créez une méthode pour configurer les options de conversion PDF pour une sortie cohérente:

private LowCodePdfSaveOptions ConfigurePdfOptions(bool onePagePerSheet = true, 
                                                 bool includeHiddenSheets = false,
                                                 bool printComments = false)
{
    // Create PDF save options
    PdfSaveOptions pdfOpts = new PdfSaveOptions();
    
    // Set whether each worksheet should be rendered as a separate page
    pdfOpts.OnePagePerSheet = onePagePerSheet;
    
    // Option to include hidden worksheets in the output
    pdfOpts.AllColumnsInOnePagePerSheet = true;
    
    // Configure additional PDF options
    pdfOpts.Compliance = PdfCompliance.PdfA1b; // For archival quality
    pdfOpts.PrintingPageType = PrintingPageType.ActualSize;
    
    // Configure comment display options
    pdfOpts.PrintComments = printComments ? PrintCommentsType.PrintInPlace : PrintCommentsType.PrintNoComments;
    
    // Create low code PDF save options
    LowCodePdfSaveOptions lcsopts = new LowCodePdfSaveOptions();
    lcsopts.PdfOptions = pdfOpts;
    
    return lcsopts;
}

Étape 5: Implémentation de la logique de conversion de fichier unique

Créez une méthode pour convertir un seul fichier Excel en PDF:

private bool ConvertExcelToPdf(string inputFilePath, string outputFilePath, LowCodePdfSaveOptions pdfOptions)
{
    try
    {
        // Create load options
        LowCodeLoadOptions loadOptions = new LowCodeLoadOptions();
        loadOptions.InputFile = inputFilePath;
        
        // Set output file path
        pdfOptions.OutputFile = outputFilePath;
        
        // Process the conversion
        PdfConverter.Process(loadOptions, pdfOptions);
        
        return true;
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Error converting {Path.GetFileName(inputFilePath)}: {ex.Message}");
        return false;
    }
}

Étape 6: Implémentation de la logique de traitement de batch

Maintenant, créez la méthode principale qui traitera plusieurs fichiers:

public void BatchConvertExcelToPdf(string inputDirectory, string outputDirectory, string searchPattern = "*.xlsx")
{
    // Get all Excel files
    List<string> excelFiles = GetExcelFilesToProcess(inputDirectory, searchPattern);
    
    // Configure PDF options
    LowCodePdfSaveOptions pdfOptions = ConfigurePdfOptions(true, false, false);
    
    // Track conversion statistics
    int successCount = 0;
    int failureCount = 0;
    
    // Process each file
    foreach (string excelFile in excelFiles)
    {
        string fileName = Path.GetFileNameWithoutExtension(excelFile);
        string outputFilePath = Path.Combine(outputDirectory, $"{fileName}.pdf");
        
        Console.WriteLine($"Converting: {fileName}");
        
        bool success = ConvertExcelToPdf(excelFile, outputFilePath, pdfOptions);
        
        if (success)
        {
            successCount++;
            Console.WriteLine($"Successfully converted: {fileName}");
        }
        else
        {
            failureCount++;
            Console.WriteLine($"Failed to convert: {fileName}");
        }
    }
    
    // Report summary
    Console.WriteLine("\n===== Conversion Summary =====");
    Console.WriteLine($"Total files processed: {excelFiles.Count}");
    Console.WriteLine($"Successfully converted: {successCount}");
    Console.WriteLine($"Failed conversions: {failureCount}");
}

Étape 7: Implémentation du traitement parallèle pour une meilleure performance

Pour les grands lots, mettre en œuvre un traitement parallèle pour accélérer la conversion :

public void ParallelBatchConvertExcelToPdf(string inputDirectory, string outputDirectory, string searchPattern = "*.xlsx")
{
    // Get all Excel files
    List<string> excelFiles = GetExcelFilesToProcess(inputDirectory, searchPattern);
    
    // Track conversion statistics
    int successCount = 0;
    int failureCount = 0;
    object lockObj = new object();
    
    // Configure PDF options (will be reused for each conversion)
    LowCodePdfSaveOptions pdfOptions = ConfigurePdfOptions(true, false, false);
    
    // Process files in parallel
    Parallel.ForEach(excelFiles, 
        new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount }, 
        excelFile =>
    {
        string fileName = Path.GetFileNameWithoutExtension(excelFile);
        string outputFilePath = Path.Combine(outputDirectory, $"{fileName}.pdf");
        
        // Each thread needs its own copy of the options
        LowCodePdfSaveOptions threadPdfOptions = ConfigurePdfOptions(true, false, false);
        threadPdfOptions.OutputFile = outputFilePath;
        
        Console.WriteLine($"Converting: {fileName}");
        
        // Create load options
        LowCodeLoadOptions loadOptions = new LowCodeLoadOptions();
        loadOptions.InputFile = excelFile;
        
        try
        {
            // Process the conversion
            PdfConverter.Process(loadOptions, threadPdfOptions);
            
            lock (lockObj)
            {
                successCount++;
                Console.WriteLine($"Successfully converted: {fileName}");
            }
        }
        catch (Exception ex)
        {
            lock (lockObj)
            {
                failureCount++;
                Console.WriteLine($"Failed to convert {fileName}: {ex.Message}");
            }
        }
    });
    
    // Report summary
    Console.WriteLine("\n===== Conversion Summary =====");
    Console.WriteLine($"Total files processed: {excelFiles.Count}");
    Console.WriteLine($"Successfully converted: {successCount}");
    Console.WriteLine($"Failed conversions: {failureCount}");
}

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

Voici un exemple de travail complet qui démontre l’ensemble du processus de conversion de batch:

using Aspose.Cells;
using Aspose.Cells.LowCode;
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;

namespace ExcelBatchConverter
{
    public class ExcelToPdfBatchConverter
    {
        private readonly string _inputDirectory;
        private readonly string _outputDirectory;
        private readonly string _logDirectory;
        
        public ExcelToPdfBatchConverter(string inputDirectory, string outputDirectory, string logDirectory)
        {
            _inputDirectory = inputDirectory;
            _outputDirectory = outputDirectory;
            _logDirectory = logDirectory;
            
            // Ensure directories exist
            Directory.CreateDirectory(_inputDirectory);
            Directory.CreateDirectory(_outputDirectory);
            Directory.CreateDirectory(_logDirectory);
        }
        
        // Log the conversion activity
        private void LogConversion(string message)
        {
            string logFilePath = Path.Combine(_logDirectory, $"ConversionLog_{DateTime.Now.ToString("yyyyMMdd")}.txt");
            string logEntry = $"[{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}] {message}";
            
            try
            {
                File.AppendAllText(logFilePath, logEntry + Environment.NewLine);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Warning: Unable to write to log file: {ex.Message}");
            }
            
            Console.WriteLine(logEntry);
        }
        
        // Get all Excel files to process
        private List<string> GetExcelFilesToProcess(string searchPattern = "*.xlsx")
        {
            List<string> excelFiles = new List<string>();
            
            try
            {
                // Get all Excel files in the directory
                excelFiles.AddRange(Directory.GetFiles(_inputDirectory, "*.xlsx"));
                excelFiles.AddRange(Directory.GetFiles(_inputDirectory, "*.xls"));
                excelFiles.AddRange(Directory.GetFiles(_inputDirectory, "*.xlsm"));
                
                LogConversion($"Found {excelFiles.Count} Excel files to process.");
            }
            catch (Exception ex)
            {
                LogConversion($"Error searching for Excel files: {ex.Message}");
            }
            
            return excelFiles;
        }
        
        // Configure PDF conversion options
        private LowCodePdfSaveOptions ConfigurePdfOptions()
        {
            // Create PDF save options
            PdfSaveOptions pdfOpts = new PdfSaveOptions();
            
            // Set whether each worksheet should be rendered as a separate page
            pdfOpts.OnePagePerSheet = true;
            
            // Set additional PDF options
            pdfOpts.Compliance = PdfCompliance.PdfA1b; // For archival quality
            pdfOpts.AllColumnsInOnePagePerSheet = true;
            
            // Create low code PDF save options
            LowCodePdfSaveOptions lcsopts = new LowCodePdfSaveOptions();
            lcsopts.PdfOptions = pdfOpts;
            
            return lcsopts;
        }
        
        // Process all Excel files in the input directory
        public void ProcessAllFiles(bool useParallelProcessing = true)
        {
            LogConversion("Starting batch conversion process...");
            
            List<string> excelFiles = GetExcelFilesToProcess();
            
            if (excelFiles.Count == 0)
            {
                LogConversion("No Excel files found to process.");
                return;
            }
            
            // Conversion statistics
            int successCount = 0;
            int failureCount = 0;
            
            if (useParallelProcessing)
            {
                // For thread safety with parallel processing
                object lockObj = new object();
                
                // Process files in parallel
                Parallel.ForEach(excelFiles, 
                    new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount }, 
                    excelFile =>
                {
                    string fileName = Path.GetFileNameWithoutExtension(excelFile);
                    string outputFilePath = Path.Combine(_outputDirectory, $"{fileName}.pdf");
                    
                    try
                    {
                        // Create load options for this file
                        LowCodeLoadOptions loadOptions = new LowCodeLoadOptions();
                        loadOptions.InputFile = excelFile;
                        
                        // Configure PDF options for this file
                        LowCodePdfSaveOptions pdfOptions = ConfigurePdfOptions();
                        pdfOptions.OutputFile = outputFilePath;
                        
                        // Process the conversion
                        PdfConverter.Process(loadOptions, pdfOptions);
                        
                        lock (lockObj)
                        {
                            successCount++;
                            LogConversion($"Successfully converted: {fileName}");
                        }
                    }
                    catch (Exception ex)
                    {
                        lock (lockObj)
                        {
                            failureCount++;
                            LogConversion($"Failed to convert {fileName}: {ex.Message}");
                        }
                    }
                });
            }
            else
            {
                // Process files sequentially
                foreach (string excelFile in excelFiles)
                {
                    string fileName = Path.GetFileNameWithoutExtension(excelFile);
                    string outputFilePath = Path.Combine(_outputDirectory, $"{fileName}.pdf");
                    
                    try
                    {
                        // Create load options for this file
                        LowCodeLoadOptions loadOptions = new LowCodeLoadOptions();
                        loadOptions.InputFile = excelFile;
                        
                        // Configure PDF options for this file
                        LowCodePdfSaveOptions pdfOptions = ConfigurePdfOptions();
                        pdfOptions.OutputFile = outputFilePath;
                        
                        // Process the conversion
                        PdfConverter.Process(loadOptions, pdfOptions);
                        
                        successCount++;
                        LogConversion($"Successfully converted: {fileName}");
                    }
                    catch (Exception ex)
                    {
                        failureCount++;
                        LogConversion($"Failed to convert {fileName}: {ex.Message}");
                    }
                }
            }
            
            // Report summary
            LogConversion("\n===== Conversion Summary =====");
            LogConversion($"Total files processed: {excelFiles.Count}");
            LogConversion($"Successfully converted: {successCount}");
            LogConversion($"Failed conversions: {failureCount}");
            LogConversion("Batch conversion process completed.");
        }
    }
    
    class Program
    {
        static void Main(string[] args)
        {
            // Define directory paths
            string inputDirectory = @"C:\Reports\ExcelFiles";
            string outputDirectory = @"C:\Reports\PDFOutput";
            string logDirectory = @"C:\Reports\Logs";
            
            // Create and run the converter
            ExcelToPdfBatchConverter converter = new ExcelToPdfBatchConverter(
                inputDirectory, outputDirectory, logDirectory);
                
            // Process all files (using parallel processing)
            converter.ProcessAllFiles(true);
            
            Console.WriteLine("Process completed. Press any key to exit.");
            Console.ReadKey();
        }
    }
}

Utiliser les cas et les applications

Systèmes d’information entrepreneuriale

Dans les systèmes de déclaration financière, les cycles de fin de mois ou de trimestre nécessitent souvent la conversion de nombreux rapports basés sur Excel dans le format PDF pour la distribution aux parties prenantes. Cette solution de convergence de batch permet aux développeurs de rapport d’automatiser le processus, en veillant à ce que tous les rappels soient convertis avec des paramètres cohérents et de la formatisation, tout en réduisant considérablement l’effort manuel. Les reportages peuvent être automatiquement archivés dans un format standardisé, rendant la réception et la conformité plus faciles.

Traitement des données départementales

Les analystes d’affaires qui recueillent des données basées sur Excel à partir de plusieurs départements peuvent utiliser cette solution pour normaliser et enregistrer les présentations. En convertisant automatiquement les livres de travail reçus en PDF, ils créent un registre permanent de la présentation de données tout en rendant les informations partagables avec les parties prenantes qui n’ont pas Excel.

Gestion automatique des flux de travail

L’intégration avec les systèmes de gestion des documents devient sans signe lorsque les rapports Excel sont automatiquement convertis en PDF. Cette solution peut être programmée pour fonctionner dans le cadre d’un plus grand flux de travail qui récupère de nouveaux fichiers Excel, les convertit en pdf, puis les guide dans les repositaires de documents appropriés avec des métadonnées appropriées. Le formatage cohérent et la qualité des archives de la sortie PDF assure l’accessibilité à long terme des données commerciales.

Défis communs et solutions

Défi 1 : Traiter les fichiers Excel avec la protection des mots de passe

Solution: Modifiez les options de chargement pour inclure la gestion de mot de passe:

// For password-protected Excel files
LowCodeLoadOptions loadOptions = new LowCodeLoadOptions();
loadOptions.InputFile = excelFile;
loadOptions.Password = "YourPassword"; // Supply the password

// Then proceed with conversion as normal
PdfConverter.Process(loadOptions, pdfOptions);

Défi 2 : Maintenir le formatage Excel dans la sortie PDF

Solution: Assurez-vous que les options PDF sont correctement configurées pour préserver le formatage :

PdfSaveOptions pdfOpts = new PdfSaveOptions();
pdfOpts.OnePagePerSheet = true;
pdfOpts.PrintingPageType = PrintingPageType.ActualSize;
pdfOpts.DefaultFontName = "Arial"; // Specify a fallback font
pdfOpts.Compliance = PdfCompliance.PdfA1b; // For archival quality

Défi 3 : Traiter les fichiers Excel très grands

Solution: Pour les fichiers extrêmement grands, implémenter l’optimisation de la mémoire :

LowCodeLoadOptions loadOptions = new LowCodeLoadOptions();
loadOptions.InputFile = largeExcelFile;
loadOptions.MemorySetting = MemorySetting.MemoryPreference; // Optimize for memory usage

// Consider file-specific optimizations
PdfSaveOptions pdfOpts = new PdfSaveOptions();
pdfOpts.OptimizationType = OptimizationType.MinimumSize;

Considérations de performance

Pour des performances optimales avec de grands lots, utilisez l’approche de traitement parallèle avec une méthode raisonnable. MaxDegreeOfParallelism Sur la base des capacités de votre serveur
Envisagez de traiter les fichiers dans des pièces plus petites lorsque vous traitez des livres de travail Excel très grands pour éviter la pression mémoire
Implémentation d’un mécanisme de suivi pour suivre le progrès de la conversion et l’utilisation des ressources
Pour les déploiements de production, considérez le déroulement du processus de conversion sur un serveur dédié ou pendant les heures off-peak

Migliori pratiche

Pré-valider les fichiers Excel avant le traitement d’emballage pour identifier les problèmes potentiels
Mettre en œuvre une gestion robuste d’erreur pour s’assurer que le processus ne cesse pas si un fichier échoue
** Créer des journaux détaillés** du processus de conversion pour la résolution des problèmes et l’audit
Organisez les PDF de sortie dans une hiérarchie de dossiers structurée pour faciliter la gestion
Construire un système de surveillance qui alerte les administrateurs d’échecs de conversion
Teste avec différents types de fichiers Excel (XLSX, XLS et XLSM) pour assurer la compatibilité

Scénarios avancés

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

Scénario 1: Noms PDF personnalisés basés sur le contenu de la cellule Excel

Vous pouvez extraire des valeurs cellulaires spécifiques à utiliser dans le nom de fichier PDF :

// Advanced naming based on cell content
private string GetCustomPdfName(string excelFilePath)
{
    try
    {
        // Load the workbook
        Workbook workbook = new Workbook(excelFilePath);
        
        // Get report date from cell A1
        string reportDate = workbook.Worksheets[0].Cells["A1"].StringValue;
        
        // Get report type from cell B1
        string reportType = workbook.Worksheets[0].Cells["B1"].StringValue;
        
        // Create a custom name
        string customName = $"{reportType}_{reportDate}";
        
        // Sanitize the filename
        foreach (char invalidChar in Path.GetInvalidFileNameChars())
        {
            customName = customName.Replace(invalidChar, '_');
        }
        
        return customName + ".pdf";
    }
    catch
    {
        // Fallback to default naming if extraction fails
        return Path.GetFileNameWithoutExtension(excelFilePath) + ".pdf";
    }
}

Scénario 2 : Conversion sélective

Convertir uniquement des feuilles spécifiques de chaque fichier Excel:

// Configure PDF options to convert only specific sheets
private LowCodePdfSaveOptions ConfigureSelectiveSheetsOptions(string[] sheetNames)
{
    PdfSaveOptions pdfOpts = new PdfSaveOptions();
    pdfOpts.OnePagePerSheet = true;
    
    // Create a worksheet name collection for selective conversion
    WorksheetCollection worksheets = new WorksheetCollection();
    foreach (string sheetName in sheetNames)
    {
        worksheets.Add(sheetName);
    }
    
    // Set sheet selection
    SheetOptions sheetOptions = new SheetOptions();
    sheetOptions.SheetNames = worksheets;
    pdfOpts.SheetOptions = sheetOptions;
    
    // Create low code PDF save options
    LowCodePdfSaveOptions lcsopts = new LowCodePdfSaveOptions();
    lcsopts.PdfOptions = pdfOpts;
    
    return lcsopts;
}

Conclusion

En implémentant Aspose.Cells LowCode PDF Converter pour le traitement de pièces, les analystes d’affaires et les développeurs de rapports peuvent réduire considérablement le temps dépensé sur les conversions manuelles Excel à PDF. Cette approche améliore significativement la productivité et assure la cohérence dans tous les PDF générés tout en gardant la qualité et le formatage des fichiers Excel originaux. La solution est scalable de l’utilisation de petits départements à des systèmes de reporting dans le monde des entreprises, avec des options de personnalisation pour répondre aux exigences commerciales spécifiques.

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