Add Chain of Responsibility pattern implementation

Implemented the Chain of Responsibility design pattern with new
classes: `Handler`, `LevelOneHandler`, `LevelTwoHandler`,
`DefaultHandler`, and `Request` in the `DesignPatterns.Chain`
namespace.

Updated `Program.cs` to include a demo showcasing the pattern.
Modified `README.md` to document the pattern, its purpose,
example usage, and test references.

Added `ChainTests` to verify the behavior of the pattern,
ensuring proper handling of requests by different handlers.
Integrated the pattern without affecting existing functionality.

Author: froghramar

DesignPatterns/Chain/DefaultHandler.cs

@@ -0,0 +1,9 @@
+namespace DesignPatterns.Chain;
+
+public sealed class DefaultHandler : Handler
+{
+    public override string Handle(Request request)
+    {
+        return $"Default handled: {request.Message}";
+    }
+}

DesignPatterns/Chain/Handler.cs

@@ -0,0 +1,18 @@
+namespace DesignPatterns.Chain;
+
+public abstract class Handler
+{
+    protected Handler? Next { get; private set; }
+
+    public Handler SetNext(Handler next)
+    {
+        Next = next;
+        return next;
+    }
+
+    public virtual string Handle(Request request)
+    {
+        if (Next != null) return Next.Handle(request);
+        return "Unhandled";
+    }
+}

DesignPatterns/Chain/LevelOneHandler.cs

@@ -0,0 +1,10 @@
+namespace DesignPatterns.Chain;
+
+public sealed class LevelOneHandler : Handler
+{
+    public override string Handle(Request request)
+    {
+        if (request.Level == 1) return $"LevelOne handled: {request.Message}";
+        return base.Handle(request);
+    }
+}

DesignPatterns/Chain/LevelTwoHandler.cs

@@ -0,0 +1,10 @@
+namespace DesignPatterns.Chain;
+
+public sealed class LevelTwoHandler : Handler
+{
+    public override string Handle(Request request)
+    {
+        if (request.Level == 2) return $"LevelTwo handled: {request.Message}";
+        return base.Handle(request);
+    }
+}

DesignPatterns/Chain/Request.cs

@@ -0,0 +1,13 @@
+namespace DesignPatterns.Chain;
+
+public sealed class Request
+{
+    public int Level { get; }
+    public string Message { get; }
+
+    public Request(int level, string message)
+    {
+        Level = level;
+        Message = message ?? string.Empty;
+    }
+}

DesignPatterns/Program.cs

@@ -10,6 +10,7 @@
 using DesignPatterns.Facade;
 using DesignPatterns.Flyweight;
 using DesignPatterns.Proxy;
+using DesignPatterns.Chain;
 
 Console.WriteLine("Factory pattern demo:");
 
@@ -95,7 +96,19 @@
 nested.Add(child);
 nested.Add(new CircleGraphic());
 Console.WriteLine(nested.Draw());
-;
+
+
+// Chain of Responsibility demo
+Console.WriteLine();
+Console.WriteLine("Chain of Responsibility pattern demo:");
+var h1 = new LevelOneHandler();
+var h2 = new LevelTwoHandler();
+var def = new DefaultHandler();
+h1.SetNext(h2).SetNext(def);
+
+Console.WriteLine(h1.Handle(new Request(1, "r1")));
+Console.WriteLine(h1.Handle(new Request(2, "r2")));
+Console.WriteLine(h1.Handle(new Request(99, "r3")));
 
 // Decorator demo
 Console.WriteLine();

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, and Proxy patterns.
+- `DesignPatterns` - Console demo showing Factory, Singleton, Builder, Prototype, Abstract Factory, Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy, and Chain of Responsibility patterns.
   - Factory implementation: `DesignPatterns/Factories`
   - Singleton implementation: `DesignPatterns/Singleton/Logger.cs`
   - Builder implementation: `DesignPatterns/Builder/HouseBuilder.cs` and `DesignPatterns/Builder/House.cs`
@@ -16,6 +16,7 @@ Projects
   - Facade implementation: `DesignPatterns/Facade/*`
   - Flyweight implementation: `DesignPatterns/Flyweight/*`
   - Proxy implementation: `DesignPatterns/Proxy/*`
+  - Chain of Responsibility implementation: `DesignPatterns/Chain/*`
 - `Tests` - xUnit tests covering the examples.
 
 Included patterns and brief docs
@@ -157,6 +158,21 @@ Included patterns and brief docs
     img.Display(); // reuses loaded image
     ```
 
+- Chain of Responsibility Pattern
+  - Purpose: Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request. Chain the receiving objects and pass the request along the chain until an object handles it.
+  - Example: `DesignPatterns/Chain/*` contains handlers `LevelOneHandler`, `LevelTwoHandler`, and `DefaultHandler` that process requests of different levels.
+  - Usage snippet:
+
+    ```csharp
+    var h1 = new LevelOneHandler();
+    var h2 = new LevelTwoHandler();
+    var def = new DefaultHandler();
+    h1.SetNext(h2).SetNext(def);
+    Console.WriteLine(h1.Handle(new Request(1, "r1")));
+    Console.WriteLine(h1.Handle(new Request(2, "r2")));
+    Console.WriteLine(h1.Handle(new Request(99, "r3")));
+    ```
+
 Tests
 - Tests are written with xUnit in the `Tests` project.
   - Factory tests: `Tests/ShapeFactoryTests.cs`
@@ -171,6 +187,7 @@ Tests
   - Facade tests: `Tests/FacadeTests.cs`
   - Flyweight tests: `Tests/FlyweightTests.cs`
   - Proxy tests: `Tests/ProxyTests.cs`
+  - Chain tests: `Tests/ChainTests.cs`
 
 Common commands
 - Build solution: `dotnet build`

Tests/ChainTests.cs

@@ -0,0 +1,23 @@
+using DesignPatterns.Chain;
+
+namespace Tests;
+
+public class ChainTests
+{
+    [Fact]
+    public void Chain_HandlesLevelOneAndTwoAndDefault()
+    {
+        var h1 = new LevelOneHandler();
+        var h2 = new LevelTwoHandler();
+        var def = new DefaultHandler();
+        h1.SetNext(h2).SetNext(def);
+
+        var r1 = new Request(1, "r1");
+        var r2 = new Request(2, "r2");
+        var r3 = new Request(99, "r3");
+
+        Assert.Equal("LevelOne handled: r1", h1.Handle(r1));
+        Assert.Equal("LevelTwo handled: r2", h1.Handle(r2));
+        Assert.Equal("Default handled: r3", h1.Handle(r3));
+    }
+}