[AUTO] Calculate Formulas Examples Update

calculate-formulas/add-a-custom-function-that-returns-the-user-name-register-it-and-invoke-via-calculateformula-for-audit-logs.cs

@@ -0,0 +1,63 @@
+using System;
+using Aspose.Cells;
+
+namespace AsposeCellsCustomFunctionDemo
+{
+    // Custom calculation engine that implements a function returning the current user name
+    public class UserNameEngine : AbstractCalculationEngine
+    {
+        // Called for each custom function encountered during calculation
+        public override void Calculate(CalculationData data)
+        {
+            // Check if the function name matches our custom function (case‑insensitive)
+            if (data.FunctionName.Equals("GETUSERNAME", StringComparison.OrdinalIgnoreCase))
+            {
+                // Return the Windows user name as the calculated value
+                data.CalculatedValue = Environment.UserName;
+            }
+        }
+
+        // Ensure the function is recalculated each time (useful for audit logs)
+        public override bool ForceRecalculate(string functionName)
+        {
+            return functionName.Equals("GETUSERNAME", StringComparison.OrdinalIgnoreCase);
+        }
+    }
+
+    class Program
+    {
+        static void Main()
+        {
+            // Create a new workbook
+            Workbook workbook = new Workbook();
+            Worksheet sheet = workbook.Worksheets[0];
+            Cells cells = sheet.Cells;
+
+            // Place the custom function in cell A1
+            cells["A1"].Formula = "=GETUSERNAME()";
+
+            // Set up calculation options to use our custom engine
+            CalculationOptions options = new CalculationOptions
+            {
+                CustomEngine = new UserNameEngine()
+            };
+
+            // Perform calculation
+            workbook.CalculateFormula(options);
+
+            // Retrieve the result (the user name)
+            string userName = cells["A1"].StringValue;
+
+            // Write the audit log entry to cell B1
+            cells["B1"].PutValue($"Audit: Formula evaluated by user '{userName}' at {DateTime.Now}");
+
+            // Optional: demonstrate detection of custom functions
+            Console.WriteLine($"Cell A1 has custom function: {cells["A1"].HasCustomFunction}");
+            Console.WriteLine($"Workbook has custom function: {workbook.HasCustomFunction}");
+            Console.WriteLine($"Calculated user name: {userName}");
+
+            // Save the workbook (using the standard save rule)
+            workbook.Save("UserNameCustomFunction.xlsx", SaveFormat.Xlsx);
+        }
+    }
+}

calculate-formulas/add-a-specific-cell-to-the-formula-watch-window-using-worksheetcellwatchesadd-after-setting-its-formula.cs

@@ -0,0 +1,34 @@
+using System;
+using Aspose.Cells;
+
+namespace AsposeCellsWatchDemo
+{
+    class Program
+    {
+        static void Main()
+        {
+            // Create a new workbook
+            Workbook workbook = new Workbook();
+
+            // Access the first worksheet
+            Worksheet sheet = workbook.Worksheets[0];
+
+            // Set a formula in cell A1 (e.g., sum of B1 and C1)
+            sheet.Cells["A1"].Formula = "=SUM(B1,C1)";
+
+            // Optionally put some values in B1 and C1 for the formula to calculate
+            sheet.Cells["B1"].PutValue(10);
+            sheet.Cells["C1"].PutValue(20);
+
+            // Add the cell to the Formula Watch Window using its address
+            int watchIndex = sheet.CellWatches.Add("A1");
+
+            // Retrieve the added CellWatch (optional, just to demonstrate access)
+            CellWatch watch = sheet.CellWatches[watchIndex];
+            Console.WriteLine($"Added watch for cell: {watch.CellName} (Row={watch.Row}, Column={watch.Column})");
+
+            // Save the workbook to a file
+            workbook.Save("FormulaWatchDemo.xlsx");
+        }
+    }
+}

calculate-formulas/add-multiple-cells-to-the-watch-window-in-a-loop-to-monitor-a-batch-of-formulas.cs

@@ -0,0 +1,47 @@
+using System;
+using Aspose.Cells;
+
+namespace AsposeCellsWatchWindowDemo
+{
+    class Program
+    {
+        static void Main()
+        {
+            // Create a new workbook (using the standard creation rule)
+            Workbook workbook = new Workbook();
+
+            // Access the first worksheet
+            Worksheet sheet = workbook.Worksheets[0];
+
+            // Populate some sample formulas in column A (A1:A10)
+            for (int i = 0; i < 10; i++)
+            {
+                // Example formula: each cell sums its row number with a constant
+                sheet.Cells[i, 0].Formula = $"=ROW()+5";
+            }
+
+            // Get the CellWatchCollection for the worksheet
+            CellWatchCollection watches = sheet.CellWatches;
+
+            // Add watches for the range A1:A10 using a loop
+            for (int row = 0; row < 10; row++)
+            {
+                // Convert row index to cell name (e.g., A1, A2, ...)
+                string cellName = CellsHelper.CellIndexToName(row, 0);
+                watches.Add(cellName);
+            }
+
+            // Display the total number of watches added
+            Console.WriteLine($"Total Cell Watches added: {watches.Count}");
+
+            // Optionally, iterate and print each watched cell name
+            foreach (CellWatch watch in watches)
+            {
+                Console.WriteLine($"Watching cell: {watch.CellName}");
+            }
+
+            // Save the workbook (using the standard save rule)
+            workbook.Save("WatchWindowDemo.xlsx");
+        }
+    }
+}

calculate-formulas/after-applying-conditional-formatting-call-workbookcalculateformula-to-ensure-conditional-formulas-recalculate.cs

@@ -0,0 +1,56 @@
+using System;
+using Aspose.Cells;
+
+namespace AsposeCellsConditionalFormattingDemo
+{
+    class Program
+    {
+        static void Main()
+        {
+            // Create a new workbook (lifecycle rule: create)
+            Workbook workbook = new Workbook();
+
+            // Access the first worksheet
+            Worksheet sheet = workbook.Worksheets[0];
+            Cells cells = sheet.Cells;
+
+            // Populate sample data that will be used by the conditional format
+            cells["A1"].PutValue(5);
+            cells["A2"].PutValue(15);
+            cells["A3"].PutValue(25);
+            cells["A4"].PutValue(35);
+            cells["A5"].PutValue(45);
+
+            // Add a conditional formatting collection to the worksheet
+            int cfIndex = sheet.ConditionalFormattings.Add();
+            FormatConditionCollection fcc = sheet.ConditionalFormattings[cfIndex];
+
+            // Define the range to which the conditional formatting will be applied (A1:A5)
+            CellArea area = new CellArea
+            {
+                StartRow = 0,
+                StartColumn = 0,
+                EndRow = 4,
+                EndColumn = 0
+            };
+            fcc.AddArea(area);
+
+            // Add a condition: highlight cells with values between 10 and 30 (inclusive)
+            int conditionIdx = fcc.AddCondition(FormatConditionType.CellValue, OperatorType.Between, "10", "30");
+            FormatCondition condition = fcc[conditionIdx];
+
+            // Set the style for the condition (red background)
+            Style style = workbook.CreateStyle();
+            style.ForegroundColor = System.Drawing.Color.Red;
+            style.Pattern = BackgroundType.Solid;
+            condition.Style = style;
+
+            // After setting up conditional formatting, recalculate formulas
+            // (ensures any formulas that depend on the formatted cells are updated)
+            workbook.CalculateFormula();
+
+            // Save the workbook (lifecycle rule: save)
+            workbook.Save("ConditionalFormattingWithRecalc.xlsx");
+        }
+    }
+}

calculate-formulas/after-applying-data-validation-call-workbookcalculateformula-to-evaluate-any-dependent-formulas.cs

@@ -0,0 +1,83 @@
+using System;
+using System.IO;
+using Aspose.Cells;
+
+namespace AsposeCellsDataValidationAndCalculate
+{
+    class Program
+    {
+        static void Main()
+        {
+            try
+            {
+                // Create a new workbook (lifecycle rule: create)
+                Workbook workbook = new Workbook();
+
+                // Access the first worksheet
+                Worksheet sheet = workbook.Worksheets[0];
+                Cells cells = sheet.Cells;
+
+                // -------------------------------------------------
+                // Set up sample data and formulas
+                // -------------------------------------------------
+                // Cell A1 will hold a base value
+                cells["A1"].PutValue(10);
+
+                // Cell B1 contains a formula that depends on A1
+                cells["B1"].Formula = "=A1*2";
+
+                // -------------------------------------------------
+                // Add data validation to cell A1 (must be between 5 and 20)
+                // -------------------------------------------------
+                // Define the area (cell A1) to which the validation applies
+                CellArea area = new CellArea
+                {
+                    StartRow = 0,
+                    StartColumn = 0,
+                    EndRow = 0,
+                    EndColumn = 0
+                };
+
+                // Add a new validation for the defined area.
+                // In older Aspose.Cells versions Add returns the index of the validation.
+                int validationIndex = sheet.Validations.Add(area);
+                Validation validation = sheet.Validations[validationIndex];
+
+                // Configure the validation rule
+                validation.Type = ValidationType.WholeNumber;
+                validation.Operator = OperatorType.Between;
+                validation.Formula1 = "5";   // Minimum value
+                validation.Formula2 = "20";  // Maximum value
+
+                // -------------------------------------------------
+                // After setting validation, calculate all formulas
+                // -------------------------------------------------
+                workbook.CalculateFormula();
+
+                // -------------------------------------------------
+                // Output the results to verify calculation
+                // -------------------------------------------------
+                Console.WriteLine("A1 (validated value) : " + cells["A1"].IntValue);
+                Console.WriteLine("B1 (formula result) : " + cells["B1"].IntValue);
+
+                // Save the workbook (lifecycle rule: save)
+                string outputPath = "DataValidationAndCalculate.xlsx";
+
+                // Ensure the directory exists before saving
+                string outputDir = Path.GetDirectoryName(Path.GetFullPath(outputPath));
+                if (!Directory.Exists(outputDir))
+                {
+                    Directory.CreateDirectory(outputDir);
+                }
+
+                workbook.Save(outputPath, SaveFormat.Xlsx);
+                Console.WriteLine($"Workbook saved to '{Path.GetFullPath(outputPath)}'.");
+            }
+            catch (Exception ex)
+            {
+                // Log any unexpected errors
+                Console.WriteLine("An error occurred: " + ex.Message);
+            }
+        }
+    }
+}

calculate-formulas/after-deleting-a-column-call-workbookcalculateformula-to-ensure-remaining-formulas-recalculate-correctly.cs

@@ -0,0 +1,74 @@
+using System;
+using System.IO;
+using Aspose.Cells;
+
+namespace AsposeCellsExamples
+{
+    public class DeleteColumnAndRecalculateDemo
+    {
+        public static void Run()
+        {
+            try
+            {
+                // Create a new workbook
+                Workbook workbook = new Workbook();
+
+                // Access the first worksheet
+                Worksheet sheet = workbook.Worksheets[0];
+                Cells cells = sheet.Cells;
+
+                // Populate sample data in columns A and B
+                cells["A1"].PutValue(10);
+                cells["B1"].PutValue(20);
+                cells["A2"].PutValue(30);
+                cells["B2"].PutValue(40);
+
+                // Add a formula that sums the values in column A and B
+                cells["C1"].Formula = "=SUM(A1:B2)";
+
+                // Calculate formulas before deletion (optional, just to show initial state)
+                workbook.CalculateFormula();
+
+                Console.WriteLine("Before deleting column:");
+                Console.WriteLine($"C1 formula result: {cells["C1"].Value}");
+
+                // Delete column B (index 1) and update references in other worksheets
+                cells.DeleteColumn(1, true);
+
+                // Recalculate formulas after the column deletion
+                workbook.CalculateFormula();
+
+                Console.WriteLine("After deleting column B:");
+                Console.WriteLine($"C1 formula: {cells["C1"].Formula}");
+                Console.WriteLine($"C1 formula result: {cells["C1"].Value}");
+
+                // Define output file path
+                string outputPath = "DeleteColumnAndRecalculateDemo.xlsx";
+
+                // Ensure the output directory exists
+                string directory = Path.GetDirectoryName(Path.GetFullPath(outputPath));
+                if (!Directory.Exists(directory))
+                {
+                    Directory.CreateDirectory(directory);
+                }
+
+                // Save the workbook
+                workbook.Save(outputPath);
+                Console.WriteLine($"Workbook saved to {outputPath}");
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Error: {ex.Message}");
+            }
+        }
+    }
+
+    // Application entry point
+    public class Program
+    {
+        public static void Main(string[] args)
+        {
+            DeleteColumnAndRecalculateDemo.Run();
+        }
+    }
+}