Kaip konvertuoti Excel failus į PDF .NET

Šiame straipsnyje parodyta, kaip konvertuoti kelis „Excel“ failus į PDF naudojant „Aspose.Cells LowCode PDF Converter“ .NET programas. „PDF“ konverteris suteikia supaprastintą požiūrį į dokumentų konvertavimą, nereikalaujant išsamios kodavimo ar gilių žinių apie Excel vidaus struktūras - idealiai tinka verslo analitikai ir ataskaitų kūrėjai, kuriems reikia automatizuoti savo ataskaitos darbo srautus.

Realaus pasaulio problemos

Verslo aplinkoje ataskaitų komandoms dažnai reikia reguliariai konvertuoti dešimtis ar net šimtus „Excel“ darbinių knygų į PDF formatą. Tai atliekama rankiniu būdu - laiko, klaidų ir vertingų išteklių atskyrimas nuo svarbesnių analitinių užduočių. Be to, užtikrinant nuoseklų formatavimą ir visų pranešimų išdėstymą yra sudėtinga konvertavus failus atskirai.

Sprendimo apžvalga

Naudojant Aspose.Cells LowCode PDF Converter, mes galime efektyviai išspręsti šį iššūkį su minimaliu kodu. Šis sprendimas idealus verslo analitikai ir ataskaitų kūrėjai, kurie turi supaprastinti savo ataskaitos procesus, užtikrinti dokumentų nuoseklumą ir laisviau laiko vertingesniam darbui. Mūsų požiūris bus sutelktas į tvirtą batch apdorojimo sistemą, kuri gali tvarkyti didelius tūrius Excel failus su pritaikytomis konvertavimo nustatymus.

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
Pagrindinis C# programavimo supratimas

PM> Install-Package Aspose.Cells

Žingsnis po žingsnio įgyvendinimas

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

Į savo projektą pridėkite Aspose.Cells paketą ir įtraukti reikiamus pavadinimų erdves:

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

2 žingsnis: sukurti katalogo struktūrą batch apdorojimui

Sukurkite direktorijos struktūrą, kad organizuotumėte savo „Excel“ įvesties ir išvestinius PDF failus:

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

3 žingsnis: failų atradimo logika

Sukurkite metodą, kad rastumėte visus „Excel“ failus, kuriuos reikia konvertuoti:

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

4 žingsnis: nustatykite PDF konverterio parinktis

Sukurkite metodą, kad nustatytumėte PDF konvertavimo galimybes nuosekliai:

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

5 žingsnis: Vieno failų konvertavimo logika

Sukurkite metodą, kaip konvertuoti vieną Excel failą į 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;
    }
}

6 žingsnis: Batch apdorojimo logika

Dabar sukurkite pagrindinį metodą, kuris apdoroja keletą failų:

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

7 žingsnis: įgyvendinti lygiagrečią apdorojimą geresnei našumui

Dideliems batams įgyvendinkite lygiagrečią apdorojimą, kad pagreitintumėte konvertavimą:

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

8 žingsnis: pilnas įgyvendinimo pavyzdys

Štai pilnas darbo pavyzdys, kuris parodo visą batch konvertavimo procesą:

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

Naudokite atvejus ir paraiškas

Įmonės ataskaitų sistemos

Finansinių ataskaitų sistemose mėnesio pabaigoje ar ketvirtfinalyje ciklai dažnai reikalauja daugelio Excel pagrįstų pranešimų konvertavimo į PDF formatą, skirtą paskirstymui suinteresuotosioms šalims. Šis pakuotės konversijos sprendimas leidžia pranešimo kūrėjams automatiškai atlikti procesus, užtikrinant, kad visi pranešimai būtų konvertuojami nuosekliais nustatimais ir formatuotais, tuo pat metu žymiai sumažinant rankinius pastangas.

Departamentų duomenų tvarkymas

Verslo analitikai, kurie renka „Excel“ pagrindu pagrįstus duomenis iš kelių skyrių, gali naudoti šį sprendimą standartizuoti ir archyvuoti pateiktus pranešimus. automatiškai konvertuojant gautus darbo knygas į PDF, jie sukuria nuolatinį duomenų pateikimo įrašą, o tuo pačiu metu dalijasi informacija su suinteresuotosiomis šalimis, neturinčiomis Excel.

Automatinis dokumentų valdymo darbo srautas

Integracija su dokumentų valdymo sistemomis tampa beprasmiška, kai “Excel” ataskaitos automatiškai konvertuojamos į PDF. Šis sprendimas gali būti planuojamas vykdyti kaip didesnio darbo srauto dalis, kuri atkuria naujus Excel failus, paverčia juos PDF ir tada nukreipia juos į atitinkamus dokumentus su tinkamais metadatais.

Bendrieji iššūkiai ir sprendimai

1 iššūkis: „Excel“ failų tvarkymas su slaptažodžio apsauga

Išsprendimas: Pakeiskite įkrovimo galimybes, kad įtrauktumėte slaptažodžio tvarkymą:

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

2 iššūkis: „Excel Formatting“ PDF išleidimo palaikymas

Išsprendimas: Įsitikinkite, kad PDF parinktis yra tinkamai sukonfigūruota siekiant išsaugoti formatavimą:

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

3 iššūkis: labai didelių Excel failų tvarkymas

Išsprendimas: Labai dideliems failams įgyvendinkite atminties optimizavimą:

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;

Veiksmingumo apžvalgos

Siekiant optimalaus veikimo su dideliais rinkiniais, naudokite lygiagrečią apdorojimo metodą su pagrįstu MaxDegreeOfParallelism Atsižvelgiant į jūsų serverio gebėjimus
Apsvarstykite failų apdorojimą mažesniais gabalais, kai susiduriate su labai didelėmis „Excel“ darbo knygomis, kad išvengtumėte atminties slėgio
Įdiegti stebėsenos mechanizmą konvertavimo progresui ir išteklių naudojimui stebėti
Gamybos iškrovimo atveju apsvarstykite konvertavimo procesą dedikuotu serveriu arba off-peak valandomis.

Geriausios praktikos

Pre-validate Excel failus prieš pakuotės apdorojimą, kad nustatytumėte galimas problemas
Įdiegti tvirtą klaidų tvarkymą užtikrinti, kad procesas nesustoja, jei vienas failas neveikia
Sukurti išsamius logus konvertavimo proceso problemų sprendimui ir auditui
Organizuokite išleidimo PDF struktūrizuotame aplankų hierarchijoje, kad būtų lengviau valdyti
Įdiegti stebėjimo sistemą , kuri įspėja administratorius apie konvertavimo klaidas
Test su įvairių „Excel“ failų tipų (XLSX, XLS ir XLSM), kad būtų užtikrintas suderinamumas

Išplėstiniai scenarijai

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

1 scenarijus: Pritaikytas PDF pavadinimas, pagrįstas „Excel Cell“ turiniu

Galite išgauti konkrečias ląstelių vertybes, kurias galite naudoti PDF failo pavadinime:

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

2 scenarijus: selektyvus lapų konvertavimas

Konvertuoti tik konkrečius lapus iš kiekvieno “Excel” failo:

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

Įgyvendinant Aspose.Cells LowCode PDF Converter batch apdorojimui, verslo analitikai ir ataskaitų kūrėjai gali dramatiškai sumažinti laiką, praleistą rankiniu Excel į PDF konvertavimus. Šis metodas žymiai pagerina našumą ir užtikrina nuoseklumą visose sukurtose PDF, išlaikydamas originalių Excel failų kokybę ir formatuotumą. Sprendimas skiriamas nuo mažų departamentų naudojimo iki įmonės masto ataskaitos sistemų, su pritaikymo galimybėmis, kad atitiktų konkrečius verslo poreikius.

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