Breaking News: Grepper is joining You.com. Read the official announcement!

chain of responsibility design pattern

Add Answer

Amjad Saeed answered on December 30, 2022 Popularity 9/10 Helpfulness 1/10

answer chain of responsibility design pattern

related What is a Chain of Responsibility pattern? In what scenarios to apply this pattern?

related Chain of Responsibility Pattern

chain of responsibility design pattern

Comment

Chain of Responsibility Pattern:
The Chain of Responsibility pattern allows you to pass requests along a chain of handlers, with each handler having the option to process the request or pass it to the next handler in the chain.

Example in React:
Suppose you have a form in your React application, and you want to validate the input data using a chain of validators.

// Validator functions
const emailValidator = (value) => {
  if (!value.includes('@')) {
    return 'Email is invalid';
  }
  return null;
};

const passwordValidator = (value) => {
  if (value.length < 8) {
    return 'Password must be at least 8 characters long';
  }
  return null;
};

// Chain of Responsibility
function validateInput(value, validators) {
  for (const validator of validators) {
    const result = validator(value);
    if (result !== null) {
      return result;
    }
  }
  return null;
}

// Usage
const input = 'example.com';
const validators = [emailValidator, passwordValidator];
const validationError = validateInput(input, validators);
console.log(validationError); // 'Email is invalid'

Popularity 9/10 Helpfulness 1/10 Language javascript

Source: Grepper

Tags: chain-of-responsibility javascript

Link to this answer
Share Copy Link

Contributed on Sep 09 2023

Amjad Saeed

0 Answers Avg Quality 2/10

Closely Related Answers

What is a Chain of Responsibility pattern? In what scenarios to apply this pattern?

Comment

Chain of Responsibility belongs to the category of a behavioural design pattern that passes requests via a chain of handlers.
Whenever a request is received, the handler decides whether to process the request or pass it to the next handler of the chain. 
It is used for achieving loose coupling where the client request is passed through an object chain to process them.

Client: This is the point of request origination and the component that accesses the handler for handling the request.
Handler: Handler can either be a class or an interface that received the request primarily and dispatches it to the chain of handlers. 
This Handler knows only the first handler of the chain.
Concrete Handlers: These are the actual request handlers in sequential order.
This pattern can be used in the following cases:

Whenever we want to decouple the sender and the receiver of the request.
Whenever we want multiple objects to handle a request at runtime.
Whenever we do not want to explicitly specify handlers in the code.
Whenever we want to issue a request to several objects without explicitly specifying handlers

Popularity 10/10 Helpfulness 3/10 Language whatever

Source: Grepper

Tags: apply appl

Link to this answer
Share Copy Link

Contributed on Dec 30 2022

Deepika Sahu

0 Answers Avg Quality 2/10

Chain of Responsibility Pattern

Comment

using System;

// Handler interface
public interface IHandler
{
    IHandler SetNext(IHandler handler);
    void Handle(Request request);
}

// ConcreteHandler classes
public class ConcreteHandlerA : IHandler
{
    private IHandler nextHandler;

    public IHandler SetNext(IHandler handler)
    {
        nextHandler = handler;
        return handler;
    }

    public void Handle(Request request)
    {
        if (request.Value < 10)
        {
            Console.WriteLine("ConcreteHandlerA handled the request.");
        }
        else if (nextHandler != null)
        {
            Console.WriteLine("ConcreteHandlerA passed the request to the next handler.");
            nextHandler.Handle(request);
        }
        else
        {
            Console.WriteLine("No handler can process the request.");
        }
    }
}

public class ConcreteHandlerB : IHandler
{
    private IHandler nextHandler;

    public IHandler SetNext(IHandler handler)
    {
        nextHandler = handler;
        return handler;
    }

    public void Handle(Request request)
    {
        if (request.Value >= 10 && request.Value < 20)
        {
            Console.WriteLine("ConcreteHandlerB handled the request.");
        }
        else if (nextHandler != null)
        {
            Console.WriteLine("ConcreteHandlerB passed the request to the next handler.");
            nextHandler.Handle(request);
        }
        else
        {
            Console.WriteLine("No handler can process the request.");
        }
    }
}

// Request class
public class Request
{
    public int Value { get; }

    public Request(int value)
    {
        Value = value;
    }
}

class Program
{
    static void Main()
    {
        // Client code
        IHandler handlerA = new ConcreteHandlerA();
        IHandler handlerB = new ConcreteHandlerB();

        handlerA.SetNext(handlerB);

        // Sending requests to the chain
        handlerA.Handle(new Request(5));
        handlerA.Handle(new Request(15));
        handlerA.Handle(new Request(25));

        /*
         * Sample Output:
         * ConcreteHandlerA handled the request.
         * ConcreteHandlerB handled the request.
         * No handler can process the request.
         */
    }
}

Popularity 9/10 Helpfulness 1/10 Language csharp

Source: chat.openai.com

Tags: c# c

Link to this answer
Share Copy Link

Contributed on Jul 31 2023

mahnaz foroutan

0 Answers Avg Quality 2/10

chain of responsibility design pattern

Contents

More Related Answers

chain of responsibility design pattern

Closely Related Answers

What is a Chain of Responsibility pattern? In what scenarios to apply this pattern?

Chain of Responsibility Pattern

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.