Kako pretvoriti Excel datoteke u PDF u .NET

Ovaj članak pokazuje kako kombinirati pretvaranje više Excel datoteka u PDF pomoću Aspose.Cells LowCode PDF Converter u .NET aplikacijama.Predvodnik PDF pruža ukusan pristup konverziji dokumenata bez potrebe za opsežnim kodiranjem ili dubokim znanjima o Excelovim unutarnjim strukturama - savršen za poslovne analitičare i razvijatelje izvješća koji trebaju automatizirati svoje izvješćivanje radne tokove.

Real-svjetski problem

U poslovnim okruženjima, timovi za izvješćivanje često trebaju pretvoriti desetke ili čak stotine Excel radnih knjiga u PDF format na redovnoj osnovi. To ručno je vremenski potrošeno, pogrešno i odvraća vrijedne resurse od važnijih analitičkih zadataka. Osim toga, osiguravanje dosljednog formata i rasporeda preko svih izvješća je izazovno prilikom pretvaranja datoteka pojedinačno.

Pregled rješenja

Koristeći Aspose.Cells LowCode PDF Converter, možemo riješiti ovaj izazov učinkovito s minimalnim kodom. Ovo rješenje je idealno za poslovne analitičare i razvijatelje izvješća koji trebaju usklađivati svoje procese izvješćivanja, osigurati dosljednost dokumenata i osloboditi vrijeme za više vrijednih radova. Naš pristup će se usredotočiti na stvaranje snažnog sustava obrade paketa koji može upravljati velikim količinama Excel datoteka s prilagođenim postavkama konverzije.

Preduzeća

Prije provedbe rješenja, pobrinite se da imate:

Visual Studio 2019 ili kasnije
.NET 6.0 ili noviji (kompatibilan s .Net Frameworkom 4.6.2+)
Aspose.Cells za .NET paket instaliran preko NuGet
Osnovno razumijevanje C# programiranja

PM> Install-Package Aspose.Cells

Korak po korak provedba

Korak 1: Instaliranje i konfiguracija Aspose.Cells

Dodajte paket Aspose.Cells vašem projektu i uključite potrebne nazivne prostore:

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

Korak 2: Kreirajte strukturu direktora za obradu batha

Postavite strukturu direktora kako biste organizirali vaše Excel ulazne i izlazne PDF datoteke:

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

Korak 3: Uvođenje logike otkrivanja datoteke

Stvorite metodu za otkrivanje svih Excel datoteka koje treba pretvoriti:

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

Korak 4: Konfigurirajte opcije PDF konvertera

Stvorite metodu za postavljanje opcija konverzije PDF-a za dosljedni izlaz:

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

Korak 5: Uvođenje jedinstvene logike konverzije datoteke

Stvorite način za pretvaranje pojedinačnog Excel datoteke u 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;
    }
}

Korak 6: Uvođenje logike obrade batch

Sada stvorite glavnu metodu koja će obrađivati više datoteka:

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

Korak 7: Uvođenje paralelnog obrade za bolju učinkovitost

Za velike partije, provedite paralelnu obradu kako biste ubrzali konverziju:

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

Korak 8: Popuniti primjer provedbe

Ovdje je potpuni radni primjer koji pokazuje cijeli proces konverzije paketa:

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

Korištenje slučajeva i aplikacija

Poduzetnički sustav izvješćivanja

U financijskim sustavima izvješćivanja, mjesečni ili kvartalni ciklusi često zahtijevaju pretvaranje brojnih izvješća na temelju Excel-a u PDF format za distribuciju zainteresiranim stranama. Ovo rješenje za konverziju paketa omogućuje razvijalcima izvještaja da automatiziraju proces, osiguravajući da se svi izvještaji pretvaraju s dosljednim postavkama i formatacijom, dok dramatično smanjuju ručni napor.

Odjel za obradu podataka

Poduzetnički analitičari koji prikupljaju podatke na temelju Excel-a iz više odjela mogu koristiti ovo rješenje za standardizaciju i arhiviranje podnošenja. automatski pretvarajući primljene radne knjige u PDF, oni stvaraju trajni zapis podnosa podataka dok čine informacije podijeljivim sa zainteresiranim stranama koje nemaju Excel.

Automatizirani protok rada za upravljanje dokumentima

Integracija sa sustavima upravljanja dokumentima postaje nemoćna kada se Excelovi izvještaji automatski pretvaraju u PDF. Ovo rješenje može biti planirano za rad kao dio veće tokove rada koji prikuplja nove Excelove datoteke, konvertira ih na PDF, a zatim ih usmjerava na odgovarajuće arhive dokumenata s ispravnim metapodatima.

Zajednički izazovi i rješenja

Izazov 1: rukovanje Excel datoteke sa zaštitom lozinke

Rješenje: Promijenite opcije opterećenja kako biste uključili upravljanje lozinkom:

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

Izazov 2: Održavanje Excel formatacije u PDF izlasku

Rješenje: Uvjerite se da su PDF opcije pravilno konfigurirane kako biste sačuvali formiranje:

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

Izazov 3: Rješavanje vrlo velikih Excel datoteka

Rješenje: Za izuzetno velike datoteke, provedite optimizaciju pamćenja:

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;

Razmatranje učinkovitosti

Za optimalnu učinkovitost s velikim udjelima, koristite paralelni pristup obrade s razumnim MaxDegreeOfParallelism Na temelju kapaciteta vašeg servera
Razmislite o obradi datoteka u manjim dijelovima prilikom rješavanja vrlo velikih Excel radnih knjiga kako biste izbjegli pritisak pamćenja
Uvođenje mehanizma praćenja za praćenje napretka konverzije i upotrebe resursa
Za distribucije proizvodnje, razmislite o provođenju procesa konverzije na posvećenom poslužitelju ili tijekom off-peak sati.

Najbolje prakse

Pre-validirati Excel datoteke prije obrade paketa kako bi se identificirale potencijalne probleme
Uvođenje robusta rješavanja pogrešaka kako bi se osiguralo da se proces ne zaustavi ako jedan datoteka ne uspje
Stvaranje detaljnih logova procesa konverzije za rješavanje problema i reviziju
Organizirajte izlazne PDF-ove u strukturiranoj hierarhiji dosjea za lakše upravljanje
Ugradite sustav za praćenje koji upozorava administratore na neuspjehe konverzije
Test s različitim Excelovim tipovima datoteke (XLSX, XLS i XLSM) kako bi se osigurala kompatibilnost

Napredni scenariji

Za složeniji zahtjevi, uzmite u obzir ove napredne implementacije:

Scenarij 1: Prilagođeno ime PDF-a na temelju sadržaja Excel Cell

Možete izvaditi određene vrijednosti stanica za korištenje u PDF datotečnom imenu:

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

Scenarij 2: Selektivna konverzija listova

Konvertirati samo određene listove iz svakog Excel datoteke:

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

zaključak

Uvođenjem Aspose.Cells LowCode PDF Converter za obradu paketa, poslovni analitičari i razvijatelji izvješća mogu dramatično smanjiti vrijeme provedeno na manualnom Excelu na PDF konverzije. Ovaj pristup značajno poboljšava produktivnost i osigurava dosljednost u svim generiranim PDF-ovima dok održava kvalitetu i formataciju originalnih Excel datoteka. Rješenje je skalabilno od malog odjeljnog korištenja do sustava izvješćivanja širom poduzeća, s opcijama za prilagodbu kako bi se zadovoljile specifične poslovne zahtjeve.

Za više informacija i dodatnih primjera, pogledajte Aspose.Cells.LowCode API referenca .