Konwerter plików PDF
Jak przekonwertować pliki Excel do PDF w .NET

Jak przekonwertować pliki Excel do PDF w .NET

Ten artykuł pokazuje, jak zamienić wiele plików programu Excel do PDF za pomocą programu Aspose.Cells LowCode PDF Converter w aplikacjach .NET. Konwerter PDF zapewnia upraszczony podejście do konwersji dokumentów bez konieczności szerokiej kodowania lub głębokiej wiedzy na temat wewnętrznych struktur Excel - idealny dla analityków biznesowych i deweloperów raportów, którzy potrzebują automatyzacji przepływów roboczych raportu.

Problem świata rzeczywistego

W środowiskach biznesowych zespoły sprawozdawczości często muszą konwertować dziesiątki lub nawet setki książek roboczych programu Excel do formatu PDF regularnie. robienie tego ręcznie jest czasochłonne, błędne i odwraca cenne zasoby od ważniejszych zadań analitycznych. Dodatkowo zapewnienie spójnego formatowania i rozmieszczenia wszystkich raportów jest trudne podczas konwersji plików indywidualnie .

Przegląd rozwiązania

Korzystając z Aspose.Cells LowCode PDF Converter, możemy skutecznie rozwiązać ten wyzwanie z minimalnym kodem. To rozwiązanie jest idealne dla analityków biznesowych i deweloperów raportów, którzy muszą upraszczać swoje procesy sprawozdawczości, zapewnić spójność dokumentów i uwolnić czas na bardziej wartościową pracę. Nasz podejście będzie koncentrować się na tworzeniu solidnego systemu przetwarzania pakietu, który może obsługiwać duże objętości plików programu Excel za pomocą ustawień konwersji.

Warunki

Przed wdrożeniem rozwiązania upewnij się, że masz:

  • Visual Studio 2019 lub później
  • .NET 6.0 lub nowszy (kompatybilny z .Net Framework 4.6.2+)
  • Aspose.Cells dla pakietu .NET zainstalowanego za pośrednictwem NuGet
  • Podstawowe zrozumienie programowania C#
PM> Install-Package Aspose.Cells

Wdrażanie krok po kroku

Krok 1: Instalacja i konfiguracja Aspose.Cells

Dodaj pakiet Aspose.Cells do Twojego projektu i obejmuj niezbędne przestrzenia nazwowe:

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

Krok 2: Tworzenie struktury katalogowej do przetwarzania batchów

Konfiguruj strukturę katalogu, aby zorganizować swoje pliki Excel wejściowe i plików PDF wyjściowych:

// 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: Wdrożenie logiki odkrywania plików

Stwórz metodę, aby odkryć wszystkie pliki programu Excel, które muszą być konwertowane:

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: Konfiguruj opcje konwertera PDF

Tworzenie metody ustawienia opcji konwersji PDF dla konsekwentnego wyjścia:

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: Wdrożenie pojedynczej logiki konwersji plików

Tworzenie metody konwersji jednego pliku programu 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: Wdrożenie logiki przetwarzania batchów

Stwórz teraz główną metodę, która będzie przetwarzać wiele plików:

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: Wdrożenie równoległego przetwarzania dla lepszej wydajności

W przypadku dużych akcesoriów, wdrożenie równoległego przetwarzania w celu przyspieszenia konwersji:

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: Pełny przykład realizacji

Oto kompletny przykład pracy, który pokazuje cały proces konwersji pakietu:

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

Korzystanie z przypadków i aplikacji

Systemy sprawozdawcze przedsiębiorstw

W systemach sprawozdawczości finansowej cykly końcowe lub kwartałowe często wymagają konwertowania licznych raportów opartych na Excel w formacie PDF do dystrybucji dla zainteresowanych stron. To rozwiązanie konwersji pakietu umożliwia programistom raportu automatyzację procesu, zapewniając, że wszystkie raporty są konvertowane z konsekwentnymi ustawieniami i formatowaniem, a jednocześnie dramatycznie zmniejszając wysiłek ręczny.

Dział przetwarzania danych

Analitycy biznesowi, którzy gromadzą dane oparte na programie Excel z wielu oddziałów, mogą korzystać z tego rozwiązania w celu standardyzacji i archiwizacji prezentacji. automatycznie konwertując otrzymane księgi robocze do PDF, tworzą stały rekord składek danych, jednocześnie sprawiając, że informacje są udostępniane osobom zainteresowanym, które nie posiadają programu Excel.

Automatyczne przepływy robocze zarządzania dokumentami

Integracja z systemami zarządzania dokumentami staje się bezpieczna, gdy sprawozdania programu Excel są automatycznie konwertowane do PDF. To rozwiązanie może być zaplanowane do uruchomienia w ramach większego przepływu pracy, który pobiera nowe pliki programu Word, przekształca je w PDF, a następnie kieruje je do odpowiednich magazynów dokumentów z odpowiednimi metadany.

Wspólne wyzwania i rozwiązania

Wyzwanie 1: Zarządzanie plikami programu Excel z ochroną hasła

Rozwiązanie: Zmień opcje ładowania, aby uwzględnić zarządzanie hasłem:

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

Wyzwanie 2: Utrzymanie formatowania programu Excel w wydaniu PDF

Rozwiązanie: Upewnij się, że opcje PDF są prawidłowo skonfigurowane, aby zachować formatowanie:

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

Wyzwanie 3: Zarządzanie bardzo dużymi plikami Excel

Rozwiązanie: W przypadku bardzo dużych plików realizuj optymalizację pamięci:

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;

uwzględnienie wydajności

  • Aby uzyskać optymalną wydajność przy dużych zestawach, użyj równoległego podejścia do przetwarzania z rozsądnym MaxDegreeOfParallelism w oparciu o możliwości serwera
  • Rozważ przetwarzanie plików w mniejszych zestawach podczas obsługi bardzo dużych książek roboczych programu Excel, aby uniknąć ciśnienia pamięci
  • Wdrożenie mechanizmu monitorowania w celu śledzenia postępu konwersji i wykorzystania zasobów
  • W przypadku deploymentów produkcyjnych należy rozważyć prowadzenie procesu konwersji na dedykowanym serwerze lub w godzinach off-peak.

Najlepsze praktyki

  • Przekwaliduj pliki programu Excel przed przetwarzaniem zestawu, aby zidentyfikować potencjalne problemy
  • Wdrożenie robustej obsługi błędu, aby upewnić się, że proces nie zatrzymuje się w przypadku awarii jednego pliku
  • Wytwórz szczegółowe dzienniki procesu konwersji do rozwiązywania problemów i audytu
  • Zorganizuj wydanie plików PDF w strukturowanej hierarchii folderów, aby ułatwić zarządzanie
  • Ustaw system monitorowania, który ostrzega administratorów o awarii konwersji
  • Test z różnymi typami plików programu Excel (XLSX, XLS i XLSM) w celu zapewnienia kompatybilności

Zaawansowane scenariusze

Dla bardziej złożonych wymagań, rozważ te zaawansowane wdrażania:

Scenariusz 1: Dostosowane nazwy PDF oparte na treści Excel Cell

Możesz wyciągnąć określone wartości komórkowe do użycia w nazwie pliku 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";
    }
}

Scenariusz 2: Selektywna konwersja arkusza

Konwertuj tylko konkretne arkusze z każdego pliku programu 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;
}

konkluzja

Wdrażając Aspose.Cells LowCode PDF Converter do przetwarzania zestawów, analitycy biznesowi i deweloperzy raportów mogą dramatycznie zmniejszyć czas spędzony na manualnych konwersjach programu Excel do PDF. Ten podejście znacznie poprawia produktywność i zapewnia spójność we wszystkich generowanych plikach PDF przy jednoczesnym utrzymaniu jakości i formatowania oryginalnych plików Excel.

Aby uzyskać więcej informacji i dodatkowych przykładów, odwołuj się do Aspose.Cells.LowCode API Referencje .

 Polski