Chain of Responsibility Pattern

Introducción

Voy a empezar la entrada describiendo una situación teórica que nos ayudará a comprender mejor el patrón sobre el que voy a hablar en esta entrada.

Imaginemos que ponemos a varias personas en fila.
Esas personas forman parte del sistema o procedimiento.
La responsabilidad de cada una de esas personas es manejar objetos de un color determinado.
Poniéndolos en un orden simbólico RGB (Red-Green-Blue), tenemos que una de esas personas espera objetos rojos, otra verdes, y otra azules en ese orden.
Cuando un objeto verde entra en el sistema, le llega al primer manejador, en nuestro caso el manejador de objetos rojos.
Si el objeto es de color rojo, hará con él lo que tenga que hacer.
Al no ser de color rojo, se lo pasará al siguiente manejador que en nuestro caso será el manejador de los objetos verdes.
Éste manejador verá que es un objeto para él y hará lo que tenga que hacer con él.

Si nuestro proceso no tiene más lógica ni necesita más, circuitará al siguiente manejador y finalizará el proceso de manejadores dándolo por correcto.

Podríamos complicar el proceso y enviarlo al manejador siguiente, pero en esencia, lo que acabo de explicar no es otra cosa que el patrón Chain Reponsibility.

Definición

De acuerdo a lo explicado anteriormente, el patrón de diseño de comportamiento Chain of Reponsibility (cadena de responsabilidades) es un patrón que te permite pasar una petición a lo largo de una cadena de manejadores que decidirán si deben procesar la petición o pasársela al siguiente manejador de la cadena.

El diagrama general del patrón es el que se indica en la siguiente imagen:

Una imagen que describe el funcionamiento del patrón junto con todo lo explicado hasta ahora, es la que se indica a continuación:

Aunque éste es un ejemplo sencillo, podemos tener manejadores de responsabilidad que tratan criterios complejos.

Es decir, este patrón puede responder a diferentes propósitos y puede ofrecernos diferentes soluciones.

Patrón Chain of Responsibility y ASP.NET Core

Ahora bien, si eres programador de ASP.NET Core, quizás te hayas dado cuenta que existen similitud entre el manejo de una petición web que entra en tu aplicación Web o tu Web API y este patrón.

Y haces bien, porque el pipeline o manejador de peticiones recae sobre los middleware de ASP.NET Core que transcurren a través de un Chain of Reponsibility que está basado en él, decidiendo cada manejador qué debe hacer con la petición, pudiendo realizar alguna acción y pasársela al siguiente manejador o corticuitarla.

Ahora bien, ¿podríamos aplicar este patrón en nuestros proyectos?.
Evidentemente sí.

¿Y cómo hacerlo?.

Vamos a ver un ejemplo sencillo.

Chain of Responsibility en C#

Vamos a hacer un ejemplo en C# que nos ayude a comprender mejor este patrón. En este caso, vamos a desarrollar el ejemplo que exponía teóricamente al principio de la entrada y que se basa en gestionar los colores RGB.

• Si entra un color Red, Green o Blue, deberá entrar en el sistema.
• Si entra cualquier otro color, deberíamos rechazar la petición.

Así que con estas premisas, vamos a programar nuestra clase Request.
Esta clase tendrá dos propiedades, un código y un nombre de color.
El nombre de color esperado sería «Red», «Green» o «Blue».

public class Request
{
    public Request(string code, string color)
    {
        Code = code;
        Color = color;
    }

    public string Code { get; set; }
    public string Color { get; set; }
}

Una vez que tenemos preparada la entrada al sistema, vamos a preparar las clases del patrón Chain of Responsibility en sí.

Empezaremos por la base del manejador, formada por una clase abstracta a la que he llamado Handler.
Esta clase como digo, será la que ponga las pautas a seguir por cada manejador.

public abstract class Handler
{
    protected Handler NextHandler;

    public void SetNextHandler(Handler nextHandler)
    {
        NextHandler = nextHandler;
    }

    public abstract void ProcessRequest(Request request);
}

Esta clase abstracta será implementada por cada manejador.

Recordemos que vamos a crear un manejador por cada color RGB.
Empezaremos a manejar una petición (Request) con color Red, y sino es de color Red, pasaremos la petición al manejador de color Green, y así sucesivamente.
Si el manejador último (Blue) no cumple sus premisas, devolveremos un mensaje de error.
En cualquier otro caso, circuitaremos el proceso terminando el flujo y devolveremos un mensaje de finalización correcta.

El flujo normal para este ejemplo será similar al que se indica en la siguiente imagen:

Así que el primer manejador es Red.

public class RedHandler : Handler
{
    public override void ProcessRequest(Request request)
    {
        if (request.Color == "Red")
            Console.WriteLine($"{this.GetType().Name} approved request {request.Code} as {request.Color}");
        else if (NextHandler != null)
            NextHandler.ProcessRequest(request);
    }
}

El siguiente manejador es Green:

public class GreenHandler : Handler
{
    public override void ProcessRequest(Request request)
    {
        if (request.Color == "Green")
            Console.WriteLine($"{this.GetType().Name} approved request {request.Code} as {request.Color}");
        else if (NextHandler != null)
            NextHandler.ProcessRequest(request);
    }
}

y el último Blue:

public class BlueHandler : Handler
{
    public override void ProcessRequest(Request request)
    {
        if (request.Color == "Blue")
            Console.WriteLine($"{this.GetType().Name} approved request {request.Code} as {request.Color}");
        else
            Console.WriteLine($"{this.GetType().Name} denied {request.Code} as {request.Color}");
    }
}

Y lo que nos queda es configurar la cadena de manejadores de acuerdo a lo que hemos preparado anteriormente.

// Setup Chain of Responsibility
Handler redHandler = new RedHandler();
Handler greenHandler = new GreenHandler();
Handler blueHandler = new BlueHandler();

redHandler.SetNextHandler(greenHandler);
greenHandler.SetNextHandler(blueHandler);


// Requests

Request request = null;

request = new Request("001", "Red");
redHandler.ProcessRequest(request);

request = new Request("002", "Green");
redHandler.ProcessRequest(request);

request = new Request("003", "Blue");
redHandler.ProcessRequest(request);

request = new Request("999", "White");
redHandler.ProcessRequest(request);

Como podemos observar en la configuración de nuestra cadena de responsabilidades, hemos declarado cada manejador o Handler (RedHandler, GreenHandler, BlueHandler), y hemos indicado para cada manejador, quién es el siguiene manejador al que se tendrá que llamar en el caso de que el manejador que trata la petición o Request, no sea capaz de procesarla correctamente.

El resultado por pantalla que obtendremos al ejecutar este código será el siguiente:

RedHandler approved request 001 as Red
GreenHandler approved request 002 as Green
BlueHandler approved request 003 as Blue
BlueHandler denied 999 as White

Aunque no es un patrón que se use mucho, sí espero que esta entrada ayude a comprender mejor como funciona para poder usarla correctamente en el caso de que sea necesario hacerlo.

El código fuente del ejemplo de esta entrada lo puedes encontrar aquí:
https://github.com/J0rgeSerran0/ChainOfResponsibilityPattern

Happy Coding!