Estoy leyendo sobre olores comunes de códigos en el libro Refactoring de Martin Fowler . En ese contexto, me preguntaba acerca de un patrón que estoy viendo en una base de código, y si uno podría considerarlo objetivamente un antipatrón.
El patrón es uno donde se pasa un objeto como argumento a uno o más métodos, todos los cuales cambian el estado del objeto, pero ninguno de los cuales devuelve el objeto. Por lo tanto, depende del paso por naturaleza de referencia de (en este caso) C # /. NET.
var something = new Thing();
// ...
Foo(something);
int result = Bar(something, 42);
Baz(something);
Encuentro que (especialmente cuando los métodos no se nombran adecuadamente) necesito investigar dichos métodos para comprender si el estado del objeto ha cambiado. Hace que la comprensión del código sea más compleja, ya que necesito rastrear múltiples niveles de la pila de llamadas.
Me gustaría proponer mejorar dicho código para devolver otro objeto (clonado) con el nuevo estado, o cualquier cosa que sea necesaria para cambiar el objeto en el sitio de la llamada.
var something1 = new Thing();
// ...
// Let's return a new instance of Thing
var something2 = Foo(something1);
// Let's use out param to 'return' other info about the operation
int result;
var something3 = Bar(something2, out result);
// If necessary, let's capture and make explicit complex changes
var changes = Baz(something3)
something3.Apply(changes);
Para mí, parece que el primer patrón se elige en los supuestos
- que es menos trabajo o requiere menos líneas de código
- que nos permite cambiar el objeto y devolver otra información
- que es más eficiente ya que tenemos menos casos de
Thing
.
Ilustra una alternativa, pero para proponerla, uno necesita tener argumentos en contra de la solución original. ¿Qué argumentos, si hay alguno, se pueden hacer para argumentar que la solución original es un antipatrón?
¿Y qué, si hay algo, está mal con mi solución alternativa?