PDF pārveidotājs
Kā pārvērst Excel failus PDF .NET

Kā pārvērst Excel failus PDF .NET

Šis raksts parāda, kā pārveidot vairākus Excel failus uz PDF, izmantojot Aspose.Cells LowCode PDF Converter .NET lietojumprogrammās.PDF Converters nodrošina vienkāršu pieeju dokumentu konversijai, neprasa plašu kodēšanu vai dziļas zināšanas par Excel iekšējām struktūrām - ideāls biznesa analītiķiem un ziņojumu izstrādātājiem, kuriem ir nepieciešams automatizēt savu ziņošanas darba plūsmu.

Reālā pasaules problēma

Uzņēmējdarbības vidēs ziņošanas komandām bieži vien ir nepieciešams regulāri konvertēt desmitiem vai pat simtiem Excel darba grāmatu PDF formātā. To rokasgrāmata ir laika, kļūdas un novērš vērtīgus resursus no svarīgākajām analītiskām darbībām. Turklāt, nodrošinot konsekventu formāšanu un izkārtojumu visās ziņojumos ir grūti, kad konversē failus individuāli.

Risinājumu pārskats

Izmantojot Aspose.Cells LowCode PDF Converter, mēs varam efektīvi atrisināt šo izaicinājumu ar minimālo kodu. Šis risinājums ir ideāls biznesa analītiķiem un ziņojumu izstrādātājiem, kuriem ir nepieciešams vienkāršot ziņošanas procesus, nodrošināt konsekvenci starp dokumentiem un atbrīvot laiku vērtīgākai darbībai. Mūsu pieeja būs vērsta uz spēcīgu batch apstrādes sistēmu, kas var apstrādāt lielas Excel failu daudzumus ar personalizētiem konversijas iestatījumiem.

Prerequisites

Pirms risinājuma ieviešanas pārliecinieties, ka jums ir:

  • Visual Studio 2019 vai vēlāk
  • .NET 6.0 vai jaunāks (kompatibilitāte ar .Net Framework 4.6.2+)
  • Aspose.Cells par .NET paketi, kas instalēta caur NuGet
  • C# programmēšanas pamata izpratne
PM> Install-Package Aspose.Cells

Step-by-step īstenošana

1. solis: Uzstādīt un konfigurēt Aspose.Cells

Pievienojiet Aspose.Cells paketi savam projektam un iekļauj nepieciešamos nosaukuma telpas:

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

2. solis: izveido adreses struktūru batch apstrādei

Iestatīt direktorijas struktūru, lai organizētu jūsu ievades Excel failus un iznākumu PDF failu:

// 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. solis: Failu atklāšanas loģika

Izveidojiet metodi, lai atklātu visus Excel failus, kas jākonvertē:

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. solis: Konfigurējiet PDF konvertora opcijas

Izveidojiet metodi, lai iestatītu PDF konversijas iespējas konsekventiem rezultātiem:

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. solis: Vienkārša failu konversijas loģika

Izveidojiet metodi, lai konvertētu vienu Excel failu 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. solis: Batch apstrādes loģika īstenošana

Tagad izveidojiet galveno metodi, kas apstrādā vairākus failus:

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. solis: Paralēli apstrādi, lai uzlabotu veiktspēju

Lieliem komplektiem, īsteno paralēli apstrādi, lai paātrinātu konversiju:

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. solis: Pilnīgs īstenošanas piemērs

Šeit ir pilns darba piemērs, kas pierāda visu batch konversijas procesu:

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

Izmantojiet gadījumus un pieteikumus

Uzņēmuma ziņošanas sistēmas

Finanšu ziņošanas sistēmās mēneša beigās vai ceturtdaļfinālā cikli bieži vien prasa vairāku Excel balstītu ziņojumu konvertēšanu PDF formātā, lai to izplatītu ieinteresētajām personām. Šis pakāpes konversijas risinājums ļauj ziņojuma izstrādātājiem automatizēt procesu, nodrošinot, ka visi ziņojumi tiek konverti ar konsekventiem iestatījumiem un formatēšanu, vienlaikus ievērojami samazinot manuālo pūliņu.

Departamenta datu apstrāde

Uzņēmējdarbības analītiķi, kas apkopo datus, pamatojoties uz Excel no vairākiem departamentiem, var izmantot šo risinājumu, lai standartizētu un arhivētu iesniegumus. automātiski konvertējot saņemtās darba grāmatas uz PDF, viņi izveido pastāvīgu datu ziņojumu, vienlaikus padarot informāciju kopīgai ar ieinteresētajām personām, kurām nav Excel.

Automatizēta dokumentu vadības darba plūsma

Integrācija ar dokumentu pārvaldības sistēmām kļūst bezjēdzīga, kad Excel ziņojumi tiek automātiski konvertēti uz PDF. Šo risinājumu var plānot darbam kā daļu no lielākas darba plūsmas, kas atjauno jaunus Excel failus, pārvērš tos PDF, un pēc tam tos virzās uz atbilstošiem dokumentu reģistriem ar pareiziem metadatiem.

Kopīgi izaicinājumi un risinājumi

1 izaicinājums: Excel failu apstrāde ar paroles aizsardzību

Rīze: Izmaiņas uzlādes opcijās, lai iekļautu paroles apstrādi:

// 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. izaicinājums: Excel formatēšanas uzturēšana PDF iznākumā

Lēmums: Pārliecinieties, ka PDF opcijas ir pareizi konfigurētas, lai saglabātu formātu:

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. izaicinājums: pārvaldīt ļoti lielas Excel failus

Rīkojums: Īpaši lieliem failiem, ievadiet atmiņas optimizāciju:

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;

Darbības apsvērumi

  • Lai nodrošinātu optimālu veiktspēju ar lieliem gabaliem, izmantojiet paralēli apstrādes pieeju ar saprātīgu MaxDegreeOfParallelism Pamatojoties uz jūsu servera iespējām
  • Padomājiet par failu apstrādi mazākajos gabalos, kad darāt ar ļoti lieliem Excel darba grāmatām, lai izvairītos no atmiņas spiediena
  • Ieviest monitoringa mehānismu, lai uzraudzītu konversijas progresu un resursu izmantošanu
  • Ražošanas izplūdes gadījumā apsveriet konversijas procesu veikšanu uz īpašu serveri vai off-peak stundās.

Labākās prakses

  • Pre-validēt Excel failus pirms kompleksa apstrādes, lai identificētu iespējamās problēmas
  • Izveidot spēcīgu kļūdu apstrādi , lai nodrošinātu, ka process netiek pārtraukts, ja viens fails neizdodas
  • Radīt detalizētus logus par konversijas procesu problēmu risināšanai un revīzijai
  • Organizējiet iznākumu PDF strukturētajā mapes hierarhijā, lai vieglāk pārvaldītu
  • Iestatīt uzraudzības sistēmu , kas brīdina administratorus par konversijas neveiksmēm
  • Test ar dažādiem Excel failu veidiem (XLSX, XLS un XLSM), lai nodrošinātu saderību

Augstākie scenāriji

Lai iegūtu sarežģītākus prasības, apsveriet šos progresīvus īstenojumus:

1. scenārijs: pielāgoti PDF nosaukumi, pamatojoties uz Excel Cell saturu

Jūs varat izrakstīt konkrētus šūnu vērtības, kas jāizmanto PDF faila vārdā:

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

Scenārija 2: Selektīva lapas konversija

Konvertēt tikai konkrētus lapas no katra Excel faila:

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

Izmantojot Aspose.Cells LowCode PDF Converter batch apstrādei, biznesa analītiķi un ziņojumu izstrādātāji var dramatiski samazināt laiku, kas pavadīts manuālajā Excel uz PDF konversijām. Šis pieeja ievērojami uzlabo produktivitāti un nodrošina konsekvenci visās radītajās PDF, vienlaikus saglabājot oriģinālo Excel failu kvalitātes un formatēšanas.

Lai iegūtu vairāk informācijas un papildu piemēru, atsauciet uz Aspose.Cells.LowCode API atsauce .

 Latviski