Jorge Marquez Jose Gomez

Vi lascio ho fatto una presentazione su architettura MVC è una spiegazione molto concettuale e, soprattutto, ma abbastanza a mio parere
deve comprendere che l'architettura.
Buon divertimento!

Architettura MVC

Un modello di fabbrica serve a incanalare tutte le creazioni di oggetti in un unico punto. Questo è utile per la progettazione robusta del nostro sistema e reagire al cambiamento.

Il modello fabbrica può essere combinato con il pattern singleton come è più comodo da usare e forma utile utilizzare. In questo esempio, metteremo una fabbrica senza singleton.

A dire il modello di fabbrica è dei modelli creativi, questo tipo di modello che astrae il modo per creare oggetti concreti, dando così sostegno alla creazione di oggetti in astratto.

Per avviare un modello di fabbrica è da eseguire:
- Una funzione o metodo, che è responsabile della creazione di oggetti di un determinato tipo.
- Non è obbligatorio ma consigliato che la funzione o il metodo restituisce un astrazione (interfaccia o classe astratta).

Immaginate un negozio di pizza richiede un software è necessario disporre di una serie di prodotti (pizze varia). Come designer siamo buoni, la creazione di oggetti pizza può essere fatto da qualsiasi punto del progetto, ma il problema è che ci sono molti tipi di pizze. Per creare ogni pizza per ogni tipo in diverse parti del programma sarebbe la prima cosa che si potrebbe pensare, ma ... se invece usiamo il buon senso e applicare la fabbrica?, Questo ci permetterebbe, come un nuovo prodotto o un cambiamento in nessuno di essi che il cambiamento in un solo luogo, prendendo più controllato questo codice. Anche se vi rendete conto la velocità del cambiamento è molto più di andare cambiare tutte le possibili aspetti delle nostre pizze dal codice.
Beh, la fabbrica sarebbe responsabile della creazione di tutti i tipi di pizze e di offrire tutti i possibili punti del programma.

Il nostro esempio potrebbe essere:

- Il IPizza interfaccia:

     IPizza interfaccia
     {
         Whoami void ();
     }

- Le pizze individuali:

     public class PizzaBarbacoa: IPizza
     {
         # Membri Regione IPizza

         public void Whoami ()
         {
             Console.WriteLine ("Sono una pizza barbecue");
         }

         # Endregion
     }

     public class PizzaMargarita: IPizza
     {
         # Membri Regione IPizza

         public void Whoami ()
         {
             Console.WriteLine ("Io sono un Margarita pizza");
         }

         # Endregion
     }

     public class PizzaPepperoni: IPizza {# membri regione public void IPizza whoami () {Console.WriteLine ("Io sono un pepperoni pizza");}} # endregion 

- L'impianto in questione:

     public class PizzaFactory
     {
         public enum tipoPizza
         {
             Pepperoni, Margherita, Barbeque
         }

         IPizza pubblico getPizza (tipo tipoPizza)
         {
             switch (tipo)
             {
                 tipoPizza.Barbacoa caso:
                     restituire nuova PizzaBarbacoa ();
                     break;
                 tipoPizza.Margarita caso:
                     restituire nuova PizzaMargarita ();
                     break;
                 tipoPizza.Pepperoni caso:
                     restituire nuova PizzaPepperoni ();
                     break;
                 default:
                     restituire nuova PizzaBarbacoa ();
             }
         }
     }

- Un piccolo test:

     classe Test pubblico testPizza {public void () {/ / ad esempio non usare factory PizzaBarbacoa IPizza pizza1 = new (); pizza1.quienSoy (); IPizza PizzaMargarita pizza2 = new (); pizza2.quienSoy (); IPizza PizzaPepperoni pizza3 = new ( ) pizza3.quienSoy (); IPizza PizzaBarbacoa pizza4 = new (); pizza4.quienSoy (); IPizza PizzaMargarita pizza5 = new (); pizza5.quienSoy () / / esempio di utilizzo di fabbrica di fabbriche PizzaFactory PizzaFactory = new (); 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 ();}} 

Come si può vedere come utilizzare e dei suoi vantaggi sono migliori. Spero che vi piaccia!. Ci vediamo più tardi!

Beh, dopo la mia letargia (non dispiace distacco prima, ma l'ho universitaria tenia ha travolto), parlerò di alcuni design pattern. NET.

Ma prima un po 'di "storia":

Modelli di progettazione vengono utilizzati per varie cose, (tratto da wikipedia):
* Fornire cataloghi di elementi riutilizzabili nella progettazione di sistemi software.
* Per evitare il ripetersi nella ricerca di soluzioni ai problemi noti e risolti prima.
* Formalizzare un vocabolario comune tra i progettisti.
* Standardizzare modalità viene eseguita progettazione.
* Agevolare l'apprendimento delle nuove generazioni di designer a condensazione conoscenze esistenti.

E come si dice in wikipedia non intende imporre nulla e abusare di loro può essere un errore.

Beh vediamo alcuni modelli. NET.

Patron Singular (Singleton):
Questo modello assicura che ci sia una sola istanza per ogni classe di evitare un consumo eccessivo di risorse o l'accesso incoerente. I suoi usi possono essere molteplici, compreso l'accesso alle impostazioni globali, logging, ecc ..
Lo schema generale è:

  Public Class PatronSingular
  Shared Private instanciaUnica PatronSingular

  Private Sub New ()
  'Costruttore privato per creare classe dell'istanza
  End Sub

  Public Shared Function getInstance () As PatronSingular
  'Controllare la creazione di oggetti della classe stessa.
  Is Nothing Then Se instanciaUnica
  New PatronSingular instanciaUnica = ()
  End If
  Torna instanciaUnica
  End Function
 End Class 

Un pattern Singleton il costruttore dovrebbe essere privata alla classe è quello di controllare la propria creazione e ne è responsabile. Dobbiamo creare un metodo, che di solito è chiamato "getInstance ()" che restituisce l'istanza della classe da utilizzare.

Decorator modello (Decorator):
Rende "wrapper" gli oggetti, in una definizione formale di ciò che si è impostata una funzionalità agli oggetti che ereditano da essa e quindi assegnare le responsabilità. In breve, ci dà la capacità di generare le classi con le funzioni che vengono generate in modo dinamico. Ci sono molti esempi di questo tipo. NET, compresa la gestione dei file (FileStream il decoratore è Stream). Rispetto a Java, ciò corrisponderebbe a classi astratte. Esempio:

 Public MustInherit PatronDecorador Class 'offre una funzionalità di base per tutti i suoi figli, ma' che funzionano in modo diverso, 'per esempio:' Cioccolato avrà un prezzo e una descrizione diversa 'di burro, ma entrambi possono sciogliersi!.  Prezzo al pubblico MustOverride Function () As Double Descrizione Public MustOverride Function () As Double Public Function Melt () As Forze Boolean 'vero ritorno Melt End Function' che i loro figli devono essere istanziati in modo particolare Public Sub New (ByVal ModificadorAcceso As String) End Sub End Class Public Class Inherits Chocolate PatronDecorador Overrides Public Function Description () As Double Return Prezzo Function "Chocolate" End Function Public Overrides () As restituire il doppio di 10,2 End Function Public Sub New (ByVal param As String) MyBase.New (param) End Sub End Class Public Class Inherits Butter PatronDecorador Overrides Public Function Description () As Double Return Prezzo Funzione "Butter" End Function Public Overrides () As restituire il doppio di 3,6 End Function Public Sub New (ByVal param As String) MyBase.New (param) End Sub End Class 

Beh, spero di scrivere più spesso, ma il tempo mi ha annegato!, In un altro articolo mi limiterò a descrivere il modello di strategia, gli adattatori e gli osservatori. Saluti!