Merge pull request #101 from aspose-cells/v3/open-workbook

[AUTO] Open Workbook Examples Update

Author: yasiraspose

index.json

@@ -0,0 +1,37 @@
+using System;
+using System.IO;
+using Aspose.Cells;
+
+class Program
+{
+    static void Main()
+    {
+        const string inputPath = "input.xlsx";
+
+        // Ensure the input file exists before attempting to load it
+        if (!File.Exists(inputPath))
+        {
+            Console.WriteLine($"Error: File \"{inputPath}\" not found.");
+            return;
+        }
+
+        try
+        {
+            // Load the workbook from the specified file
+            Workbook workbook = new Workbook(inputPath);
+
+            // NOTE: In some Aspose.Cells versions the LoadWarnings collection is not available.
+            // If needed, warnings can be retrieved via other mechanisms provided by the library.
+
+            Console.WriteLine("Workbook loaded successfully.");
+
+            // (Optional) Save the workbook if further processing is needed
+            // workbook.Save("output.xlsx");
+        }
+        catch (Exception ex)
+        {
+            // Catch any runtime exceptions and display a friendly message
+            Console.WriteLine($"An error occurred: {ex.Message}");
+        }
+    }
+}

open-workbook/after-loading-iterate-through-workbookloadwarnings-collection-and-output-each-warning-message-to-console.cs

@@ -0,0 +1,115 @@
+---
+category: open-workbook
+framework: .NET
+parent: ../agents.md
+version: v2
+---
+
+# Persona
+
+You are a C# developer specializing in workbook loading and opening operations using Aspose.Cells for .NET.
+
+Generate simple, correct, production-quality examples that demonstrate ONE workbook-opening scenario at a time.
+
+---
+
+# Scope
+
+- Standalone .cs examples
+- One operation per example
+- Fully runnable with dotnet run
+- No external dependencies
+
+---
+
+# Required Namespaces
+
+using System;
+using Aspose.Cells;
+
+---
+
+# Key APIs
+
+- Workbook
+- LoadOptions
+- TxtLoadOptions
+- HtmlLoadOptions
+- PdfSaveOptions
+
+---
+
+# Common Pattern
+
+1. Create or prepare workbook source
+2. Configure load options if needed
+3. Open workbook
+4. Access workbook content
+5. Save workbook or verify results
+6. Print success message
+
+---
+
+# Open Workbook Rules
+
+- Demonstrate one loading feature per example
+- Use LoadOptions only when relevant
+- Show how workbook content is accessed after loading
+- Keep examples focused and easy to understand
+
+---
+
+# Input Strategy
+
+- Avoid dependency on unknown external files
+- Create source content programmatically when possible
+- Keep examples self-contained
+
+---
+
+# Output Rules
+
+- Always generate output.xlsx when appropriate
+- Ensure workbook is processed successfully
+- Output files are written to the working directory
+
+---
+
+# Common Tasks
+
+- Open workbook
+- Open CSV file
+- Open HTML file
+- Configure LoadOptions
+- Detect file format
+- Access workbook metadata after loading
+
+---
+
+# Common Mistakes
+
+❌ var workbook = new Workbook();
+✅ Workbook workbook = new Workbook();
+
+❌ Use incorrect LoadOptions type
+✅ Match LoadOptions to source format
+
+❌ Assume workbook contains worksheets without validation
+✅ Verify workbook content before processing
+
+---
+
+# Code Simplicity
+
+- Keep examples concise
+- Avoid unnecessary abstractions
+- Focus on one workbook-loading capability per example
+
+---
+
+# General Rules
+
+Refer to the root agents.md for:
+- Boundaries
+- Testing requirements
+- Build and run instructions

open-workbook/agents.md

@@ -0,0 +1,49 @@
+using System;
+using Aspose.Cells;
+
+namespace AsposeCellsLoadFilterExample
+{
+    // Custom LoadFilter that returns a specific sheet loading order
+    public class CustomLoadFilter : LoadFilter
+    {
+        private readonly int[] _sheetsOrder;
+
+        // Accept the desired sheet indices via constructor
+        public CustomLoadFilter(int[] sheetsOrder) : base(LoadDataFilterOptions.All)
+        {
+            _sheetsOrder = sheetsOrder;
+        }
+
+        // Override the read‑only property to supply the indices
+        public override int[] SheetsInLoadingOrder => _sheetsOrder;
+    }
+
+    class Program
+    {
+        static void Main()
+        {
+            // User‑provided list of sheet indexes to load (e.g., load sheet 0 and sheet 2)
+            int[] selectedSheetIndexes = new int[] { 0, 2 };
+
+            // Create the custom filter with the desired order
+            LoadFilter filter = new CustomLoadFilter(selectedSheetIndexes);
+
+            // Configure load options to use the filter
+            LoadOptions loadOptions = new LoadOptions();
+            loadOptions.LoadFilter = filter;
+
+            // Load the workbook using the filter – only the specified sheets will be loaded
+            Workbook workbook = new Workbook("Template.xlsx", loadOptions);
+
+            // Demonstrate which sheets were loaded
+            Console.WriteLine("Loaded worksheets count: " + workbook.Worksheets.Count);
+            foreach (Worksheet ws in workbook.Worksheets)
+            {
+                Console.WriteLine($"- Index: {ws.Index}, Name: {ws.Name}");
+            }
+
+            // Save the workbook (optional, demonstrates that saving works with filtered sheets)
+            workbook.Save("FilteredOutput.xlsx");
+        }
+    }
+}

open-workbook/apply-a-loadfilter-that-selects-worksheets-based-on-a-userprovided-list-of-indices-before-loading-the-workbook.cs

@@ -0,0 +1,39 @@
+using System;
+using Aspose.Cells;
+
+namespace AsposeCellsFilterExample
+{
+    class Program
+    {
+        static void Main()
+        {
+            // Path to the template workbook
+            string templatePath = "TemplateWorkbook.xlsx";
+
+            // Create LoadOptions and set a LoadFilter that loads only numeric (including date/time) cells
+            LoadOptions loadOptions = new LoadOptions();
+            loadOptions.LoadFilter = new LoadFilter(LoadDataFilterOptions.CellNumeric);
+
+            // Load the workbook using the specified load options
+            Workbook workbook = new Workbook(templatePath, loadOptions);
+
+            // At this point, only cells with numeric or date values are loaded.
+            // Perform any statistical analysis here, e.g., iterate through worksheets and cells.
+
+            // Example: Count numeric cells in the first worksheet
+            Worksheet sheet = workbook.Worksheets[0];
+            int numericCellCount = 0;
+            foreach (Cell cell in sheet.Cells)
+            {
+                if (cell.Type == CellValueType.IsNumeric) // includes dates
+                {
+                    numericCellCount++;
+                }
+            }
+            Console.WriteLine($"Numeric/Date cells loaded: {numericCellCount}");
+
+            // Save the filtered workbook (optional, for verification)
+            workbook.Save("FilteredWorkbook.xlsx");
+        }
+    }
+}

open-workbook/apply-filterdatakind-to-load-only-numeric-and-date-cells-from-a-template-workbook-for-statistical-analysis.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Text;
+using Aspose.Cells;
+
+class Program
+{
+    static void Main()
+    {
+        // Paths to the template and the output summary workbook
+        string templatePath = "template.xlsx";
+        string outputPath = "summary.xlsx";
+
+        // Configure load options to load only cells that contain string values
+        LoadOptions loadOptions = new LoadOptions();
+        loadOptions.LoadFilter = new LoadFilter(LoadDataFilterOptions.CellString);
+
+        // Load the workbook from the template using the specified filter
+        Workbook sourceWorkbook = new Workbook(templatePath, loadOptions);
+
+        // StringBuilder to accumulate all string values from the loaded workbook
+        StringBuilder concatenatedStrings = new StringBuilder();
+
+        // Iterate through each worksheet and its used cells
+        foreach (Worksheet sheet in sourceWorkbook.Worksheets)
+        {
+            Cells cells = sheet.Cells;
+            int maxRow = cells.MaxDataRow;
+            int maxCol = cells.MaxDataColumn;
+
+            for (int row = 0; row <= maxRow; row++)
+            {
+                for (int col = 0; col <= maxCol; col++)
+                {
+                    Cell cell = cells[row, col];
+                    // After applying the filter, only string cells are loaded,
+                    // but we still verify the cell type for safety.
+                    if (cell != null && cell.Type == CellValueType.IsString)
+                    {
+                        concatenatedStrings.Append(cell.StringValue);
+                        concatenatedStrings.Append(' '); // separator between values
+                    }
+                }
+            }
+        }
+
+        // Create a new workbook that will hold the summary report
+        Workbook summaryWorkbook = new Workbook();
+        Worksheet summarySheet = summaryWorkbook.Worksheets[0];
+        summarySheet.Name = "Summary";
+
+        // Write the concatenated string into cell A1 of the summary sheet
+        summarySheet.Cells["A1"].PutValue(concatenatedStrings.ToString().Trim());
+
+        // Save the summary workbook to the specified output path
+        summaryWorkbook.Save(outputPath);
+    }
+}

open-workbook/apply-filterdatakind-to-load-only-string-cells-from-a-template-then-concatenate-them-into-a-summary-report.cs

@@ -0,0 +1,44 @@
+using System;
+using Aspose.Cells;
+
+class FilterDefinedNamesDemo
+{
+    static void Main()
+    {
+        // Path to the source workbook (replace with your actual file)
+        string sourcePath = "Source.xlsx";
+
+        // Path where the processed workbook will be saved
+        string outputPath = "FilteredNames.xlsx";
+
+        // Create LoadOptions and assign a custom LoadFilter that loads only defined names
+        LoadOptions loadOptions = new LoadOptions();
+        loadOptions.LoadFilter = new DefinedNamesOnlyLoadFilter();
+
+        // Load the workbook using the specified LoadOptions
+        Workbook workbook = new Workbook(sourcePath, loadOptions);
+
+        // Retrieve all defined names (both workbook‑scoped and worksheet‑scoped)
+        Name[] allNames = workbook.Worksheets.Names.Filter(NameScopeType.All, -1);
+
+        // Output information about the loaded names
+        Console.WriteLine($"Loaded {allNames.Length} defined name(s):");
+        foreach (Name name in allNames)
+        {
+            Console.WriteLine($"Name: {name.Text}, RefersTo: {name.RefersTo}");
+        }
+
+        // Save the workbook (structure and names are preserved)
+        workbook.Save(outputPath);
+    }
+
+    // Custom LoadFilter that restricts loading to defined name objects only
+    private class DefinedNamesOnlyLoadFilter : LoadFilter
+    {
+        public override void StartSheet(Worksheet sheet)
+        {
+            // Load only the defined names; other data (cells, formats, etc.) is ignored
+            LoadDataFilterOptions = LoadDataFilterOptions.DefinedNames;
+        }
+    }
+}

open-workbook/apply-filterdefinednames-while-loading-a-workbook-to-include-only-required-named-ranges-for-calculations.cs

@@ -0,0 +1,33 @@
+using System;
+using Aspose.Cells;
+
+class Program
+{
+    static void Main()
+    {
+        // Path to the source workbook
+        string sourcePath = "input.xlsx";
+
+        // Create a LoadFilter that loads everything except data validations
+        // LoadDataFilterOptions.All includes all data; we remove DataValidation using bitwise NOT
+        LoadDataFilterOptions filterOptions = LoadDataFilterOptions.All & ~LoadDataFilterOptions.DataValidation;
+        LoadFilter loadFilter = new LoadFilter(filterOptions);
+
+        // Assign the filter to LoadOptions
+        LoadOptions loadOptions = new LoadOptions();
+        loadOptions.LoadFilter = loadFilter;
+
+        // Load the workbook with the specified filter
+        Workbook workbook = new Workbook(sourcePath, loadOptions);
+
+        // Demonstrate that worksheets are loaded and data validations are excluded
+        Console.WriteLine("Number of worksheets loaded: " + workbook.Worksheets.Count);
+        foreach (Worksheet sheet in workbook.Worksheets)
+        {
+            Console.WriteLine($"Worksheet '{sheet.Name}' - Cells: {sheet.Cells.Count}, Validations: {sheet.Validations.Count}");
+        }
+
+        // Save the workbook (optional, shows lifecycle usage)
+        workbook.Save("output.xlsx");
+    }
+}