¿Si eres un desarrollador.Net ya sabrás que es muy importante escribir un código limpio, eficiente y que pueda mantenerse, entonces te preguntas que son esas buenas prácticas y por qué realmente importan?.
Dos razones de mucho peso:
Además, no solo se trata de escribir código, se trata de que tu código comunica algo, que ese algo se pueda leer, y permita a otros desarrolladores entenderlo, y no solo a otros, sino que para ti mismo también, yo por ejemplo no sé qué comí la semana pasada, hay cosas que mi cerebro no almacena, y si eres como yo, estoy segura de que un código limpio te ayudará más de los crees, porque aunque tú seas el creador de ese código, mañana puede que no te acuerdes de todos los detalles, en realidad un trozo de código no se queda allí y se olvida, sino que va evolucionando conjuntamente con tu aplicación, dicho esto, comencemos:
1. Sigue la convención de nombres
Usa PascalCase para los nombres de las clases, métodos y propiedades públicas, además usa CamelCase para variables locales y parámetros, también recuerda que las propiedades privadas se agrega un guion bajo.
Evita esto:
Mejor esto:
2. Intenta usar nombres más descriptivos
Elige nombres que indiquen con precisión el propósito o funcionalidad de tu código.
Evita esto:
Mejor esto:
3. Mantente actualizado con la última versión de .Net
Actualiza tu proyecto con la última versión de .NET ya sea la versión 6, core o framework porque esto podría optimizar el rendimiento, la seguridad y el mantenimiento de tu aplicación. Recuerda que .NET Framework 4.8 será la última versión, ahora se recomienda por Microsoft actualizar .NET 6 ó 7, entonces .NET Core su última versión ha sido 3.1, y luego cambió a .NET 5 (como una fusion entre framework 4.8 y core 3) es decir que ahora debemos utilizar el .NET (Core) 6 en adelante, como recomendación de sus creadores.
4. Sigue los principios SOLID
¿Está ya la veías venir a que sí? primero que nada recuerda que SOLID son principios (reglas y/o recomendaciones) no es un patrón, la diferencia es que SOLID te da unas pautas a seguir para evitar un mal diseño, la solución puede tener varios caminos, es decir tú lo adaptas a la necesidad del requerimiento, mientras que un patrón te dice exactamente cómo se ha de resolver aquello.
¿Por qué es importante aplicar este principio?
- Facilita los test.
- Reduce el acoplamiento.
- Elimina duplicidades.
- Incrementa la comprensión del código.
- Incrementa su capacidad de extenderse.
4.1 SINGLE RESPONSABILITY
Evita esto:
Mejor esto:
4.2 Open/Close
Evita esto:
Mejor esto:
4.3 Liskov.
Va de esto más o menos:
Veamos algo más o menos situado a la realidad:
Tenemos una clase padre que es hacer una transferencia de dinero y una clase hija que es una transferencia internacional.
Hasta aquí todo bien, vemos que podemos sustituir el padre por el hijo, pero ¿qué pasa si queremos hacer un Bizum(o sea otra hija)?, ya sabemos que este no tiene ningún cobro de comisión.
Al intentar sustituir el padre por el otro hijo que sería el bizum, tenemos un error.
Entonces para hacer cumplir Liskov debemos crear una clase como un segundo padre que herede de MoneyTransfer, ahora tendremos como dos clases padre.
Una de las hijas hereda del padre que más se acople a su necesidad.
Y la otra también.
Ahora sí, podemos hacer sustituciones y no rompemos su funcionamiento 🙂
4.4 Interface Segregation
Evita esto:
Entonces no podemos implementar todos los métodos, así que mejor intenta algo así:
4.5 Dependency Inversion
Evita esto:
Unas de las formas de lograr DIP (Dependency Inversion Principle) es a través de Inyección de Dependencias.
Mejor esto:
5. Implementa un buen manejo de errores
Cuando estés desarrollando, intenta pensar que podría salir mal, eso te llevará a controlar un tipo de error, crea tus propias excepciones para que puedas controlarlas, y evita a medida de lo posible capturar la System.Exception, esa es muy genérica y úsala solo si es estrictamente necesario.
Evita esto:
Mejor esto:
6. Usa async/await:
Tus peticiones serás más eficientes.
Evita esto:
Mejor esto:
7. Crear un sistema de Logs
Te ayudará a identificar y diagnosticar problemas en tu aplicación, intenta registrar solo la información más relevante y evita guardar en log información confidencial.
8. Usa LINQ
Te ayudará a simplificar y comprender más la query.
9. Haz test unitarios y de integración
Las pruebas unitarias demuestran que la lógica de tu código está bien hecha y que funcionará en todos los casos, también sirven como documentación del proyecto.
Los test permiten refactorizar el código más adelante y tener la garantía de que el módulo sigue funcionando correctamente, debes hacer el hábito de realizar pruebas regularmente mientras programas, de lo contrario tendrás más dificultad para encontrar errores, por el contrario, si tiene buena cobertura en tus test será más fácil corregir.
10. Invierte en ti
Y, por último, pero no menos importante invierte en ti, dedica unas horas a la semana a actualizar y mejorar tus conocimientos, tendrás más confianza.
Las habilidades y conocimientos que obtenga te encaminarán hacia el logro de sus objetivos personales y profesionales.
Conclusión
Parece mucha información, pero en realidad no es tanto, ya verás, aplica como minino estos pasos, y tu código será más reutilizable, más limpio, más eficiente, y te hará sentir muy bien al final del día.
Además, no somos perfectos y a lo mejor no siempre escribamos código impecable, pero te servirá para detectar tus fallos y seguir creciendo.
“Truth can only be found in one place: the code.”
― Robert C. Martin, Clean Code: A Handbook of Agile Software Craftsmanship
-Kim M.