[AUTO] Conversion Examples Update

conversion/after-converting-csv-to-xlsx-add-a-data-validation-rule-to-restrict-values-in-a-column.cs

@@ -0,0 +1,61 @@
+using System;
+using Aspose.Cells;
+using Aspose.Cells.Utility;
+
+namespace AsposeCellsDataValidationDemo
+{
+    class Program
+    {
+        static void Main()
+        {
+            // Paths for source CSV and intermediate XLSX file
+            string csvPath = "input.csv";
+            string xlsxPath = "output.xlsx";
+
+            // -------------------------------------------------
+            // 1. Convert CSV to XLSX using the provided utility
+            // -------------------------------------------------
+            // The ConversionUtility.Convert method is the approved way to perform the conversion.
+            ConversionUtility.Convert(csvPath, xlsxPath);
+
+            // -------------------------------------------------
+            // 2. Load the generated workbook
+            // -------------------------------------------------
+            Workbook workbook = new Workbook(xlsxPath);
+
+            // -------------------------------------------------
+            // 3. Add a data‑validation rule to restrict values
+            //    in column B (index 1) to whole numbers between 1 and 100
+            // -------------------------------------------------
+            Worksheet sheet = workbook.Worksheets[0];
+            ValidationCollection validations = sheet.Validations;
+
+            // Create a new validation object
+            int validationIndex = validations.Add();
+            Validation validation = validations[validationIndex];
+
+            // Set validation type and criteria
+            validation.Type = ValidationType.WholeNumber;
+            validation.Operator = OperatorType.Between;
+            validation.Formula1 = "1";   // Minimum allowed value
+            validation.Formula2 = "100"; // Maximum allowed value
+
+            // Apply the validation to the whole column B (rows 0‑1048575)
+            CellArea area = new CellArea
+            {
+                StartRow = 0,
+                StartColumn = 1,   // Column B
+                EndRow = sheet.Cells.MaxDataRow, // Use existing max row or a large number
+                EndColumn = 1
+            };
+            validation.AddArea(area);
+
+            // -------------------------------------------------
+            // 4. Save the workbook with the validation rule applied
+            // -------------------------------------------------
+            workbook.Save(xlsxPath, SaveFormat.Xlsx);
+
+            Console.WriteLine("CSV converted to XLSX and data validation added successfully.");
+        }
+    }
+}

conversion/apply-a-filter-to-hide-rows-where-a-status-column-equals-inactive-after-importing-csv-data.cs

@@ -0,0 +1,39 @@
+using System;
+using Aspose.Cells;
+
+namespace AsposeCellsFilterExample
+{
+    class Program
+    {
+        static void Main()
+        {
+            // Path to the source CSV file
+            string csvPath = "input.csv";
+
+            // Load the CSV data into a workbook
+            Workbook workbook = new Workbook(csvPath);
+            Worksheet sheet = workbook.Worksheets[0];
+
+            // Determine the used range (including header row)
+            int lastRow = sheet.Cells.MaxDataRow;          // zero‑based index of the last row with data
+            int lastColumn = sheet.Cells.MaxDataColumn;    // zero‑based index of the last column with data
+
+            // Build the address string for the autofilter range (e.g., "A1:D10")
+            string startCell = "A1";
+            string endCell = CellsHelper.CellIndexToName(lastRow, lastColumn);
+            sheet.AutoFilter.Range = $"{startCell}:{endCell}";
+
+            // Assume the "Status" column is the third column (C) – zero‑based index = 2
+            int statusColumnIndex = 2;
+
+            // Apply a filter to hide rows where Status = "Inactive"
+            sheet.AutoFilter.Filter(statusColumnIndex, "Inactive");
+
+            // Refresh the filter so that rows not matching the criteria become hidden
+            sheet.AutoFilter.Refresh();
+
+            // Save the filtered workbook
+            workbook.Save("output.xlsx");
+        }
+    }
+}

conversion/apply-odspagebackground-solid-blue-color-and-save-ods-with-background.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Drawing;
+using Aspose.Cells;
+using Aspose.Cells.Ods;
+
+namespace OdsPageBackgroundExample
+{
+    class Program
+    {
+        static void Main()
+        {
+            // Create a new workbook
+            Workbook workbook = new Workbook();
+
+            // Access the first worksheet
+            Worksheet sheet = workbook.Worksheets[0];
+
+            // Get the ODS page background object
+            OdsPageBackground background = sheet.PageSetup.ODSPageBackground;
+
+            // Set background type to solid color
+            background.Type = OdsPageBackgroundType.Color;
+
+            // Apply solid blue color
+            background.Color = Color.Blue;
+
+            // Save the workbook as ODS with the background applied
+            workbook.Save("OdsPageBackgroundBlue.ods");
+        }
+    }
+}

conversion/assign-a-graphic-stream-to-odspagebackground-and-save-the-workbook-as-ods-with-colored-background.cs

@@ -0,0 +1,46 @@
+using System;
+using System.IO;
+using System.Drawing;
+using Aspose.Cells;
+using Aspose.Cells.Ods;
+
+namespace OdsBackgroundDemo
+{
+    class Program
+    {
+        static void Main()
+        {
+            // Create a new workbook and get the first worksheet
+            Workbook workbook = new Workbook();
+            Worksheet sheet = workbook.Worksheets[0];
+
+            // Access the ODS page background through PageSetup
+            OdsPageBackground background = sheet.PageSetup.ODSPageBackground;
+
+            // Set a solid background color
+            background.Type = OdsPageBackgroundType.Color;
+            background.Color = Color.LightGreen;
+
+            // Change the type to graphic to assign an image stream
+            background.Type = OdsPageBackgroundType.Graphic;
+
+            // Load image data into a byte array (replace with a valid image path)
+            string imagePath = "background.png";
+            if (File.Exists(imagePath))
+            {
+                background.GraphicData = File.ReadAllBytes(imagePath);
+                background.GraphicType = OdsPageBackgroundGraphicType.Tile;
+                background.GraphicPositionType = OdsPageBackgroundGraphicPositionType.CenterCenter;
+            }
+            else
+            {
+                Console.WriteLine($"Image file not found: {imagePath}");
+                return;
+            }
+
+            // Save the workbook as ODS
+            workbook.Save("WorkbookWithGraphicBackground.ods");
+            Console.WriteLine("Workbook saved successfully.");
+        }
+    }
+}

conversion/batch-convert-a-folder-of-xlsx-files-to-pdf-preserving-page-margins-and-orientation-settings.cs

@@ -0,0 +1,59 @@
+using System;
+using System.IO;
+using Aspose.Cells.Utility;
+
+namespace AsposeCellsBatchConversion
+{
+    public class XlsxToPdfBatchConverter
+    {
+        // Converts all .xlsx files in the specified folder to PDF.
+        // The ConversionUtility preserves page margins, orientation and other print settings.
+        public static void ConvertFolder(string sourceFolder, string destinationFolder)
+        {
+            // Ensure source folder exists
+            if (!Directory.Exists(sourceFolder))
+                throw new DirectoryNotFoundException($"Source folder not found: {sourceFolder}");
+
+            // Create destination folder if it does not exist
+            Directory.CreateDirectory(destinationFolder);
+
+            // Get all .xlsx files (including .xlsm, .xltx, etc. if needed)
+            string[] excelFiles = Directory.GetFiles(sourceFolder, "*.xlsx", SearchOption.TopDirectoryOnly);
+
+            foreach (string excelPath in excelFiles)
+            {
+                // Build PDF file name with same base name
+                string fileNameWithoutExt = Path.GetFileNameWithoutExtension(excelPath);
+                string pdfPath = Path.Combine(destinationFolder, fileNameWithoutExt + ".pdf");
+
+                // Perform conversion using Aspose.Cells ConversionUtility
+                // This method respects the workbook's page setup (margins, orientation, etc.)
+                ConversionUtility.Convert(excelPath, pdfPath);
+
+                Console.WriteLine($"Converted: {excelPath} -> {pdfPath}");
+            }
+        }
+
+        // Example entry point
+        public static void Main(string[] args)
+        {
+            // Example usage:
+            // args[0] = source folder, args[1] = destination folder
+            if (args.Length < 2)
+            {
+                Console.WriteLine("Usage: XlsxToPdfBatchConverter <sourceFolder> <destinationFolder>");
+                return;
+            }
+
+            try
+            {
+                ConvertFolder(args[0], args[1]);
+                Console.WriteLine("Batch conversion completed successfully.");
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Error during conversion: {ex.Message}");
+            }
+        }
+    }
+}

conversion/batch-convert-multiple-excel-files-to-csv-trimming-leading-blanks-and-preserving-column-headers-consistently.cs

@@ -0,0 +1,81 @@
+using System;
+using System.IO;
+using Aspose.Cells;
+
+namespace BatchExcelToCsv
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            // Input folder containing Excel files
+            string inputFolder = @"C:\InputExcelFiles";
+            // Output folder where CSV files will be saved
+            string outputFolder = @"C:\OutputCsvFiles";
+
+            // Verify input directory exists
+            if (!Directory.Exists(inputFolder))
+            {
+                Console.WriteLine($"Input folder not found: {inputFolder}");
+                return;
+            }
+
+            // Ensure output directory exists
+            Directory.CreateDirectory(outputFolder);
+
+            // Define the Excel file extensions to process
+            string[] excelExtensions = new[] { ".xlsx", ".xls", ".xlsm", ".xlsb", ".ods" };
+
+            try
+            {
+                // Enumerate all files with the defined extensions
+                foreach (string filePath in Directory.EnumerateFiles(inputFolder, "*.*", SearchOption.TopDirectoryOnly))
+                {
+                    if (Array.IndexOf(excelExtensions, Path.GetExtension(filePath).ToLower()) < 0)
+                        continue; // Skip non‑Excel files
+
+                    // Verify the file still exists before processing
+                    if (!File.Exists(filePath))
+                    {
+                        Console.WriteLine($"File not found (skipped): {filePath}");
+                        continue;
+                    }
+
+                    try
+                    {
+                        // Load the workbook (default LoadOptions are sufficient for Excel formats)
+                        Workbook workbook = new Workbook(filePath);
+
+                        // Prepare CSV save options
+                        TxtSaveOptions saveOptions = new TxtSaveOptions(SaveFormat.Csv)
+                        {
+                            // Trim leading blank rows/columns (default is true, set explicitly for clarity)
+                            TrimLeadingBlankRowAndColumn = true,
+                            // Export all worksheets into a single CSV (set to true if required)
+                            ExportAllSheets = true
+                        };
+
+                        // Build output CSV file name (same base name, .csv extension)
+                        string outputFileName = Path.GetFileNameWithoutExtension(filePath) + ".csv";
+                        string outputPath = Path.Combine(outputFolder, outputFileName);
+
+                        // Save the workbook as CSV using the configured options
+                        workbook.Save(outputPath, saveOptions);
+
+                        Console.WriteLine($"Converted: {Path.GetFileName(filePath)} -> {outputFileName}");
+                    }
+                    catch (Exception ex)
+                    {
+                        Console.WriteLine($"Error processing file '{filePath}': {ex.Message}");
+                    }
+                }
+
+                Console.WriteLine("Batch conversion completed.");
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Unexpected error: {ex.Message}");
+            }
+        }
+    }
+}

conversion/batch-convert-multiple-xlsx-files-to-pdf-and-store-results-in-an-output-folder.cs

@@ -0,0 +1,46 @@
+using System;
+using System.IO;
+using Aspose.Cells.Utility;
+
+namespace AsposeCellsBatchConversion
+{
+    public class BatchXlsxToPdfConverter
+    {
+        public static void Main()
+        {
+            // Folder containing the source XLSX files
+            string inputFolder = "input";
+
+            // Folder where the converted PDF files will be saved
+            string outputFolder = "output";
+
+            // Ensure the output directory exists
+            Directory.CreateDirectory(outputFolder);
+
+            // Get all .xlsx files in the input folder
+            string[] xlsxFiles = Directory.GetFiles(inputFolder, "*.xlsx", SearchOption.TopDirectoryOnly);
+
+            foreach (string sourcePath in xlsxFiles)
+            {
+                try
+                {
+                    // Determine the PDF file name based on the source file name
+                    string fileNameWithoutExt = Path.GetFileNameWithoutExtension(sourcePath);
+                    string destPath = Path.Combine(outputFolder, fileNameWithoutExt + ".pdf");
+
+                    // Convert the Excel file to PDF using Aspose.Cells ConversionUtility
+                    ConversionUtility.Convert(sourcePath, destPath);
+
+                    Console.WriteLine($"Converted: {sourcePath} -> {destPath}");
+                }
+                catch (Exception ex)
+                {
+                    // Log any conversion errors but continue processing other files
+                    Console.WriteLine($"Error converting '{sourcePath}': {ex.Message}");
+                }
+            }
+
+            Console.WriteLine("Batch conversion completed.");
+        }
+    }
+}