Cascade Pattern

A cuantos de nosotros nos tocó alguna vez escribir código como el que vamos a ver a continuación?

public class EmailManager
{
    public string Client { get; set; }
    public string From { get; set; }
    public string To { get; set; }
    public string Subject { get; set; }
    public string Body { get; set; }

    public void Send()
    {
        // Enviar correo...
    }
}

Teniendo la clase EmailManager, la instanciación seria mas o menos de la siguiente forma:

var email = new EmailManager();
email.Client = "client";
email.From = "from@sebys.com.ar";
email.To = "to@sebys.com.ar";
email.Subject = "Envio email";
email.Body = "Este es el contenido del e-mail";

email.Send();

Si prestan atención al código notarán que hay algunas cositas que podríamos mejorar. En primer lugar, vemos que la variable “email” se repite un importante número de veces antes de realizar la acción final, esto nos lleva a pensar que tenemos código redundante que se puede evitar. Por otro lado no queda claro si para realizar un nuevo envío puedo utilizar la instancia ya creada o debería definir una nueva, lo que puede resultar confuso para cualquier desarrollador.

Para resolver esto hagamos algunas pequeñas adaptaciones al código:

public class EmailManager
{
    private string client { get; set; }
    private string from { get; set; }
    private string to { get; set; }
    private string subject { get; set; }
    private string body { get; set; }

    public EmailManager Client(string client)
    {
        this.client = client;
        return this;
    }

    public EmailManager From(string from)
    {
        this.from = from;
        return this;
    }

    public EmailManager To(string to)
    {
        this.to = to;
        return this;
    }

    public EmailManager Subject(string subject)
    {
        this.subject = subject;
        return this;
    }

    public EmailManager Body(string body)
    {
        this.body = body;
        return this;
    }

    public void Send()
    {
        // Enviar correo...
    }
}

Lo que hicimos es agregar a cada propiedad un método que devuelve la instancia del objeto creado, lo que nos permite ir invocando nuevos métodos sin necesidad de escribir una nueva línea.

Veamos como es la nueva forma de instanciarlo:

new EmailManager()
    .Client("client")
    .From("from@sebys.com.ar")
    .To("to@sebys.com.ar")
    .Subject("Envio email")
    .Body("Este es el contenido del e-mail")
    .Send();

Como resultado, se logra eliminar código duplicado logrando más legibilidad y simplicidad de uso.

Algunos frameworks que nos ayudan con esta tarea son FluentValidation y NBuilder. Por último, un patrón alternativo y del que ya habíamos hablado en el post es Fluent Interface.

Espero que les sea de utilidad!

Anuncios