PDF Převaděč
Jak převést Excel soubory do PDF v .NET

Jak převést Excel soubory do PDF v .NET

Tento článek ukazuje, jak kombinovat konverzi několika Excelových souborů do PDF pomocí aplikace Aspose.Cells LowCode PDF Converter v aplikacích .NET. Konvertor PDF poskytuje zjednodušený přístup k převodu dokumentů, aniž by vyžadoval rozsáhlé kódování nebo hluboké znalosti vnitřních struktur Excelu - ideální pro obchodní analytiky a vývojáře zpráv, kteří potřebují automatizovat své reportovací pracovní toky.

Reálný světový problém

V podnikových prostředí, reporting týmy často potřebují konvertovat desítky nebo dokonce stovky Excel pracovních knih do formátu PDF pravidelně. dělat to ručně je časově náročný, chybově odolný a odstraňuje cenné zdroje od důležitějších analytických úkolů. Kromě toho, zajistit konzistentní formátování a uspořádání přes všechny zprávy je obtížné při konverzi souborů individuálně.

Řešení přehled

Pomocí Aspose.Cells LowCode PDF Converter můžeme tento problém efektivně vyřešit s minimálním kódem. Toto řešení je ideální pro obchodní analytiky a vývojáře zpráv, kteří potřebují zjednodušit své procesy hlášení, zajistit konzistenci dokumentů a uvolnit čas na cennější práci. Náš přístup se zaměří na vytvoření robustního systému zpracování souborů, který může zvládnout velké množství součástí Excelu s přizpůsobenými nastaveními konverze.

Předpoklady

Před provedením řešení se ujistěte, že máte:

  • Visual Studio 2019 nebo novější
  • • .NET 6.0 nebo novější (kompatibilní s .Net Framework 4.6.2+)
  • Aspose.Cells pro balíček .NET nainstalovaný prostřednictvím NuGet
  • Základní znalosti C# programování
PM> Install-Package Aspose.Cells

krok za krokem implementace

Krok 1: Instalace a nastavení Aspose.Cells

Přidejte do vašeho projektu balíček Aspose.Cells a zahrněte potřebné názevové prostory:

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

Krok 2: Vytvořte strukturu adresáře pro zpracování batchů

Vytvořte strukturu adresáře pro organizaci vašich vstupních souborů Excel a výstupní soubory 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);

Krok 3: Implementace logiky objevování souborů

Vytvořte metodu pro objevování všech Excelových souborů, které potřebují konverzi:

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

Krok 4: Nastavení možností PDF Converter

Vytvořte metodu pro nastavení možností konverze PDF pro konzistentní výstup:

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

Krok 5: Implementace jednotné logiky konverze souborů

Vytvořte metodu pro konverzi jednoho souboru Excel do 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;
    }
}

Krok 6: implementace batch zpracování logiky

Nyní vytvořte hlavní metodu, která bude zpracovávat více souborů:

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

Krok 7: Provádění paralelního zpracování pro lepší výkon

Pro velké balíčky implementujte paralelní zpracování pro urychlení konverze:

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

Krok 8: Kompletní příklad provádění

Zde je kompletní pracovní příklad, který ukazuje celý proces konverze 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();
        }
    }
}

Použití případů a aplikací

Enterprise Reporting Systémy

V systémech finančního hlášení, měsíční nebo čtvrtletní cykly často vyžadují konverzi četných zpráv založených na Excelu do formátu PDF pro distribuci zainteresovaným stranám. Toto řešení konverze balíčku umožňuje vývojářům zpráv automatizovat proces, zaručuje, že všechny zprávy jsou konverzovány s konzistentními nastaveními a formátováním, zatímco dramaticky snižuje manuální úsilí.

Oddělení zpracování údajů

Obchodní analytici, kteří shromažďují data založené na Excelu z několika oddělení, mohou toto řešení použít k standardizaci a archivování předložení. Automaticky převáděním obdržených pracovních knih do PDF vytvářejí trvalý záznam datových předloží a zároveň dělají informace sdílené s zúčastněnými stranami, které nemají Excel.

Automatizované pracovní toky pro správu dokumentů

Integrace s systémy správy dokumentů se stává bezproblémovou, když jsou zprávy Excelu automaticky převedeny na PDF. Toto řešení může být naplánováno k provozu jako součást většího pracovního toku, který vytváří nové soubory Excel, konvertuje je do PDF, a pak je přesměruje do příslušných záznamů dokumentu s odpovídajícími metadatami.

Společné výzvy a řešení

Výzva 1: Zpracování Excelových souborů s ochranou hesla

Rozhodnutí: Změňte možnosti nabíjení, abyste zahrnovali zpracování hesla:

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

Výzva 2: Udržování Excel Formátování v PDF Output

Rozhodnutí: Ujistěte se, že možnosti PDF jsou správně konfigurovány pro zachování formátování:

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

Výzva 3: Zpracování velkých Excelových souborů

Rozhodnutí: U extrémně velkých souborů se provádí optimalizace paměti:

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;

Úvahy o výkonu

  • Pro optimální výkon s velkými baleními použijte přístup k paralelnímu zpracování s přiměřeným MaxDegreeOfParallelism Na základě možností vašeho serveru
  • Zvažte zpracování souborů v menších souborech, když se zabýváte velmi velkými knihami Excelu, abyste se vyhnuli tlaku paměti
  • Zavedení monitorovacího mechanismu pro sledování pokroku konverze a využívání zdrojů
  • Pro výrobní deploymenty, zvážit spuštění procesu konverze na dedikovaném serveru nebo během off-peak hodin

Nejlepší postupy

  • Předběžně ověřte soubory Excel před zpracováním souborů k identifikaci potenciálních problémů
  • Vykonání robustní manipulace s chybami, aby se ujistil, že proces se nezastaví, pokud jeden soubor selže
  • Vytvořte podrobné záznamy o procesu konverze pro řešení problémů a audit
  • Organizujte výstupní PDF v strukturované složkové hierarchii pro jednodušší správu
  • Nastavení monitorovacího systému, který upozorňuje správce na poruchy konverze
  • Testování s různými typy souborů Excelu (XLSX, XLS a XLSM) pro zajištění kompatibility

Pokročilé scénáře

Pro složitější požadavky, zvážit tyto pokročilé implementace:

Scénář 1: Přizpůsobené názvy PDF založené na obsahu Excel Cell

Můžete extrahovat určité hodnoty buněk pro použití v souboru 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énář 2: Selektivní konverze listů

Konvertovat pouze konkrétní listy z každého souboru 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;
}

závěr

Prováděním aplikace Aspose.Cells LowCode PDF Converter pro zpracování souborů mohou obchodní analytici a vývojáři zpráv dramaticky snížit čas strávený na manuální konverze Excelu do PDF. Tento přístup výrazně zlepšuje produktivitu a zajišťuje konzistenci ve všech generovaných PDF, při zachování kvality a formátování původních Excelových součástí.

Pro další informace a další příklady se podívejte na Aspose.Cells.LowCode API Reference .

 Čeština