Principio de Responsabilidad simple (Single Responsibility)

Continuando el post anterior en el cual vimos los principios SOLID, quisiera hoy en este artículo hablar sobre el principio de Responsabilidad simple (Single Responsability término en inglés).

¿Qué es el principio de responsabilidad simple?

Este principio trata de destinar cada clase a una finalidad sencilla y concreta. En muchas ocasiones estamos tentados a poner un método reutilizable que no tiene nada que ver con la clase, simplemente porque lo utiliza y nos viene bien implementarlo ahi. Pensamos “Ya que estamos en esta clase y lo va usar para que voy a crear una clase para realizar esto”. Y directamente lo colocamos en la clase.

El problema surge cuando tenemos la necesidad de utilizar ese mismo método desde otra clase. Si no se refactoriza en ese momento y se crea una clase destinada para la finalidad del método, nos toparemos a largo plazo con que las clases realizan tareas que no deberían ser de su responsabilidad.

¿Cómo podemos alcanzar el principio de Responsabilidad Simple en C# ?

Veremos un ejemplo sencillo para poder entender como ponemos en práctica este principio.

Como comentábamos anteriormente, cada clase debe tener una sola responsabilidad, por lo tanto no debería ser multitarea. Imaginemos que estamos desarrollando un sistema para un banco, y en nuestro servicio queremos saber por ejemplo si un cliente puede pagar sus deudas.

Como vemos en el código anterior, el usuario desea saber si dispone de dinero en el banco para poder realizar el pago de sus deudas.

¿ Cuál es el problema ?

Lo que vemos en el ejemplo anterior es que hemos combinado dos responsabilidades y esto va a ser mas complejo de mantener o escalar. El método de verificar si tiene el dinero suficiente en el banco es otra responsabilidad, no le pertenece directamente al usuario porque posiblemente queramos usar esa lógica en otro  lugar y vamos a tener que copiar/pegar código más adelante.  Veremos a continuación como refactorizar este código.

Rafactorizando el código

Moviendo la responsabilidad de verificación de dinero a otra clase y dejando solo la responsabilidad de pagar deudas en nuestro código de UserService, logramos alcanzar implementar el principio de responsabilidad simple. De esta manera podemos hacer muchas mejoras a nuestro código de BankService sin tener que tocar la clase UserService.

Bueno hasta aquí el principio de responsabilidad simple. Recordemos que si no utilizamos este principio en nuestras clases y agregamos multiples responsabilidades dentro de una sola, podemos tener las siguientes desventajas:

1.Dificultad de entender la clase
2. Difícil de hacer un test
3. Mucha chance de duplicar la lógica en otras partes de la aplicación.

En el próximo artículo, escribiré sobre el principio de abierto/cerrado (Open-closed Principle término en inglés) el cual lo veremos con un ejemplo. En este artículo he tratado de explicar el principio de responsabilidad simple con un ejemplo en C#. Y lo importante de este principio y la necesidad de su uso en nuestros desarrollos de software. Cualquier comentario o duda, puede dejarlo aquí debajo y no vemos en el próximo artículo !!.

The following two tabs change content below.
Admin

Admin

Administrador de Dotnetuy, con más de 20 años de experiencia en el mundo de la informática y el desarrollo de software en diferentes lenguajes, trabajando en backend y frontend, desde sus primeros pasos con clipper cuando comenzaba la década de los 90’s , y continuando con pascal, C, C++, Visual basic, y multiples gestores de bases de datos hasta hoy en día con C# y todas las técnologias relacionadas con .NET.

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *