Using the C# Chain of Responsibility Pattern

A behavioral design pattern called the Chain of Responsibility (CoR) pattern enables an object to forward a request to a series of possible handlers until the request is fulfilled. By allowing the sender of a request to be unsure of which object will handle it, this pattern encourages loose coupling and permits dynamic and flexible request handling.

The Chain of Responsibility Pattern: Why Use It?

Separating the Sender and Receiver: A request’s sender is not required to know which handler will handle it.
Flexibility: Handlers can be dynamically added or withdrawn.
Separation of Concerns: Various issues or stages in the handling of requests are contained within distinct handler classes.
Accountability Sharing: Redundancy and fault tolerance are provided by many objects handling the same request.

Real-World Illustration

Consider a customer care system where requests from customers (such as questions, concerns, or comments) must be handled. Depending on the type of request, several departments including Customer Support, Technical Support, and Management may handle it. This kind of system can be implemented using the Chain of Responsibility pattern.
Application in C#

public class CustomerRequest
{
    public string RequestType { get; set; }
    public string Description { get; set; }
    public CustomerRequest(string requestType, string description)
    {
        RequestType = requestType;
        Description = description;
    }
}

Step 2. Define the Handler Interface

Next, we define an abstract handler class with a method to handle the request and a reference to the next handler in the chain.

public abstract class RequestHandler
{
    protected RequestHandler NextHandler;
    public void SetNextHandler(RequestHandler nextHandler)
    {
        NextHandler = nextHandler;
    }
    public abstract void HandleRequest(CustomerRequest request);
}

Step 3. Implement Concrete Handlers

We create concrete handlers for different types of requests. Each handler will process the request if it can, or pass it to the next handler in the chain if it cannot.

public class CustomerSupportHandler : RequestHandler
{
    public override void HandleRequest(CustomerRequest request)
    {
        if (request.RequestType == "Customer Support")
        {
            Console.WriteLine($"Customer Support: Handling request - {request.Description}");
        }
        else if (NextHandler != null)
        {
            NextHandler.HandleRequest(request);
        }
    }
}
public class TechnicalSupportHandler : RequestHandler
{
    public override void HandleRequest(CustomerRequest request)
    {
        if (request.RequestType == "Technical Support")
        {
            Console.WriteLine($"Technical Support: Handling request - {request.Description}");
        }
        else if (NextHandler != null)
        {
            NextHandler.HandleRequest(request);
        }
    }
}
public class ManagementHandler : RequestHandler
{
    public override void HandleRequest(CustomerRequest request)
    {
        if (request.RequestType == "Management")
        {
            Console.WriteLine($"Management: Handling request - {request.Description}");
        }
        else if (NextHandler != null)
        {
            NextHandler.HandleRequest(request);
        }
    }
}

Step 4. Set Up the Chain of Responsibility

We create the chain of handlers and pass a request through the chain.

class Program
{
    static void Main(string[] args)
    {
        // Create handlers
        var customerSupport = new CustomerSupportHandler();
        var technicalSupport = new TechnicalSupportHandler();
        var management = new ManagementHandler();

        // Set up the chain
        customerSupport.SetNextHandler(technicalSupport);
        technicalSupport.SetNextHandler(management);

        // Create requests
        var request1 = new CustomerRequest("Customer Support", "Need help with my account.");
        var request2 = new CustomerRequest("Technical Support", "Having trouble with the website.");
        var request3 = new CustomerRequest("Management", "Feedback about service quality.");

        // Pass requests through the chain
        customerSupport.HandleRequest(request1);
        customerSupport.HandleRequest(request2);
        customerSupport.HandleRequest(request3);
    }
}

Explanation

• Request Class: CustomerRequest represents a customer request with a type and description.
• Handler Interface: RequestHandler is an abstract class with a method to handle requests and a reference to the next handler.
• Concrete Handlers: CustomerSupportHandler, TechnicalSupportHandler, and ManagementHandler are concrete implementations that process specific types of requests.
• Setting Up the Chain: Handlers are linked together to form a chain. Requests are passed through the chain, starting from the first handler.

Output

When the program runs, it will produce the following output.

Customer Support: Handling request - Need help with my account.
Technical Support: Handling request - Having trouble with the website.
Management: Handling request - Feedback about service quality.

Conclusion

The Chain of Responsibility pattern is a powerful tool for handling requests in a flexible and decoupled manner. By using this pattern, you can create a system where multiple handlers can process a request, and the sender does not need to know which handler will ultimately handle it. This promotes separation of concerns and makes the system easier to maintain and extend. In our example, we demonstrated how to implement the Chain of Responsibility pattern in C# for a customer service request handling system.

Best ASP.NET 9.0 Core Hosting

The feature and reliability are the most important things when choosing a good ASP.NET Core hosting. HostForLIFE is the leading provider of Windows hosting and affordable ASP.NET Core , their servers are optimized for PHP web applications such as the latest ASP.NET Core version. The performance and the uptime of the ASP.NET Core  hosting service are excellent, and the features of the web hosting plan are even greater than what many hosting providers ask you to pay for. At HostForLIFEASP.NET, customers can also experience fast ASP.NET Core hosting. The company invested a lot of money to ensure the best and fastest performance of the datacenters, servers, network and other facilities. Its data centers are equipped with top equipment like cooling system, fire detection, high-speed Internet connection, and so on. That is why HostForLIFEASP.NET guarantees 99.9% uptime for ASP.NET Core . And the engineers do regular maintenance and monitoring works to assure its ASP.NET Core  hosting are security and always up.