[AUTO] XML Maps Examples Update

manage-workbook/README.md

@@ -0,0 +1,94 @@
+---
+title: Create and Manage Excel Workbooks in C# with Aspose.Cells
+description: C# examples for workbook creation, settings, worksheet coordination, custom XML, content-type properties, cleanup, streams, disposal, and batch processing.
+product: Aspose.Cells for .NET
+category: manage-workbook
+language: C#
+last_reviewed: 2026-06-29
+---
+
+# Create and Manage Excel Workbooks in C# with Aspose.Cells
+
+Create, configure, inspect, clean, copy, and manage Excel workbooks in C# with Aspose.Cells for .NET. These 60 examples cover workbook lifecycle, settings, worksheet coordination, custom XML parts, content-type properties, unused-style cleanup, streams, disposal, and batch workflows.
+
+| Fact | Value |
+| --- | --- |
+| Examples | 60 |
+| Primary API | `Workbook` |
+| Key collections | `Worksheets`, `CustomXmlParts`, `ContentTypeProperties` |
+| Agent guidance | [`AGENTS.md`](AGENTS.md) |
+
+## Quick answer: How do I create an Excel workbook in C#?
+
+```csharp
+Workbook workbook = new Workbook();
+Worksheet worksheet = workbook.Worksheets[0];
+
+worksheet.Name = "Summary";
+worksheet.Cells["A1"].PutValue("Managed workbook");
+
+workbook.Save("managed-workbook.xlsx");
+workbook.Dispose();
+```
+
+Dispose workbooks deterministically when your application owns them, particularly in batch and stream-processing services.
+
+## Workbook management map
+
+| Goal | API/pattern |
+| --- | --- |
+| Create/configure workbook | `Workbook`, `Workbook.Settings` |
+| Coordinate worksheets | `Workbook.Worksheets` |
+| Add custom XML | `Workbook.CustomXmlParts` |
+| Add content-type properties | `Workbook.ContentTypeProperties` |
+| Remove unused styles | `Workbook.RemoveUnusedStyles` |
+| Process streams | `Workbook(Stream, ...)` and stream save overloads |
+| Release resources | `Dispose` / exception-safe ownership pattern |
+
+## Featured examples
+
+- [Copy a worksheet between workbooks](copy-a-worksheet-from-the-source-workbook-to-a-destination-workbook-while-preserving-cell-styles.cs)
+- [Add a custom XML part](add-a-custom-xml-part-containing-metadata-and-retrieve-it-later-using-its-unique-identifier.cs)
+- [Add a content-type property](add-a-new-contenttypeproperty-named-projectid-with-a-string-value-to-the-workbook.cs)
+- [Remove unused workbook styles](load-a-workbook-that-contains-numerous-unused-styles-and-invoke-removeunusedstyles-to-clean-it.cs)
+- [Compare file size before and after style cleanup](measure-the-file-size-before-and-after-removing-unused-styles-to-assess-reduction-impact.cs)
+- [Load and save through a memory stream](use-a-memory-stream-to-load-a-workbook-add-metadata-and-save-back-without-touching-the-file-system.cs)
+- [Guarantee disposal in a finally block](integrate-workbook-disposal-into-a-finally-block-to-guarantee-resource-release-even-when-exceptions-occur.cs)
+- [Process 100 workbooks in a batch](create-a-batch-job-that-processes-100-workbooks-adding-optional-metadata-and-removing-unused-styles.cs)
+
+## FAQ
+
+### When should a Workbook be disposed?
+
+Dispose it when the application owns it and all reads/saves are complete. This is especially important for large files and batch processing.
+
+### Are custom XML parts the same as custom document properties?
+
+No. Custom XML stores structured XML payloads inside the workbook package. Document properties store metadata name/value pairs.
+
+### Is removing unused styles always safe?
+
+Validate before and after output. Compare representative cell styles and rendered appearance because style-cleanup behavior may matter to complex workbooks.
+
+### How should batch failures be handled?
+
+Isolate each workbook, continue according to policy, record sanitized diagnostics, avoid input overwrite, and dispose resources after each item.
+
+## AI retrieval guidance
+
+Useful intents include "create Excel workbook in C#," "manage workbook settings," "remove unused styles," "add custom XML to XLSX," and "dispose workbook in batch." Distinguish workbook-wide operations from worksheet-only tasks.
+
+## Related categories and official resources
+
+- [Open workbook](../open-workbook/)
+- [Save workbook](../save-workbook/)
+- [Worksheets](../working-with-worksheets/)
+- [Document properties](../document-properties/)
+- [Workbook API](https://reference.aspose.com/cells/net/aspose.cells/workbook/)
+- [Create workbook documentation](https://docs.aspose.com/cells/net/create-new-workbook/)
+
+Repository policy requires build, runtime, output, resource-lifecycle, and reopened-state validation.
+
+## License
+
+See [`../LICENSE`](../LICENSE) and [Aspose.Cells licensing](https://purchase.aspose.com/buy).

xml-maps/after-importing-xml-recalculate-all-formulas-to-ensure-dependent-calculations-reflect-the-new-data.cs

@@ -0,0 +1,24 @@
+using System;
+using Aspose.Cells;
+
+class Program
+{
+    static void Main()
+    {
+        // Create a new workbook instance
+        Workbook workbook = new Workbook();
+
+        // Import XML data into the first worksheet starting at cell A1
+        // Adjust the file path as needed; the sheet name must exist or will be created
+        workbook.ImportXml("data.xml", "Sheet1", 0, 0);
+
+        // Recalculate all formulas so that any dependent cells reflect the newly imported data
+        workbook.CalculateFormula();
+
+        // Refresh pivot tables and charts if they exist (optional but ensures full consistency)
+        workbook.Worksheets.RefreshAll();
+
+        // Save the updated workbook
+        workbook.Save("Result.xlsx");
+    }
+}

xml-maps/agents.md

@@ -0,0 +1,117 @@
+# XML Maps Examples
+
+This folder contains **Aspose.Cells for .NET** code examples related to:
+
+XML Maps
+
+
+## Purpose
+
+These examples demonstrate common **Aspose.Cells APIs** used when working with:
+
+- Workbooks
+- Worksheets
+- Cells
+- Formulas
+- Charts
+- Data operations
+
+
+## Example Files
+
+Each `.cs` file demonstrates a specific task related to **XML Maps**.
+
+Example:
+
+create-a-workbook.cs
+
+
+## Required Namespaces
+
+Most examples will require:
+
+using Aspose.Cells;
+
+
+## Common Pattern
+
+Typical Aspose.Cells workflow:
+
+Workbook workbook = new Workbook();
+
+Worksheet sheet = workbook.Worksheets[0];
+
+Cells cells = sheet.Cells;
+
+
+## Output
+
+Examples may generate:
+
+- XLSX files
+- PDF files
+- CSV files
+- Images
+
+Output files are written to the working directory.
+- import-an-xml-map-from-an-xsd-file-into-a-workbook-using-workbookimportxml-method.cs
+- import-an-xml-map-directly-from-an-xml-file-into-a-workbook-with-workbookimportxml.cs
+- list-all-xml-maps-in-the-workbook-and-output-each-maps-name-to-the-console.cs
+- retrieve-the-root-element-name-of-the-first-xml-map-via-xmlmaprootelementname-property.cs
+- retrieve-the-root-element-name-of-a-specific-map-by-its-index-using-workbookxmlmapsindexrootelementname.cs
+- query-cells-mapped-to-a-given-xpath-expression-using-worksheetxmlmapquery-method.cs
+- query-cells-with-namespaceaware-xpath-by-providing-prefix-mappings-to-worksheetxmlmapquery.cs
+- validate-linked-cells-after-importing-xml-data-by-reexecuting-worksheetxmlmapquery-and-checking-results.cs
+- export-xml-data-for-a-specific-map-to-a-file-using-workbookexportxml-with-map-index.cs
+- export-xml-data-for-a-specific-map-to-a-memory-stream-using-workbookexportxml-overload.cs
+- loop-through-all-xml-maps-in-a-workbook-and-export-each-maps-xml-using-exportxml.cs
+- export-xml-with-utf8-encoding-by-specifying-encodingutf8-parameter-in-exportxml-method.cs
+- export-xml-with-indentation-enabled-by-configuring-exportxmloptions-before-calling-exportxml.cs
+- remove-an-unwanted-xml-map-from-the-workbook-by-its-index-using-xmlmapsremoveat.cs
+- remove-an-xml-map-by-its-name-using-a-helper-that-searches-the-xmlmaps-collection.cs
+- update-an-existing-xml-map-by-readding-it-with-the-same-name-and-a-new-xsd-schema.cs
+- save-the-workbook-after-modifying-xml-maps-using-workbooksave-to-persist-changes.cs
+- load-a-workbook-from-a-memory-stream-add-an-xml-map-and-save-back-to-a-stream.cs
+- batch-process-a-folder-of-workbooks-adding-the-same-xml-map-to-each-file-programmatically.cs
+- batch-export-xml-data-from-multiple-workbooks-by-iterating-files-and-invoking-exportxml-for-each-map.cs
+- import-xml-data-from-a-stream-into-a-workbook-with-linked-cells-using-importxml-overload.cs
+- export-xml-without-xml-declaration-by-setting-exportxmloptionsomitxmldeclaration-to-true.cs
+- export-xml-with-custom-namespace-prefixes-by-configuring-exportxmloptionsnamespaceprefixdictionary-before-export.cs
+- use-worksheetxmlmapquery-result-to-apply-background-color-formatting-to-all-cells-mapped-to-a-path.cs
+- enumerate-the-xmlmapcollection-and-log-each-maps-name-and-root-element-name-for-debugging.cs
+- create-a-new-workbook-add-a-worksheet-and-define-an-xml-map-using-a-xsd-file.cs
+- import-xml-data-into-the-workbook-by-linking-cells-to-corresponding-xml-map-elements.cs
+- query-all-cell-areas-mapped-to-a-given-xml-path-using-worksheetxmlmapquery-method.cs
+- retrieve-the-address-of-the-first-cell-mapped-to-the-invoicetotal-element.cs
+- iterate-through-each-mapped-cell-area-and-log-its-row-and-column-indices-for-debugging.cs
+- filter-mapped-cell-areas-by-xpath-expression-and-process-only-those-matching-the-criteria.cs
+- export-the-current-xml-map-data-to-a-separate-xml-file-preserving-original-schema-structure.cs
+- validate-the-xml-map-against-its-xsd-schema-and-report-any-validation-errors-encountered.cs
+- remove-an-existing-xml-map-from-the-workbook-and-ensure-all-linked-cells-are-cleared.cs
+- load-multiple-workbooks-from-a-directory-apply-the-same-xml-map-and-batch-export-their-xml-data.cs
+- configure-the-xml-map-to-ignore-whitespace-nodes-during-import-to-prevent-unwanted-blank-entries.cs
+- set-a-custom-namespace-prefix-for-the-xml-map-to-handle-namespaced-xml-documents-correctly.cs
+- use-worksheetcellsfind-to-locate-a-cell-that-is-mapped-to-a-specific-xml-attribute.cs
+- apply-conditional-formatting-to-cells-based-on-values-retrieved-from-the-linked-xml-map-elements.cs
+- create-a-pivot-table-that-summarizes-data-from-cells-mapped-to-the-ordersorder-element.cs
+- generate-a-chart-visualizing-totals-from-mapped-xml-nodes-and-embed-it-into-the-worksheet.cs
+- implement-error-handling-to-catch-exceptions-when-an-xml-map-path-does-not-exist-in-the-schema.cs
+- use-workbookloadoptions-to-preserve-existing-xml-maps-when-opening-a-workbook-in-readonly-mode.cs
+- export-mapped-xml-data-as-a-compressed-zip-archive-containing-separate-files-for-each-map.cs
+- apply-data-validation-rules-to-mapped-cells-to-ensure-imported-xml-values-meet-business-constraints.cs
+- use-multithreading-to-process-xml-map-imports-for-several-workbooks-concurrently-improving-performance.cs
+- log-the-execution-time-of-each-xml-map-query-to-identify-performance-bottlenecks-in-large-datasets.cs
+- configure-the-workbook-to-automatically-refresh-xml-map-data-when-the-source-xml-file-changes-on-disk.cs
+- implement-a-routine-that-clears-all-cell-values-linked-to-a-specific-xml-map-without-removing-the-map.cs
+- export-the-workbook-to-pdf-while-preserving-the-visual-representation-of-mapped-cells-and-their-data.cs
+- generate-a-summary-report-listing-each-xml-map-its-root-element-and-the-number-of-linked-cells.cs
+- apply-a-custom-style-to-cells-mapped-to-the-customername-element-to-highlight-customer-names.cs
+- set-the-xmlmaps-preservewhitespace-property-to-true-to-keep-formatting-spaces-from-the-source-xml.cs
+- use-a-linq-query-on-the-workbooks-xmlmaps-collection-to-find-maps-containing-a-specific-namespace.cs
+- programmatically-disable-automatic-xml-map-refresh-during-bulk-cell-updates-to-improve-processing-speed.cs
+- after-importing-xml-recalculate-all-formulas-to-ensure-dependent-calculations-reflect-the-new-data.cs
+- create-a-backup-copy-of-the-workbook-before-modifying-xml-maps-to-allow-easy-rollback-if-needed.cs
+- export-mapped-data-to-a-json-file-by-converting-the-xml-nodes-to-equivalent-json-structures.cs
+- implement-a-ui-dialog-that-lets-users-select-an-xml-schema-file-to-create-a-new-map.cs
+- create-a-scheduled-task-that-refreshes-all-xml-maps-in-a-set-of-workbooks-every-night-at-midnight.cs
+- export-the-workbook-to-an-ods-file-while-ensuring-that-xml-map-definitions-are-retained-in-the-output.cs

xml-maps/apply-a-custom-style-to-cells-mapped-to-the-customername-element-to-highlight-customer-names.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Drawing;
+using Aspose.Cells;
+
+namespace AsposeCellsCustomStyleExample
+{
+    class Program
+    {
+        static void Main()
+        {
+            // Load an existing workbook (replace with your file path)
+            Workbook workbook = new Workbook("Input.xlsx");
+
+            // Access the first worksheet
+            Worksheet worksheet = workbook.Worksheets[0];
+            Cells cells = worksheet.Cells;
+
+            // Create a custom style to highlight customer names
+            Style highlightStyle = workbook.CreateStyle();
+            highlightStyle.ForegroundColor = Color.Yellow;          // cell background
+            highlightStyle.Pattern = BackgroundType.Solid;
+            highlightStyle.Font.IsBold = true;                     // bold font
+            highlightStyle.Font.Color = Color.Red;                 // font color
+            highlightStyle.Font.Size = 12;
+
+            // Assume that cells mapped to /Customer/Name are in column B (index 1)
+            // Apply the style to rows 2 through 10 (adjust as needed)
+            for (int row = 1; row <= 9; row++) // zero‑based index: row 1 = second row
+            {
+                Cell nameCell = cells[row, 1]; // column B
+                // Optionally verify the cell contains a name before styling
+                if (!string.IsNullOrEmpty(nameCell.StringValue))
+                {
+                    nameCell.SetStyle(highlightStyle);
+                }
+            }
+
+            // Save the modified workbook
+            workbook.Save("Output.xlsx");
+        }
+    }
+}

xml-maps/apply-conditional-formatting-to-cells-based-on-values-retrieved-from-the-linked-xml-map-elements.cs

@@ -0,0 +1,87 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.IO;
+using System.Linq;
+using System.Xml.Linq;
+using Aspose.Cells;
+
+namespace AsposeCellsXmlConditionalFormatting
+{
+    class Program
+    {
+        static void Main()
+        {
+            try
+            {
+                // Create a new workbook and get the first worksheet
+                Workbook workbook = new Workbook();
+                Worksheet worksheet = workbook.Worksheets[0];
+                Cells cells = worksheet.Cells;
+
+                // Sample XML data
+                string xml = @"<?xml version='1.0' encoding='UTF-8'?>
+<Root>
+    <Item>150</Item>
+    <Item>80</Item>
+    <Item>200</Item>
+</Root>";
+
+                // Parse XML and write values to cells (A1, A2, A3)
+                XDocument doc = XDocument.Parse(xml);
+                List<string> items = doc.Root?.Elements("Item").Select(e => e.Value).ToList() ?? new List<string>();
+
+                for (int i = 0; i < items.Count; i++)
+                {
+                    cells[i, 0].PutValue(items[i]);
+                }
+
+                // Define the area that contains the imported values
+                CellArea dataArea = new CellArea
+                {
+                    StartRow = 0,
+                    StartColumn = 0,
+                    EndRow = items.Count - 1,
+                    EndColumn = 0
+                };
+
+                // Add a conditional formatting collection to the worksheet
+                int cfIndex = worksheet.ConditionalFormattings.Add();
+                FormatConditionCollection cfCollection = worksheet.ConditionalFormattings[cfIndex];
+
+                // Apply the conditional formatting to the data area
+                cfCollection.AddArea(dataArea);
+
+                // Add a condition: highlight cells with value > 100
+                int conditionIdx = cfCollection.AddCondition(
+                    FormatConditionType.CellValue,
+                    OperatorType.GreaterThan,
+                    "100",
+                    null);
+
+                // Set the style for the condition (red background, white bold font)
+                FormatCondition condition = cfCollection[conditionIdx];
+                condition.Style.BackgroundColor = Color.Red;
+                condition.Style.Font.Color = Color.White;
+                condition.Style.Font.IsBold = true;
+
+                // Save the workbook
+                string outputPath = "XmlConditionalFormattingOutput.xlsx";
+
+                // Ensure the output directory exists (prevents FileNotFoundException on save)
+                string outputDir = Path.GetDirectoryName(Path.GetFullPath(outputPath));
+                if (!string.IsNullOrEmpty(outputDir) && !Directory.Exists(outputDir))
+                {
+                    Directory.CreateDirectory(outputDir);
+                }
+
+                workbook.Save(outputPath);
+                Console.WriteLine($"Workbook saved to {outputPath}");
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Error: {ex.Message}");
+            }
+        }
+    }
+}