Cuánto menos sepamos, mejor

Por Luis Gabriel Rodríguez Alejos

En nuestro día a día ayudando a nuestros clientes, nos encontramos con código poco sostenible. En LeanMind estamos enfocados en mejorar la forma en la que se hace código de una forma mucho más sostenible.

El acoplamiento es uno de los principios que menos se tienen en cuenta a la hora de programar y cuando somos conscientes de ello, es demasiado tarde.

Decimos que un código es de calidad, cuando es fácil de cambiar. Tener un código fuertemente acoplado, significa que es complicado cambiarlo, porque los elementos que no están relacionados entre sí, están estrechamente ligados. Podemos leer más sobre acoplamiento en el siguiente enlace

Partiendo de la idea anterior, los métodos privados tienen que saber lo mínimo imprescindible para poder trabajar. Generalmente los métodos saben demasiadas cosas de los datos con los que trabajan. Por lo tanto, estamos incrementando el acoplamiento entre dos clases, que no tienen que conocerse tan íntimamente.

Como podemos ver en el siguiente código. Tenemos una clase UserSignUpService que se encarga de dar de alta a un nuevo usuario. Para ello tenemos la clase UserSingUpArgs, que contiene los datos de ese nuevo usuario. Pero antes de dar de alta, necesitamos comprobar que ese usuario no se encuentre en el sistema, que es la responsabilidad del método Exist de la interfaz IUserRepository.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

public class UserSignUpService {

	private readonly IUserRepository userRepository;

	public UserService(IUserRepository userRepository) {
		this.userRepository = userRepository;
	}

	public void SignUp(UserSignUpArgs args) {
		if (Exist(args))
			throw new ArgumentException();
	}

	private bool Exist(UserSignUpArgs args) {
		return userRepository.Exist(args.Email);
	}
}

public class UserSignUpArgs {

	public string Email { get; }

	public string Password { get; }

	public UserSignUpArgs(string email, string password) {
		Email = email;
		Password = password;
	}
}

public interface IUserRepository {
	bool Exist(string email); 
}

Como podemos observar existe un acoplamiento entre el método Exist y el objeto UserSignUpArgs, porque ese método no tiene que conocer que la clase UserSignUpArgs tiene una propiedad que se llama Email. Para reducir el acoplamiento entre estos dos elementos, decrementaría el nivel de conocimiento del método Exist de la siguiente manera:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

public class UserService {

	private readonly IUserRepository userRepository;

	public UserService(IUserRepository userRepository) {
		this.userRepository = userRepository;
	}

	public void SignUp(UserSignUpArgs args) {
		if (Exist(args.Email))
			throw new ArgumentException();
	}

	private bool Exist(string email) {
		return userRepository.Exist(email);
        }
}

De esta forma, los métodos sólo saben de los datos con los que tienen que trabajar.

Conclusión:

Como hemos visto, es una pequeña mejora en el código que parece que no aporta nada, pero repetida en el tiempo, obtenemos un código mucho menos acoplado, más fácil de cambiar y mucho más sostenible.

Espero que te haya sido de utilidad

Happy Coding!!!