Mostrando entradas con la etiqueta Arquitectura. Mostrar todas las entradas
Mostrando entradas con la etiqueta Arquitectura. Mostrar todas las entradas

martes, 22 de mayo de 2012

Patrones de diseño: implementando Abstract Factory

Los patrones molan, si sabes cómo usarlos, más.

Hace algún tiempo compramos en la oficina el libro “Patrones de diseño para C#”. Este libro detalla los 23 modelos de diseño fundamentales y aunque aún no he tenido tiempo de leerlo al completo, lo que he visto está bien explicado y es sencillo de entender.

No es mi intención debatir los beneficios que se obtiene al utilizar patrones de diseño, de eso seguro que puedes encontrar muchísima información en miles de blogs.

Sin embargo, si lo que buscas son ejemplos de cómo (pero sobretodo porqué) implementar un patrón de diseño desde cero, ahí amigo, seguro que lo tienes más difícil.

Los ejemplos que yo he encontrado, muchas veces son excesivamente formales, y se centran en explicar el patrón en sí, implementando algún ejemplo concreto sobre la definición formal del patrón.

Mi idea es partir de un escenario en el que el código es correcto, en términos funcionales, pero no es correcto en el sentido de que incumple varios principios SOLID, y además en el momento en el que las especificaciones cambien, va a ser también más complicado de mantener.

Veremos que para optimizar el escenario propuesto, el patrón que mejor encaja es el denominado “Factoría Abstracta”. Trataré de explicar porqué, y reescribiremos el código hasta tener la implementación del patrón completada.

De esta manera, podremos evaluar los beneficios que vamos a obtener al usar la Factoría Abstracta, nuestro código ganará calidad, nosotros algo de ego (no mintáis, malditos geeks!), a partir del momento en el que decidáis incorporar el uso de patrones a vuestros proyectos, miles de gatitos dormirán tranquilos… y a nosotros no nos “sangrarán” los ojos al ver nuestro ahora precioso código.

Bueno, al turrón! y ánimo, que me ha salido un “troncho” de post que no es para unas prisas ;-D

miércoles, 24 de agosto de 2011

Uso de Interfaces en aplicaciones n-capas

 

Hola a todos.

Ayer tuve una discusión sana con mi compañero Sergio (podéis seguir su magnífico blog aquí), acerca de las arquitecturas n-capas, y más concretamente del uso de “interfaces“para la comunicación entre capas.

La discusión giraba en torno a lo que es una “Interfaz”, como concepto,  en el contexto de comunicaciones entre capas. La idea que primero nos viene a la cabeza, es que la interfaz es lo que la capa expone a modo de servicios (métodos y clases públicas) para comunicarse con otras capas.

Y si bien esa idea es completamente correcta y cierta, tenemos que tener en cuenta que las interfaces (entendidas aquí como elementos dentro de una programación orientada a objetos), también nos proporcionan un contrato a cumplir por las clases que las implementen. ejemplos los tenemos a miles (IComparable, IEnumerable, IQueryable, .. y unas cuantas más)

Pues bien, el propósito de este post es mostrar cómo las interfaces nos pueden ayudar a conseguir cierto nivel de desacoplamiento entre capas, con todos los beneficios que eso nos trae: testeabilidad, división de responsabilidades, y otros muchos.

Bueno, vamos al turrón.