José Jorge Márquez Gómez

Us deixo una presentació que vaig fer sobre arquitectura MVC, és una explicació molt conceptual i per sobre però prou al meu entendre
perquè s'entengui aquesta arquitectura.
Que la gaudiu!

Arquitectura MVC

Un patró factoria ens serveix per canalitzar totes les creacions d'objectes en un sol punt. Això és útil per a un disseny robust del nostre sistema i àgil al canvi.

El patró factoria es pot combinar amb el patró Singleton ja que és més còmode el seu ús i útil la seva forma d'utilitzar. En aquest exemple posarem un factoria sense Singleton.

Dir que el patró factoria és del tipus patrons creacionals, que aquest tipus de patró abstreu la manera de crear objectes concrets, donant així un suport per crear objectes de forma abstracta.

Per començar un patró factoria ha de complir:
- Una funció o mètode el qual s'encarrega de crear objectes d'un tipus donat.
- No és obligatori però si recomanable que aquesta funció o mètode retorni una abstracció (interfície o classe abstracta).

Imaginem que una botiga de pizzes requereix d'un programari que necessita que tinguin una sèrie de productes (pizzes variades). Com a bons dissenyadors que som, la creació d'objectes de pizzes es podrà fer des de qualsevol part el projecte, però el problema és que hi ha molts tipus de pizzes. El crear cada pizza de cada tipus en diferents punts del programa seria el primer que pensaríem, però ... si en comptes d'això fem servir sentit comú i apliquem el factoria?, Això ens permetria que donat un nou producte o un canvi en algun d'ells , que només canviem en un sol lloc, tenint més controlat aquest codi. Fins i tot si us adoneu l'agilitat al canvi és molt més gran que anar canviant totes les possibles aparicions de les nostres pizzes pel codi.
Doncs bé, el factoria s'encarregaria de crear tot tipus de pizzes i les oferiria a tots els possibles punts del programa.

El nostre exemple seria el següent:

- La interfície IPizza:

     interfície IPizza
     {
         void quienSoy ();
     }

- Les pizzes concretes:

     public class PizzaBarbacoa: IPizza
     {
         # Region Membres de IPizza

         public void quienSoy ()
         {
             Console.WriteLine ("Sóc una pizza de Barbacoa");
         }

         # Endregion
     }

     public class PizzaMargarita: IPizza
     {
         # Region Membres de IPizza

         public void quienSoy ()
         {
             Console.WriteLine ("Sóc una pizza de Margarida");
         }

         # Endregion
     }

     public class PizzaPepperoni: IPizza
     {
         # Region Membres de IPizza

         public void quienSoy ()
         {
             Console.WriteLine ("Sóc una pizza de Pepperoni");
         }

         # Endregion
     }

- La factoria en qüestió:

     public class PizzaFactory
     {
         public enum tipoPizza
         {
             Pepperoni, Margarita, Barbacoa
         }

         public IPizza getPizza (tipoPizza tipus)
         {
             switch (tipus)
             {
                 case tipoPizza.Barbacoa:
                     return new PizzaBarbacoa ();
                     break;
                 case tipoPizza.Margarita:
                     return new PizzaMargarita ();
                     break;
                 case tipoPizza.Pepperoni:
                     return new PizzaPepperoni ();
                     break;
                 default:
                     return new PizzaBarbacoa ();
             }
         }
     }

- Un petit test:

     public class Test
     {
         public void testPizza ()
         {
             / / Exemple no usant factoria
             IPizza pizza1 = new PizzaBarbacoa ();
             pizza1.quienSoy ();
             IPizza pizza2 = new PizzaMargarita ();
             pizza2.quienSoy ();
             IPizza pizza3 = new PizzaPepperoni ();
             pizza3.quienSoy ();
             IPizza pizza4 = new PizzaBarbacoa ();
             pizza4.quienSoy ();
             IPizza pizza5 = new PizzaMargarita ();
             pizza5.quienSoy ();

             / / Exemple usant factoria
             PizzaFactory factory = new PizzaFactory ();
             IPizza pizza6 = factory.getPizza (PizzaFactory.tipoPizza.Barbacoa);
             pizza6.quienSoy ();
             IPizza pizza7 = factory.getPizza (PizzaFactory.tipoPizza.Margarita);
             pizza7.quienSoy ();
             IPizza pizza8 = factory.getPizza (PizzaFactory.tipoPizza.Pepperoni);
             pizza8.quienSoy ();
         }
     }

Com veieu la forma d'ús i els seus avantatges són millors. Espero que us serveixi!!. Fins ara!

Bé, després de la meva letargia (sento molt no postejar abans, però la universitat em tenia té aclaparat), vaig a parlar d'alguns patrons de disseny sobre. NET.

Però abans una mica de "història":

Els patrons de disseny serveixen per a diverses coses, (extret de wikipedia):
* Proporcionar catàlegs d'elements reusables en el disseny de sistemes programari.
* Evitar la reiteració en la recerca de solucions a problemes ja coneguts i solucionats anteriorment.
* Formalitzar un vocabulari comú entre dissenyadors.
* Estandarditzar la manera com es realitza el disseny.
* Facilitar l'aprenentatge de les noves generacions de dissenyadors condensant coneixement ja existent.

I com bé diuen en wikipedia no pretenen imposar res i abusar dels mateixos pot ser un error.

Bé vegem alguns patrons en. NET.

Patro Singular (Singleton):
Aquest patró ens assegura que només hi hagi una instància per classe evitant així consums excessius de recursos o accessos inconsistents. Els seus usos poden ser diversos, entre ells l'accés a configuracions globals, de logging, etc ..
L'esquema general seria:

  Public Class PatronSingular
  Private Shared instanciaUnica As PatronSingular

  Private Sub New ()
  'Constructor privat per generar la instància la pròpia classe
  End Sub

  Public Shared Function getInstance () As PatronSingular
  'Controlem la creació d'objectes des de la pròpia classe.
  If instanciaUnica Is Nothing Then
  instanciaUnica = New PatronSingular ()
  End If
  Return instanciaUnica
  End Function
 End Class 

Un patró Singleton seu constructor ha de ser privat perquè sigui la classe la controli la seva pròpia creació i sigui responsable d'aquesta. Hem de crear un mètode, que normalment es diu "getInstance ()" que ens retorna aquesta instància de classe per al seu ús.

Patró decorador (Decorator):
Ens fa de "embolcall" d'objectes, en una definició formal el que fa és definir una funcionalitat als objectes que s'heretin d'aquest i assignar així una responsabilitat. En resum, ens dóna la possibilitat de generar classes amb funcions que es generin dinàmicament. Hi ha molts exemples d'aquest tipus a. NET, entre ells els de maneig de fitxers (FileStream seva decorador és Stream). En comparació amb JAVA, això correspondria a les classes abstractes. Exemple:

  Public MustInherit Class PatronDecorador
  'Ofereix una funcionalitat base per a tots els seus fills però
  'Que funcionin de manera diferent:
  'Per exemple:
  'Xocolata tindrà un preu i una descripció diferent que
  'La mantega, però tots dos es poden fondre!.
  Public MustOverride Function Preu () As Double
  Public MustOverride Function Descripció () As Double

  Public Function Fondre () As Boolean
  'Fondre
  Return True
  End Function

  'Obliga que els seus fills s'hagin instanciar d'una forma concreta
  Public Sub New (ByVal ModificadorAcceso As String)
  End Sub
 End Class

 Public Class Xocolata
  Inherits PatronDecorador

  Public Overrides Function Descripció () As Double
  Return "Xocolata"
  End Function

  Public Overrides Function Preu () As Double
  Return 10/02
  End Function

  Public Sub New (ByVal param As String)
  MyBase.New (param)
  End Sub
 End Class

 Public Class Mantega
  Inherits PatronDecorador

  Public Overrides Function Descripció () As Double
  Return "Mantega"
  End Function

  Public Overrides Function Preu () As Double
  Return 3/6
  End Function

  Public Sub New (ByVal param As String)
  MyBase.New (param)
  End Sub
 End Class 

Bé, espero escriure més sovint, però el temps em té ofegat!!, En un altre article intentaré descriure els patrons estratègia, adaptadors i observadors. Salutacions!