[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,61 @@
+using System;
+using Aspose.Cells;
+
+namespace AsposeCellsCustomFunctionDemo
+{
+    // Custom calculation engine that implements the GETUSERNAME() function
+    public class UserNameEngine : AbstractCalculationEngine
+    {
+        // Called for each custom function during calculation
+        public override void Calculate(CalculationData data)
+        {
+            // Check if the function being evaluated is our custom function
+            if (data.FunctionName.Equals("GETUSERNAME", StringComparison.OrdinalIgnoreCase))
+            {
+                // Return the current Windows user name as the function result
+                data.CalculatedValue = Environment.UserName;
+            }
+        }
+
+        // Ensure the function is recalculated each time (useful for volatile data like user name)
+        public override bool ForceRecalculate(string functionName)
+        {
+            return functionName.Equals("GETUSERNAME", StringComparison.OrdinalIgnoreCase);
+        }
+    }
+
+    public class Program
+    {
+        public static void Main()
+        {
+            // Create a new workbook (lifecycle: create)
+            Workbook workbook = new Workbook();
+
+            // Access the first worksheet
+            Worksheet sheet = workbook.Worksheets[0];
+
+            // Place the custom function in cell A1
+            // The formula name must match the name used in the custom engine
+            sheet.Cells["A1"].Formula = "=GETUSERNAME()";
+
+            // Configure calculation options to use the custom engine
+            CalculationOptions options = new CalculationOptions
+            {
+                CustomEngine = new UserNameEngine()
+            };
+
+            // Perform calculation (invokes the custom function)
+            workbook.CalculateFormula(options);
+
+            // Retrieve and display the result
+            string userName = sheet.Cells["A1"].StringValue;
+            Console.WriteLine("Custom function result (User Name): " + userName);
+
+            // Audit log example – write to console (could be written to a file or DB)
+            Console.WriteLine($"[Audit] GETUSERNAME() evaluated at {DateTime.UtcNow:u} – Result: {userName}");
+
+            // Save the workbook (lifecycle: save)
+            workbook.Save("UserNameFunctionDemo.xlsx");
+        }
+    }
+}

calculate-formulas/add-multiple-cells-to-the-watch-window-in-a-loop-to-monitor-a-batch-of-formulas.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();
+            Worksheet sheet = workbook.Worksheets[0];
+
+            // Add watches for a batch of cells (A1 to A10) in a loop
+            for (int i = 0; i < 10; i++)
+            {
+                // Define the cell address (e.g., A1, A2, ...)
+                string cellName = $"A{i + 1}";
+
+                // Optionally set a formula in the cell to be monitored
+                sheet.Cells[cellName].Formula = $"=ROW()*2";
+
+                // Add the cell to the Watch Window
+                sheet.CellWatches.Add(cellName);
+            }
+
+            // Output the total number of watches added
+            Console.WriteLine($"Total watches added: {sheet.CellWatches.Count}");
+
+            // Save the workbook with the watch window configuration
+            workbook.Save("WatchWindowDemo.xlsx");
+        }
+    }
+}

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

@@ -0,0 +1,57 @@
+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
+            cells["A1"].PutValue(10);
+            cells["A2"].PutValue(20);
+            cells["A3"].PutValue(30);
+            cells["B1"].Formula = "=A1*2";   // Formula that will be affected by conditional formatting
+            cells["B2"].Formula = "=A2*2";
+            cells["B3"].Formula = "=A3*2";
+
+            // Add a conditional formatting rule: highlight cells in column A between 15 and 25
+            int cfIndex = sheet.ConditionalFormattings.Add();
+            FormatConditionCollection fcc = sheet.ConditionalFormattings[cfIndex];
+
+            // Define the range A1:A3 for the conditional formatting
+            CellArea area = new CellArea
+            {
+                StartRow = 0,
+                StartColumn = 0,
+                EndRow = 2,
+                EndColumn = 0
+            };
+            fcc.AddArea(area);
+
+            // Add the condition (type: CellValue, operator: Between, formulas "15" and "25")
+            int conditionIdx = fcc.AddCondition(FormatConditionType.CellValue, OperatorType.Between, "15", "25");
+            FormatCondition condition = fcc[conditionIdx];
+
+            // Set the style to be applied when the condition is met (e.g., 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 all formulas
+            // This ensures that any formulas dependent 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,44 @@
+using System;
+using Aspose.Cells;
+
+class Program
+{
+    static void Main()
+    {
+        // Create a new workbook (lifecycle rule: create)
+        Workbook workbook = new Workbook();
+        Worksheet sheet = workbook.Worksheets[0];
+        Cells cells = sheet.Cells;
+
+        // Sample data and a dependent formula
+        cells["A1"].PutValue(10);               // Base value
+        cells["B1"].Formula = "=A1*2";          // Formula depends on A1
+
+        // Add data validation to cell C1 (whole number between 5 and 20)
+        Validation validation = sheet.Validations[sheet.Validations.Add()];
+        validation.Type = ValidationType.WholeNumber;
+        validation.Operator = OperatorType.Between;
+        validation.Formula1 = "5";
+        validation.Formula2 = "20";
+
+        // Apply the validation to cell C1
+        CellArea area = new CellArea
+        {
+            StartRow = 0,      // Row 0 (A)
+            StartColumn = 2,   // Column C
+            EndRow = 0,
+            EndColumn = 2
+        };
+        validation.AddArea(area);
+
+        // After applying validation, calculate all formulas (required step)
+        workbook.CalculateFormula();
+
+        // Display calculated results
+        Console.WriteLine("A1 value: " + cells["A1"].IntValue);
+        Console.WriteLine("B1 formula result: " + cells["B1"].IntValue);
+
+        // Save the workbook (lifecycle rule: save)
+        workbook.Save("Output.xlsx");
+    }
+}

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

@@ -0,0 +1,30 @@
+using System;
+using Aspose.Cells;
+
+class DeleteColumnAndRecalculate
+{
+    static void Main()
+    {
+        // Create a new workbook
+        Workbook workbook = new Workbook();
+        Worksheet sheet = workbook.Worksheets[0];
+        Cells cells = sheet.Cells;
+
+        // Add sample data
+        cells["A1"].PutValue(10);
+        cells["B1"].PutValue(20);
+        cells["C1"].PutValue(30);
+
+        // Formula that references the three columns
+        cells["D1"].Formula = "=SUM(A1:C1)";
+
+        // Delete column B (index 1) and update references in formulas
+        cells.DeleteColumn(1, true);
+
+        // Recalculate formulas after the column deletion
+        workbook.CalculateFormula();
+
+        // Save the modified workbook
+        workbook.Save("AfterDeleteColumn.xlsx");
+    }
+}

calculate-formulas/after-inserting-a-new-row-call-workbookcalculateformula-to-update-dependent-formulas-automatically.cs

@@ -0,0 +1,35 @@
+using System;
+using Aspose.Cells;
+
+namespace AsposeCellsInsertRowAndRecalculate
+{
+    class Program
+    {
+        static void Main()
+        {
+            // Create a new workbook (lifecycle rule: create)
+            Workbook workbook = new Workbook();
+
+            // Access the first worksheet and its cells collection
+            Worksheet sheet = workbook.Worksheets[0];
+            Cells cells = sheet.Cells;
+
+            // Populate some initial data and a formula that depends on the data
+            cells["A1"].PutValue(10);               // Row 0
+            cells["A2"].PutValue(20);               // Row 1 (will be shifted after insertion)
+            cells["A3"].Formula = "=A1+A2";         // Depends on A1 and A2
+
+            // Insert a new row at index 1 (between the original rows 0 and 1)
+            // This uses the Cells.InsertRow method rule
+            cells.InsertRow(1);
+
+            // After inserting the row, recalculate all formulas so that dependent
+            // cells (e.g., A3) reflect the new layout.
+            // This uses the Workbook.CalculateFormula method rule.
+            workbook.CalculateFormula();
+
+            // Save the workbook (lifecycle rule: save)
+            workbook.Save("InsertedRowWithRecalculatedFormulas.xlsx");
+        }
+    }
+}

calculate-formulas/after-protecting-a-worksheet-call-workbookcalculateformula-to-verify-that-protected-cells-still-calculate.cs

@@ -0,0 +1,38 @@
+using System;
+using Aspose.Cells;
+
+namespace AsposeCellsProtectedFormulaDemo
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            // Create a new workbook
+            Workbook workbook = new Workbook();
+            Worksheet sheet = workbook.Worksheets[0];
+            Cells cells = sheet.Cells;
+
+            // Populate cells with values and a formula that depends on them
+            cells["A1"].PutValue(5);               // Input value
+            cells["B1"].Formula = "=A1*2";          // Formula to calculate
+            cells["C1"].Formula = "=B1+10";         // Dependent formula
+
+            // Protect the worksheet with a password
+            sheet.Protect(ProtectionType.All, "myPassword", null);
+
+            // Verify protection status (optional)
+            Console.WriteLine($"Worksheet protected: {sheet.IsProtected}");
+
+            // Calculate all formulas in the workbook after protection
+            workbook.CalculateFormula();
+
+            // Display the calculated results
+            Console.WriteLine($"A1 value: {cells["A1"].IntValue}");
+            Console.WriteLine($"B1 formula result: {cells["B1"].IntValue}");
+            Console.WriteLine($"C1 formula result: {cells["C1"].IntValue}");
+
+            // Save the workbook (optional)
+            workbook.Save("ProtectedFormulaDemo.xlsx", SaveFormat.Xlsx);
+        }
+    }
+}

calculate-formulas/after-renaming-a-worksheet-call-workbookcalculateformula-to-refresh-formulas-that-reference-the-sheet.cs

@@ -0,0 +1,40 @@
+using System;
+using Aspose.Cells;
+
+class Program
+{
+    static void Main()
+    {
+        // Create a new workbook (lifecycle: create)
+        Workbook wb = new Workbook();
+
+        // Access the default first worksheet and give it an initial name
+        Worksheet sheet1 = wb.Worksheets[0];
+        sheet1.Name = "Data";
+
+        // Populate some data in the first worksheet
+        sheet1.Cells["A1"].PutValue(10);
+        sheet1.Cells["A2"].PutValue(20);
+
+        // Add a second worksheet that contains a formula referencing the first sheet
+        Worksheet sheet2 = wb.Worksheets.Add("Summary");
+        // Formula uses the sheet name "Data"
+        sheet2.Cells["B1"].Formula = "=Data!A1+Data!A2";
+
+        // Initial calculation so the formula has a value
+        wb.CalculateFormula();
+
+        Console.WriteLine("Before rename, B1 value: " + sheet2.Cells["B1"].Value);
+
+        // Rename the first worksheet
+        sheet1.Name = "RenamedData";
+
+        // Refresh all formulas after the rename operation
+        wb.CalculateFormula();
+
+        Console.WriteLine("After rename, B1 value: " + sheet2.Cells["B1"].Value);
+
+        // Save the workbook (lifecycle: save)
+        wb.Save("RenamedSheetDemo.xlsx");
+    }
+}