Add Template Method pattern with demo and tests

Implemented the Template Method design pattern, including:
- Abstract `Report` class and concrete implementations (`SalesReport` and `InventoryReport`) in `Report.cs`.
- Console demo showcasing the pattern in `Program.cs`.
- Updated `README.md` with documentation, usage examples, and test references.
- Added unit tests in `TemplateMethodTests.cs` to verify correct behavior of `SalesReport` and `InventoryReport`.

Author: froghramar

DesignPatterns/Program.cs

@@ -17,6 +17,7 @@
 using DesignPatterns.Observer;
 using DesignPatterns.State;
 using DesignPatterns.Strategy;
+using DesignPatterns.TemplateMethod;
 
 Console.WriteLine("Factory pattern demo:");
 
@@ -222,6 +223,14 @@
 sorted = sorter.Sort(data);
 Console.WriteLine("Sorted: " + string.Join(", ", sorted));
 
+// Template Method demo
+Console.WriteLine();
+Console.WriteLine("Template Method pattern demo:");
+var salesReport = new SalesReport();
+Console.WriteLine(salesReport.GenerateReport());
+var inventoryReport = new InventoryReport();
+Console.WriteLine(inventoryReport.GenerateReport());
+
 // Memento demo
 Console.WriteLine();
 Console.WriteLine("Memento pattern demo:");

DesignPatterns/TemplateMethod/Report.cs

@@ -0,0 +1,66 @@
+namespace DesignPatterns.TemplateMethod;
+
+// Template Method pattern: defines skeleton of an algorithm in base class and lets subclasses override specific steps.
+public abstract class Report
+{
+    // Template method
+    public string GenerateReport()
+    {
+        var data = CollectData();
+        var analysis = AnalyzeData(data);
+        var formatted = FormatReport(data, analysis);
+        return formatted;
+    }
+
+    protected abstract string CollectData();
+    protected abstract string AnalyzeData(string data);
+    protected abstract string FormatReport(string data, string analysis);
+}
+
+public class SalesReport : Report
+{
+    protected override string CollectData()
+    {
+        // simulate data collection
+        return "Sales:100,200,150";
+    }
+
+    protected override string AnalyzeData(string data)
+    {
+        // simple analysis: compute total
+        var parts = data.Split(':')[1].Split(',');
+        int total = 0;
+        foreach (var p in parts) total += int.Parse(p);
+        return $"Total={total}";
+    }
+
+    protected override string FormatReport(string data, string analysis)
+    {
+        return $"SalesReport\nData: {data}\nAnalysis: {analysis}";
+    }
+}
+
+public class InventoryReport : Report
+{
+    protected override string CollectData()
+    {
+        return "Items:A:10,B:5,C:20";
+    }
+
+    protected override string AnalyzeData(string data)
+    {
+        // count total items
+        var parts = data.Split(':', ',');
+        int total = 0;
+        for (int i = 2; i < parts.Length; i += 2)
+        {
+            total += int.Parse(parts[i]);
+        }
+        return $"TotalItems={total}";
+    }
+
+    protected override string FormatReport(string data, string analysis)
+    {
+        return $"InventoryReport\nData: {data}\nAnalysis: {analysis}";
+    }
+}

README.md

@@ -3,7 +3,7 @@ Design Patterns Examples
 This solution demonstrates simple design pattern examples in C# targeting .NET 10 (C# 14).
 
 Projects
-- `DesignPatterns` - Console demo showing Factory, Singleton, Builder, Prototype, Abstract Factory, Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy, Chain of Responsibility, Command, Iterator, Mediator, Observer, State, Strategy, and Memento patterns.
+- `DesignPatterns` - Console demo showing Factory, Singleton, Builder, Prototype, Abstract Factory, Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy, Chain of Responsibility, Command, Iterator, Mediator, Observer, State, Strategy, Template Method, and Memento patterns.
   - Factory implementation: `DesignPatterns/Factories`
   - Singleton implementation: `DesignPatterns/Singleton/Logger.cs`
   - Builder implementation: `DesignPatterns/Builder/HouseBuilder.cs` and `DesignPatterns/Builder/House.cs`
@@ -23,6 +23,7 @@ Projects
   - Observer implementation: `DesignPatterns/Observer/*`
   - State implementation: `DesignPatterns/State/*`
   - Strategy implementation: `DesignPatterns/Strategy/*`
+  - Template Method implementation: `DesignPatterns/TemplateMethod/*`
   - Memento implementation: `DesignPatterns/Memento/*`
 - `Tests` - xUnit tests covering the examples.
 
@@ -277,6 +278,19 @@ Included patterns and brief docs
     editor.Restore(caretaker.PopState());
     ```
 
+- Template Method Pattern
+  - Purpose: Define the skeleton of an algorithm in a base class and let subclasses override specific steps without changing the algorithm's structure.
+  - Example: `DesignPatterns/TemplateMethod/*` contains `Report` (base class) and concrete reports `SalesReport` and `InventoryReport` that implement the specific steps.
+  - Usage snippet:
+
+    ```csharp
+    var sales = new SalesReport();
+    Console.WriteLine(sales.GenerateReport());
+
+    var inv = new InventoryReport();
+    Console.WriteLine(inv.GenerateReport());
+    ```
+
 Tests
 - Tests are written with xUnit in the `Tests` project.
   - Factory tests: `Tests/ShapeFactoryTests.cs`
@@ -299,6 +313,7 @@ Tests
   - State tests: `Tests/StateTests.cs`
   - Strategy tests: `Tests/StrategyTests.cs`
   - Memento tests: `Tests/MementoTests.cs`
+  - Template Method tests: `Tests/TemplateMethodTests.cs`
 
 Common commands
 - Build solution: `dotnet build`

Tests/TemplateMethodTests.cs

@@ -0,0 +1,26 @@
+using DesignPatterns.TemplateMethod;
+using Xunit;
+
+namespace Tests
+{
+    public class TemplateMethodTests
+    {
+        [Fact]
+        public void SalesReport_Generates_Correctly()
+        {
+            var r = new SalesReport();
+            var output = r.GenerateReport();
+            Assert.Contains("SalesReport", output);
+            Assert.Contains("Total=450", output);
+        }
+
+        [Fact]
+        public void InventoryReport_Generates_Correctly()
+        {
+            var r = new InventoryReport();
+            var output = r.GenerateReport();
+            Assert.Contains("InventoryReport", output);
+            Assert.Contains("TotalItems=35", output);
+        }
+    }
+}