Jorge Marquez Jose Gomez

Je vous laisse, j'ai fait une présentation sur l'architecture MVC est une explication très conceptuel et au-dessus, mais assez à mon avis,
à être compris que l'architecture.
Profitez-en!

Architecture MVC

Un modèle de fabrique sert à canaliser toutes les créations d'objets en un seul point. Ceci est utile pour la conception robuste de notre système et de s'adapter aux changements.

Le modèle de fabrique peut être combiné avec le pattern singleton car il est plus confortable à utiliser et la forme utile d'utiliser. Dans cet exemple nous allons mettre une usine sans singleton.

Pour dire le modèle d'usine est des modèles créationnelles, ce type de modèle qui fait abstraction de la manière de créer des objets concrets, donnant ainsi un soutien pour créer des objets dans l'abstrait.

Pour démarrer un modèle de fabrique consiste à effectuer:
- Une fonction ou une méthode qui est responsable de la création d'objets d'un type donné.
- Il n'est pas obligatoire mais recommandé que la fonction ou la méthode retourne une abstraction (interface ou classe abstraite).

Imaginez un magasin de pizza nécessite un logiciel dont vous avez besoin d'avoir un certain nombre de produits (pizzas variées). En tant que concepteurs, nous sommes bien, la création d'objets pizza peut être fait à partir de n'importe où dans le projet, mais le problème c'est qu'il ya de nombreux types de pizzas. Pour créer chaque pizza pour chaque type dans différentes parties du programme serait la première chose que vous pourriez penser, mais ... si, au lieu que nous utilisons le bon sens et d'appliquer l'usine?, Cela nous permettrait aussi d'un nouveau produit ou un changement de l'un d'eux que le changement à un seul endroit, en prenant plus contrôlé ce code. Même si vous vous rendez compte de la vitesse de changement est beaucoup plus pour aller changer toutes les apparences possibles de nos pizzas par le code.
Eh bien, l'usine serait responsable de la création de toutes sortes de pizzas et d'offrir tous les points possibles du programme.

Notre exemple serait:

- Le IPizza interface:

     IPizza l'interface
     {
         Nulle WhoAmI ();
     }

- Les pizzas individuelles:

     public class PizzaBarbacoa: IPizza
     {
         Membres de la région # IPizza

         public void WhoAmI ()
         {
             Console.WriteLine ("Je suis une pizza barbecue");
         }

         # Endregion
     }

     public class PizzaMargarita: IPizza
     {
         Membres de la région # IPizza

         public void WhoAmI ()
         {
             Console.WriteLine ("Je suis un Margarita pizza");
         }

         # Endregion
     }

     public class PizzaPepperoni: IPizza
     {
         Membres de la région # IPizza

         public void WhoAmI ()
         {
             Console.WriteLine ("Je suis un pizza au pepperoni");
         }

         # Endregion
     }

- L'usine en question:

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

         IPizza publique getPizza (type tipoPizza)
         {
             Interrupteur (Type)
             {
                 cas tipoPizza.Barbacoa:
                     return new PizzaBarbacoa ();
                     break;
                 cas tipoPizza.Margarita:
                     return new PizzaMargarita ();
                     break;
                 cas tipoPizza.Pepperoni:
                     return new PizzaPepperoni ();
                     break;
                 par défaut:
                     return new PizzaBarbacoa ();
             }
         }
     }

- Un petit test:

     Test de la classe publique
     {
         public void testPizza ()
         {
             / / Exemple ne pas utiliser l'usine
             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 d'utilisation de l'usine
             PizzaFactory PizzaFactory usine = 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 ();
         }
     }

Comme vous pouvez voir comment utiliser et ses avantages sont une meilleure. J'espère que vous aimez!. Rendez-vous plus tard!

Eh bien, après ma léthargie (désolé de ne pas poster plus tôt, mais l'université, je ténia a submergé), je vais parler de quelques modèles de conception. NET.

Mais d'abord un peu "l'histoire":

Les design patterns sont utilisés pour diverses choses, (tiré de wikipedia):
* Fournir des catalogues d'éléments réutilisables dans la conception de systèmes logiciels.
* Pour éviter les répétitions dans la recherche de solutions aux problèmes connus et résolus avant.
* Formaliser un vocabulaire commun entre les concepteurs.
* Normaliser le mode de conception est réalisée.
* Faciliter l'apprentissage de nouvelles générations de créateurs de condensation des connaissances existantes.

Et comme on dit dans wikipedia n'a pas l'intention d'imposer quoi que ce soit et d'en abuser peut-être une erreur.

Eh bien nous allons voir quelques modèles. NET.

Patron singulier (Singleton):
Ce modèle assure qu'il n'y a qu'une seule instance par classe en évitant la consommation excessive de ressources ou d'accès incompatibles. Ses utilisations peuvent être plusieurs, y compris l'accès à des paramètres globaux, l'exploitation forestière, etc ..
Le régime général est le suivant:

  PatronSingular Public Class
  Privé Partagé en tant que instanciaUnica PatronSingular

  Private Sub New ()
  'Le constructeur privé à créer la classe de l'instance
  End Sub

  Public Function partagée getInstance () As PatronSingular
  «Contrôle de la création d'objets de la classe elle-même.
  Is Nothing Then If instanciaUnica
  Nouveau PatronSingular instanciaUnica = ()
  End If
  Retour instanciaUnica
  End Function
 End Class 

Un modèle Singleton son constructeur devrait être privé de la classe est de contrôler leur propre création et en est responsable. Nous devons créer une méthode, qui est généralement appelé "getInstance ()" qui retourne cette instance de classe à utiliser.

Pattern Décorateur (Decorator):
Il fait "wrapper" des objets, dans une définition formelle de ce qu'il ne figure une fonctionnalité à des objets qui héritent d'elle et donc attribuer la responsabilité. En bref, nous donne la capacité de générer des classes avec des fonctions qui sont générées dynamiquement. Il ya de nombreux exemples de ce type. NET, y compris la gestion des fichiers (FileStream votre décorateur est Stream). Comparé à Java, ce qui correspondrait à des classes abstraites. Exemple:

  Public Class MustInherit PatronDecorador
  «Il offre une fonctionnalité de base pour tous les enfants, mais
  «Cela fonctionne différemment:
  «Par exemple:
  «Le chocolat sera tarifée différemment et la description
  «Beurre, mais les deux peuvent fondre!.
  Prix ​​Public MustOverride Function () As Double
  Description de la fonction publique MustOverride () As Double

  Melt Fonction publique () As Boolean
  «Faire fondre
  Retour Vrai
  End Function

  «Elle oblige leurs enfants à être instancié dans une manière particulière
  Public Sub New (ByVal ModificadorAcceso As String)
  End Sub
 End Class

 Chocolat Public Class
  Inherits PatronDecorador

  Description Public Overrides Function () As Double
  Retour "Chocolate"
  End Function

  Prix ​​Public Overrides Function () As Double
  10,2 Retour
  End Function

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

 Beurre Public Class
  Inherits PatronDecorador

  Description Public Overrides Function () As Double
  Retour "Beurre"
  End Function

  Prix ​​Public Overrides Function () As Double
  3.6 Retour
  End Function

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

Eh bien, je l'espère à écrire plus souvent, mais le temps m'a noyé!, Dans un autre article, je décrirai le modèle de stratégie, les adaptateurs et les observateurs. Salutations!