Μετατροπέας PDF
Πώς να μετατρέψετε τα αρχεία του Excel σε PDF στο .NET

Πώς να μετατρέψετε τα αρχεία του Excel σε PDF στο .NET

Αυτό το άρθρο δείχνει πώς να μετατρέψετε πολλαπλά αρχεία του Excel σε PDF χρησιμοποιώντας το Aspose.Cells LowCode PDF Converter σε εφαρμογές .NET. Ο μετατροπέας PDF παρέχει μια ευέλικτη προσέγγιση για τη μετατροπή εγγράφων χωρίς να απαιτείται εκτεταμένη κωδικοποίηση ή βαθιά γνώση των εσωτερικών δομών της Excel - ιδανική για τους επιχειρηματικούς αναλυτές και τους προγραμματιστές αναφορών που χρειάζονται να αυτοματοποιήσουν τις ροές εργασίας αναφοράς τους.

Το πρόβλημα του πραγματικού κόσμου

Σε επιχειρηματικά περιβάλλοντα, οι ομάδες αναφοράς συχνά χρειάζονται να μετατρέπουν δεκάδες ή ακόμη και εκατοντάδες βιβλία εργασίας του Excel σε μορφή PDF σε τακτική βάση. Το να το κάνετε αυτό με το χέρι είναι χρόνος-χρήσιμο, ελαττωματικό, και αποσπά πολύτιμους πόρους από πιο σημαντικά αναλυτικά καθήκοντα. Επιπλέον, η διασφάλιση της συνεκτικής μορφοποίησης και διάταξης σε όλες τις αναφορές είναι δύσκολη κατά την μετατροπή αρχείων ξεχωριστά.

Συνοπτική λύση

Χρησιμοποιώντας το Aspose.Cells LowCode PDF Converter, μπορούμε να επιλύσουμε αυτή την πρόκληση αποτελεσματικά με ελάχιστο κώδικα. Αυτή η λύση είναι ιδανική για τους επιχειρηματικούς αναλυτές και τους προγραμματιστές αναφορών που χρειάζονται να απλοποιήσουν τις διαδικασίες αναφοράς τους, να εξασφαλίσουν τη συνοχή μεταξύ των εγγράφων και να απελευθερώσουν χρόνο για πιο πολύτιμη εργασία. Η προσέγγιση μας θα επικεντρωθεί στη δημιουργία ενός ισχυρού συστήματος επεξεργασίας συσκευών που μπορεί να χειριστεί μεγάλους όγκους αρχείων του Excel με προσαρμοσμένες ρυθμίσεις μετατροπής.

Προϋποθέσεις

Πριν από την εφαρμογή της λύσης, βεβαιωθείτε ότι έχετε:

  • Visual Studio 2019 ή αργότερα
  • .NET 6.0 ή μεταγενέστερο (συμβατό με το .Net Framework 4.6.2+)
  • Aspose.Cells για το πακέτο .NET που είναι εγκατεστημένο μέσω NuGet
  • Βασική κατανόηση του C# προγραμματισμού
PM> Install-Package Aspose.Cells

Βήμα προς βήμα εφαρμογή

Βήμα 1: Εγκαταστήστε και ρυθμίστε Aspose.Cells

Προσθέστε το πακέτο Aspose.Cells στο έργο σας και συμπεριλάβετε τις απαραίτητες ονομαστικές περιοχές:

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

Βήμα 2: Δημιουργήστε μια δομή γραμματοσειράς για την επεξεργασία συσκευών

Δημιουργήστε μια δομή καταλόγου για να οργανώσετε τα αρχεία Excel εισόδου και τα PDF εξόδου σας:

// Create directories if they don't exist
string inputDirectory = @"C:\Reports\ExcelFiles";
string outputDirectory = @"C:\Reports\PDFOutput";
string logDirectory = @"C:\Reports\Logs";

Directory.CreateDirectory(inputDirectory);
Directory.CreateDirectory(outputDirectory);
Directory.CreateDirectory(logDirectory);

Βήμα 3: Εφαρμογή File Discovery Logic

Δημιουργήστε μια μέθοδο για να ανακαλύψετε όλα τα αρχεία του Excel που χρειάζονται μετατροπή:

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: Ρυθμίστε τις επιλογές μετατροπής PDF

Δημιουργήστε μια μέθοδο για να ρυθμίσετε τις επιλογές μετατροπής PDF για συνεπή έκδοση:

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: Εφαρμογή της μόνης λογικής μετατροπής αρχείων

Δημιουργήστε μια μέθοδο για να μετατρέψετε ένα μόνο αρχείο του Excel σε 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: Εφαρμογή της λογικής επεξεργασίας συσκευών

Τώρα δημιουργήστε την κύρια μέθοδο που θα επεξεργαστεί πολλαπλά αρχεία:

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: Εφαρμογή παράλληλης επεξεργασίας για καλύτερη απόδοση

Για μεγάλες συσκευές, εφαρμόστε παράλληλη επεξεργασία για να επιταχυνθεί η μετατροπή:

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: Συμπληρωματικό παράδειγμα εφαρμογής

Εδώ είναι ένα πλήρες παράδειγμα εργασίας που αποδεικνύει ολόκληρη τη διαδικασία μετατροπής συσκευών:

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

Χρήση περιπτώσεων και εφαρμογών

Συστήματα Εταιρικής Αναφοράς

Σε συστήματα χρηματοοικονομικής αναφοράς, οι κύκλοι του τέλους του μήνα ή του τριμήνου συχνά απαιτούν τη μετατροπή πολλών εκθέσεων με βάση το Excel σε μορφή PDF για διανομή στους ενδιαφερόμενους. Αυτή η λύση μετατροπής συσκευών επιτρέπει στους προγραμματιστές αναφορών να αυτοματοποιήσουν τη διαδικασία, εξασφαλίζοντας ότι όλες οι αναφορές μετατρέπονται με συνεπείς ρυθμίσεις και μορφοποίηση, ενώ μειώνει δραματικά τις χειροκίνητες προσπάθειες.

Τμήμα επεξεργασίας δεδομένων

Οι επιχειρηματικοί αναλυτές που συλλέγουν δεδομένα με βάση το Excel από πολλαπλά τμήματα μπορούν να χρησιμοποιήσουν αυτή τη λύση για την τυποποίηση και την αρχειοθέτηση των υποβολών. Με την αυτόματη μετατροπή των παραληφθέντων εργαστηρίων σε PDF, δημιουργούν ένα μόνιμο αρχείο των δεδομένων ενώ καθιστούν τις πληροφορίες κοινές με τους ενδιαφερόμενους φορείς που δεν έχουν Excel.

Αυτόματη διαχείριση εγγράφων ροές εργασίας

Η ολοκλήρωση με τα συστήματα διαχείρισης εγγράφων γίνεται αδιάλειπτη όταν οι αναφορές του Excel μετατρέπονται αυτόματα σε PDF. Αυτή η λύση μπορεί να προγραμματιστεί για να εκτελεστεί ως μέρος μιας μεγαλύτερης ροής εργασίας που αναβαθμίζει τα νέα αρχεία Excel, τα μετατρέπει σε pdf και στη συνέχεια τα κατευθύνει στα κατάλληλα αποθηκευτικά έγγραφα με σωστά μεταδεδομένα. Η συνεπής μορφοποίηση και η ποιότητα των αρχείων PDF εξασφαλίζει τη μακροπρόθεσμη προσβασιμότητα των επιχειρηματικών δεδομένων.

Κοινές προκλήσεις και λύσεις

Πρόκληση 1: Διαχείριση αρχείων του Excel με προστασία κωδικού πρόσβασης

Λύση: Τροποποιήστε τις επιλογές φόρτωσης για να συμπεριλάβετε τη διαχείριση κωδικού πρόσβασης:

// 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: Διατήρηση της μορφοποίησης του Excel σε PDF output

Λύση: Βεβαιωθείτε ότι οι επιλογές PDF είναι σωστά προσαρμοσμένες για τη διατήρηση της μορφοποίησης:

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: Διαχείριση πολύ μεγάλων αρχείων Excel

Λύση: Για εξαιρετικά μεγάλα αρχεία, εφαρμόστε τη βελτιστοποίηση μνήμης:

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;

Αξιολόγηση των επιδόσεων

  • Για βέλτιστη απόδοση με μεγάλες συσκευές, χρησιμοποιήστε την παράλληλη προσέγγιση επεξεργασίας με εύλογη MaxDegreeOfParallelism Με βάση τις δυνατότητες του διακομιστή σας
  • Σκεφτείτε την επεξεργασία αρχείων σε μικρότερα κομμάτια όταν ασχολούνται με πολύ μεγάλα βιβλία εργασίας του Excel για να αποφευχθεί η πίεση μνήμης
  • Εφαρμογή μηχανισμού παρακολούθησης για τον εντοπισμό της προόδου μετατροπής και της χρήσης πόρων
  • Για τις εγκαταστάσεις παραγωγής, εξετάστε την εκτέλεση της διαδικασίας μετατροπής σε έναν αφιερωμένο διακομιστή ή κατά τη διάρκεια των ωρών off-peak.

שיטות עבודה מומלצות

  • Προεπιβεβαιώστε τα αρχεία του Excel πριν από την επεξεργασία συσκευών για την αναγνώριση πιθανών προβλημάτων
  • Εφαρμόστε ισχυρή επεξεργασία σφαλμάτων για να βεβαιωθείτε ότι η διαδικασία δεν σταματά εάν ένα αρχείο αποτύχει
  • ** Δημιουργία λεπτομερών ημερολογίων** της διαδικασίας μετατροπής για την επίλυση προβλημάτων και τον έλεγχο
  • Οργανώστε τα PDF εξόδου σε μια δομημένη ιεραρχία φακέλων για ευκολότερη διαχείριση
  • Συστήστε ένα σύστημα παρακολούθησης που προειδοποιεί τους διαχειριστές για αποτυχίες μετατροπής
  • Δεξέταση με διάφορους τύπους αρχείων του Excel (XLSX, XLS και XLSM) για να εξασφαλιστεί η συμβατότητα

Προχωρημένα σενάρια

Για πιο σύνθετες απαιτήσεις, εξετάστε αυτές τις προηγμένες εφαρμογές:

Σενάριο 1: Προσαρμοσμένη ονομασία PDF με βάση το περιεχόμενο του Excel Cell

Μπορείτε να εξαγάγετε συγκεκριμένες τιμές κυττάρων για χρήση στο όνομα αρχείου 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";
    }
}

Σενάριο 2: Επιλεκτική μετατροπή φύλλου

Μετατρέψτε μόνο συγκεκριμένα φύλλα από κάθε αρχείο του 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;
}

Συμπεράσματα

Με την εφαρμογή του Aspose.Cells LowCode PDF Converter για επεξεργασία συσκευών, οι επιχειρηματικοί αναλυτές και οι προγραμματιστές αναφορών μπορούν να μειώσουν δραματικά το χρόνο που ξοδεύεται σε χειροκίνητα μετατροπές Excel σε PDF. Αυτή η προσέγγιση βελτιώνει σημαντικά την παραγωγικότητα και εξασφαλίζει τη συνοχή σε όλα τα γεννημένα PDF ενώ διατηρεί την ποιότητα και τη μορφοποίηση των αρχικών αρχείων Excel. Η λύση είναι κλιμάκωση από τη μικρή χρήση του τμήματος σε συστήματα αναφοράς σε ολόκληρη την επιχείρηση, με τις επιλογές προσαρμογής για να ικανοποιήσει συγκεκριμένες απαιτήσεις των επιχειρήσεων.

Για περισσότερες πληροφορίες και συμπληρωματικά παραδείγματα, ανατρέξτε στο Aspose.Cells.LowCode API αναφοράς .

 Ελληνικά