Cet article a fait l'objet d'une traduction automatique.

Motifs et méthodes

Vous pouvez exige sur modèles et méthodes

Alex Homer

Contenu

Motifs et méthodes
Un stock généraux
Gestion avec abstraction
Un historique de base de dépendance chez Microsoft
Extension vous-même
Résumé

Écrire du code de l'ordinateur permet de s'avérer très difficile.Lorsque J'AI commencé programmation ordinateurs domestiques plusieurs années que je charge N'oubliez pas, la seule façon de faire un programme à exécuter au plus une analyse desultory consistait à écrire à l'aide de code machine.Même un utilitaire simple traitement peut prendre plusieurs semaines pour créer comme meticulously planifié les allocations de mémoire pour les variables, écrit routines pour effectuer des tâches simples telles que l'entrée de caractères dessin à l'écran et clavier décodage et puis tapé chaque instruction de processeur individuel dans un assembleur.

Aujourd'hui, par comparaison, création de code puissant est facile.Nous prendre pour accordé la multitude d'outils, langages de haut niveau infrastructures de runtime, bibliothèques de code et services système d'exploitation qui permettent de créer des applications rapidement et efficacement.Cependant, lors de la création le code est devenu beaucoup plus facile, la tâche de création d'applications n'a pas.Nous prévoyons beaucoup plus de nos applications modernes que jamais.Il doivent communiquer via des réseaux, interagir avec d'autres applications et services, exposent les interfaces utilisateur hautement interactifs et réactive et prennent en charge multimédia enrichi et les graphiques.Et, bien sûr, qu'ils doivent être robuste, sécurisées, fiables et plus faciles à gérer.

En fait, il serait presque impossible répondre aux exigences demandées de nos applications modernes sans la croissance et évolution de langages de programmation, les systèmes d'exploitation, les services de plate-forme et infrastructures continue.L'augmentation énorme de complexité de ces applications a forcé également nous pour découvrir les méthodes pour simplifier et d'organiser le code.Au fil des années, un nombre de techniques de programmation et la conception essayés et testés ont évolué, tels que componentization, objet-orientation, et, plus récemment, l'orientation de service.

Motifs et méthodes

Alors qu'améliorations dans outils et les infrastructures rendre plus facile à écrire du code plus rapidement et moderne langues et les styles de programmation facilitent écrire du code mieux, la zone un qui a été l'impact de la plupart sur notre capacité à créer des applications au cours 10 à 15 dernières années a été l'évolution et acceptation croissante des modèles de conception logicielle.

Modèles de conception décrivent les problèmes courants qui se produisent à plusieurs reprises dans la conception d'applications et le développement et fournissent des techniques pour traiter ces problèmes.Modèles décrivent également l'exercice de secteur d'activité en cours pour résoudre les problèmes architectes et de gestion de la complexité de conception demandé d'applications.La disposition des éléments de code et de solution est au cœur de conception de logiciels aujourd'hui ; modèles fournissent à nous manières de simplifier et d'organiser ces éléments, offrant la possibilité de meilleure optimiser performance, la flexibilité et facilité de gestion des applications.

Depuis la publication de la loi révolutionnaire par le groupe de quatre, Erich gamma, Richard Helm, Ralph Johnson et John M.Vlissides, modèles de conception : Elements of Reusable Object-Oriented Software (Addison-Wesley, 1996), qui documenté nombreux les modèles de conception de base que nous prendre pour accorder aujourd'hui, le nombre de modèles de conception disponibles pour les développeurs et concepteurs a augmenté à un rythme phenomenal.Presque tous les aspects de la création de logiciels a associé motifs de conception et implémentation, et simplement documenter les a devenir une tâche impossible.Au lieu de cela, concepteurs et développeurs ont tendance à fragmenter en fonctions et découvrez les modèles plus applicables à leur propre zone d'expertise.

Un stock généraux

En 2002, le groupe modèles et méthodes chez Microsoft publié l'architecture de l'application pour .NET : guide de conception d'applications et services, plaçant ensemble l'avis de conseils et spécialiste conception de base pour aider les architectes de créer des applications sur le Microsoft .NET Framework.Toutefois, technologies modifier dans le temps, et pendant que les principes fondamentaux de conception et de décrites dans le guide de développement sont aussi valides aujourd'hui, le guide d'origine n'a pas couvrir certaines des fonctionnalités nouvelles du .NET Framework ou résoudre les problèmes de conception découlant pour nouveaux types d'applications.

Pour les mois dernier plusieurs, une équipe large des spécialistes du secteur d'activité et des experts, dans et en dehors de Microsoft, a été collaboration pour créer une nouvelle version du guide fournit une introduction complète à la conception et la conception des solutions sur le Microsoft .NET Framework.Le guide Microsoft Application Architecture (2nd Edition) décrit haut niveau principes architecturaux et des motifs et penser en cours sur accepté pratiques de conception et de développement.Elle contient également des conseils sur l'application de ces facteurs à des types d'applications spécifiques, et fournit une vue d'ensemble large des nombreux services de plate-forme et bibliothèques de code pour faciliter l'implémentation.

Bien entendu, pour emprunter une expression souvent utilisé, logiciel et système de l'architecture est quelque chose qui met l'accent sur la question de durée de vie, l'univers et tout.Aucune seule composition peut répondre à chaque question possible ou espère que fournir de couverture entièrement complète de chaque scénario possible.Toutefois, le nouveau repère vise à fournir les informations que vous avez besoin si vous sont uniquement des designing.NET applications basées sur Framework, un concepteur expérimenté de déplacement vers le .NET Framework d'une autre plate-forme, un architecte accompli cherchez des informations spécifiques et de conseil, ou simplement souhaite en savoir plus sur les scénarios larges et les opportunités offertes par le .NET Framework.

Gestion avec abstraction

Pour illustrer les pratiques du secteur d'activité, le guide répertorie principes généraux que vous devez appliquer lorsque vous créez presque tout type d'application.Ces principes incluent gestion séparation des problèmes, l'utilisation d'abstraction pour implémenter libre associant entre les couches et composants, les implémenter les fonctionnalités d'emplacement service et Gestion des problèmes crosscutting tels que la journalisation et de sécurité.Il peuvent sembler à but souhaitable mais sans relation, une technique peut vous aider à appliquer facilement plusieurs principes de conception.Le principe d'inversion de dépendance implique la séparation des problèmes par abstractions plutôt que des implémentations concrètes.En termes de modèles de conception, vous pouvez obtenir cela en appliquant le motif d'inversion de contrôle (IoC) et son motif associé, l'injection de dépendance (DI).

La théorie est assez simple.Au lieu de spécifier au moment de la conception le type concret réel chaque classe ou un composant permet d'effectuer certaines activités ou un processus, vous organiser pour ces classes ou les composants pour récupérer l'objet approprié à partir d'un conteneur que vous configuré avec un type de cartes précédemment et enregistré des types.Par exemple, comme illustré dans l'application simple dans la figure 1 , votre composant d'accès aux données peut nécessiter les services d'un composant de journalisation.Comme vous avez correctement abstrait votre code crosscutting du code spécifique des tâches et d'application spécifique, vous devrez peut-être plusieurs composants de la journalisation à partir de laquelle choisir.Peut-être un est conçu pour une utilisation lorsque vous déboguez l'application, un autre pour utilisation lors de l'exécution en interne de l'application sur votre propre réseau, et une troisième plus adaptée à l'exécution d'un système au niveau de l'entreprise qu'utilise un environnement de surveillance, tel que Microsoft System Center.

La figure 1, une application simple qui permet l'utilisation des couches et un séparateur enregistrement composant

Il peut même être le cas que vous avez plusieurs données accès aux composants, chaque conçus pour une utilisation dans un environnement spécifique ou avec un autre type de magasin de données.Par conséquent, votre couche métier devrez choisir le composant de couche données appropriées selon le déploiement en cours ou l'environnement d'exécution.De manière similaire, vous devrez peut-être services que votre application utilise plusieurs fois, tel qu'un message électronique l'envoi de service ou un service de transformation de données.Injection de dépendance peut agir comme une fonction d'emplacement service pour aider votre application récupérer une instance (une nouvelle instance ou une instance existante) du service au moment de l'exécution.

Chacun de ces exemples décrit efficacement une dépendance d'une partie de l'application sur un autre et résolution de ces dépendances d'une façon qui ne pas étroitement couplé les objets est l'objectif du principe Inversion de dépendance.

Un historique de base de dépendance chez Microsoft

Bien que les principes de Inversion de dépendance ont été autour pendant une longue période, les fonctionnalités pour aider les développeurs à implémenter dans les applications s'exécutant sur la plate-forme Microsoft sont relativement récentes.En fait, un article est qu'un développeur éviter que dans le monde Java, lors de visiter le campus Microsoft, remarked que le belief générale était que personne chez Microsoft pourrait Épeler « injection de dépendance ». Lorsque c'est-à-dire sans doute un mythe (Urbain), il est le cas que les outils pour aider les développeurs d'implémenter la plupart des motifs courants n'ont pas été une priorité dans la plupart des zones de la société.

Toutefois, du groupe modèles & méthodes chez Microsoft évidence à notre position unique d'en cours dans la société mais en dehors des équipes de développement produit principal et les divisions.L'objectif de p & p, comme illustré par notre slogan « révélé pratiques pour des résultats prévisibles, » est de fournir aux développeurs des conseils, des outils, bibliothèques, les infrastructures et une multitude d'autres outils pour les aider à concevoir et créer des applications mieux sur la plate-forme Microsoft.Un rapide coup de œil à notrepage d'accueil sur MSDNillustrent la large gamme d'immobilisations que nous fournissons.

Parmi ces éléments sont plusieurs produits qui utilisent du motif injection de dépendance, notamment Enterprise Library, application composite infrastructures et fabriques de logiciels.Est lors du développement de ces actifs, en particulier le d'origine Composite Application Block (CAB), il devenu évident qu'un mécanisme d'injection de dépendance réutilisables et hautement configurable était requis, et l'équipe créé la version originale du Générateur d'objets.

Générateur d'objet est presque entièrement configurable et est maintenant utilisé dans une large gamme de produits dans p & p et un autre emplacement au sein de Microsoft.Toutefois, il est très difficile à utiliser.Il requiert un excellent de paramètres qui prennent les objets complexes, et qu'elle expose un éventail d'événements vous devez gérer pour appliquer la configuration que vous avez besoin.Initiale tente document Générateur d'objets dans le cadre du projet CAB révélé plus rapidement que cela allait être une tâche uphill.En outre, Générateur d'objets a été plutôt plus qu'un conteneur d'injection de dépendance, et il semblait excessif en termes des besoins courants pour implémenter les motifs DI et IoC.

Lors du développement d'Enterprise Library 4.0, Object Builder mis à jour, ne pas pour simplifier il, mais pour rendre plus rapides et plus efficaces.Il a été également affiné pour une utilisation dans le mécanisme de d'injection de dépendance principales premier auprès de Microsoft destinée squarely aux développeurs qui souhaitent mettre en œuvre les modèles DI et IoC.Générateur d'objet est la base Unity, un conteneur d'injection de dépendance léger et extensible qui prend en charge d'injection de constructeur, propriété d'injection et injection d'appel de méthode.

Unity fournit des fonctionnalités pour la création objet simplifié, en particulier pour objet hiérarchique structures et les dépendances ; abstraction des besoins en exécution ou via la configuration ; simplifiée Gestion de crosscutting problèmes ; et une flexibilité augmenté de report de configuration de composant pour le conteneur.Il a une capacité d'emplacement de service et permet aux clients Enregistrer ou mettre en cache le conteneur, même dans les applications Web ASP.NET.

Depuis la sortie de la première version Unity dans 2008 au plus tôt, il a trouvé une maison dans plusieurs p & p immobilisations comme mécanisme par défaut pour l'implémentation Inversion de dépendance.Unity a également continué à évoluer tout en restant descendante ; vous pouvez l'utiliser à activer les fonctionnalités d'Enterprise Library, ainsi que d'utiliser comme conteneur DI autonome.Dans la version plus récente, il propose des outils pour implémenter instance et interception par type (via une extension de plug-in) qui permettent d'implémentations de techniques de programmation orientée aspect telles que stratégie injection.

Unity a généré également d'autres implémentations de conteneur DI destinées à des tâches spécifiques et exigences, telles qu'une implémentation très léger, conçu pour utiliser dans les périphériques mobiles et téléphones actives.En outre, planifiées développements futurs dans le domaine Unity et Enterprise Library comprend des fonctionnalités pour ouvrir Enterprise Library aux autres mécanismes de conteneur tierce partie, tout en offrant des extensions supplémentaires activer les nouvelles fonctionnalités pour Unity.Application de dépendance Inversion

Quitter cet avoir besoin recourir à l'historique et renvoyer l'application hypothétique, comment vous pouvez appliquer le principe d'inversion de dépendance pour atteindre les objectifs, expliqués précédemment, de séparation des problèmes, abstraction et couplage libre ?La réponse est pour configurer un conteneur d'injection de dépendance, comme Unity, avec les types appropriés et tapez mappages et autoriser l'application récupérer et injecter des instances d'objets appropriés au moment de l'exécution.la figure 2 illustre comment vous pouvez utiliser le bloc d'application Unity pour implémenter ce conteneur.Dans ce cas, vous renseigner le conteneur avec des mappages de type entre les définitions d'interface pour les composants de données et composants de connexion et les implémentations concrètes spécifiques de ces interfaces vous souhaitez que l'application à utiliser.

La figure 2 injection de dépendance peut sélectionnez des composants lors de l'exécution en fonction de configuration du conteneur.

Au moment de l'exécution, la couche métier interroge le conteneur pour récupérer une instance du composant de couche données correctes, en fonction de son mappage en cours.La couche de données puis interroge le conteneur pour obtenir une instance du composant journalisation approprié, selon le mappage enregistrée pour ce type d'interface.En guise d'alternative, les données et les composants de la journalisation peuvent héritent des classes de base respectives et des enregistrements dans le conteneur peuvent mapper entre ces types de base et les types concrets héritantes.

Cette approche pilotées par le du conteneur pour résoudre des types et les instances signifie que le développeur est libre de modifier les implémentations pour les données et les composants de journalisation, tant que ces implémentations fournissent la fonctionnalité requise et exposent l'interface appropriée (par exemple, en implémentant l'interface mappé ou hérite de la classe de base mappée).La configuration du conteneur peut être définie dans code lors de l'exécution appliquant méthodes enregistrer types, les mappages de type ou instances existantes des objets du conteneur.Vous pouvez également renseigner le conteneur en chargeant les enregistrements à partir d'une source de configuration ou un fichier, telles que le fichier web.config ou le fichier app.config.

Lorsque vous souhaitez enregistrer plusieurs instances d'un type, vous pouvez utiliser un nom pour définir chacun d'eux et puis résoudre les différents types en spécifiant le nom.L'enregistrement pouvez également spécifier la durée de vie de l'objet, ce qui facilite obtenir des fonctionnalités de localisation style service en enregistrement de l'objet du service comme un singleton ou avec une durée de vie spécifique, telles que par thread.L'exemple de code suivant montre quelques exemples d'enregistrement des mappages de type avec le conteneur :

C#
// Register a mapping for the CustomerService class to the IMyService interface. 
myContainer.RegisterType<IMyService, CustomerService>();

// Register the same mapping using a mapping name. 
myContainer.RegisterType<IMyService, CustomerService>("Data");

// Register the first mapping, but as a singleton. 
myContainer.RegisterType<IMyService, CustomerService>(
                         new ContainerControlledLifetimeManager());

Remarque : les exemples de code référence les classes et types en utilisant le nom de classe. Vous pouvez utiliser les définitions de types alias dans le fichier de configuration alias noms type complet des classes, qui simplifie le conteneur d'enregistrement lorsque vous utilisez un fichier de configuration.

Pour récupérer l'instance d'un objet, vous simplement interroger le conteneur en spécifiant le type, le type d'interface, ou le type de classe de base (et le nom), si vous avez enregistré le type à l'aide d'un nom comme illustré dans l'exemple suivant. Le conteneur résout le type, si elle est enregistrée, crée ou renvoie une instance de l'objet approprié. S'il n'est pas enregistré, le conteneur crée une nouvelle instance de ce type simplement et remet en. Pourquoi souhaitez vous résoudre éléments via le conteneur lorsqu'il n'existe aucun enregistrement pour ce type ? L'idée doit prendre parti des fonctionnalités supplémentaires et très utiles qui Unity et plusieurs autres DI conteneur mécanismes, fournit, la possibilité d'insérer des objets avec constructeur, propriété setter et injection d'appel de méthode.

C#
// Retrieve an instance of the mapped IMyService concrete class. 
IMyService result = myContainer.Resolve<IMyService>();
// Retrieve an instance by specifying the mapping name. 
IMyService result = myContainer.Resolve<IMyService>("Data");

Par exemple, lorsque vous créez une instance d'un objet dans le conteneur, Unity examine les constructeurs et est automatiquement injecter des instances du type approprié dans les paramètres de constructeur. Retourner à notre exemple d'application simple précédent, le composant d'accès aux données peut-être un constructeur qui accepte une référence à un composant de journalisation en tant que paramètre. Si ce type de paramètre est l'interface ou classe de base pour la journalisation composants enregistrés avec le conteneur, Unity invoque résoudre le type mappé, créer une instance et il transmet au constructeur du composant de données (comme illustré dans la figure 3 ). Vous ne rien faire à l'exception de Registre les mappages.

La figure 3 injection d'objets dans les paramètres de constructeur

C#
// In main or startup code:
// Register a mapping for a logging component to the ILogger interface.
// Alternatively, you can specify this mapping in a configuration file. 
myContainer.RegisterType<ILogger, MyLogger>();

...

// In data access component:
// Variable to hold reference to logger.
private ILogger _logger = null;

// Class constructor. Unity will populate the ILogger type parameter.
public DataAccessRoutines(ILogger myLogger)
{
  // store reference to logger
  _logger = myLogger;
  _logger.WriteToLog("Instantiated DataAccessRoutines component");
}

Cela signifie que vous pouvez modifier le type concret réel l'application utilise simplement par la modification de la configuration du conteneur, soit au moment de la conception, à exécuter temps en modifiant la configuration ou dynamiquement en fonction sur une valeur que votre code rassemble à partir de l'environnement et utilise pour créer ou mettre à jour le mappage dans le conteneur. Vous pouvez brancher votre composant de journalisation de débogage lorsque cela est nécessaire ou connectez un nouveau composant de journalisation « super rapide » lorsque vous trouvez que l'ancien est trop lente. Pendant ce temps, l'administrateur système pouvez mettre à jour la configuration que nécessaire pour surveiller, gérer et adapter le comportement de l'application à l'exécution aux environnements de modification de couleur et problèmes opérationnels.

De même, si vous avez une relation entre deux objets, tels que la dépendance d'un affichage sur le présenteur lorsque vous implémentez le motif MVP (modèle-vue-présentateur), vous pouvez utiliser d'injection de dépendance pour diminuer l'association entre ces classes. Suffit de définir une propriété de la classe d'affichage que le présenteur type ou le type de classe de base et marque la propriété avec une dépendance d'attribut, comme illustré dans l'exemple suivant :

C#
// Variable to hold reference to controller.
private IPresenter _presenter;

// Property that exposes the presenter in the view class. Unity will inject 
// this automatically because it carries the Dependency attribute.
 [Dependency]
public IPresenter MyViewPresenter
{
  get { return _presenter; }
  set { _presenter = value; }
} 

Remarque : les attributs sont pour spécifier les propriétés pour injecter rapidement.Si vous ne souhaitez pas utiliser des attributs (pour éviter associant vos classes dans le conteneur) vous pouvez plutôt utiliser un fichier de configuration ou l'API Unity pour spécifier les propriétés qui doivent être injectées.

Lorsque vous créez la vue en résolution par le biais du conteneur, Unity détectera l'attribut de dépendance, automatiquement résoudre une instance de la classe de présenteur concret approprié et définissez-le comme la valeur de cette propriété de la classe Vue.L'exemple de démarrage rapide inclus avec Unity illustre cette approche dans une application Windows Forms.Il résout en fait le formulaire principal de l'application via le conteneur, ce qui provoque Unity créer et remplir plusieurs dépendances dans l'application entière, à l'aide constructeur et propriété accesseur Set injection.

Extension vous-même

Unity fournit une multitude de fonctionnalités DI-liés, mais il est toujours un élément supplémentaire à atteindre.Le défi avec Unity était de conserver suffisamment générique pour satisfaire le nombre maximal d'exigences, tout en étant extensible permettant de vous pouvez l'adapter à vos propres exigences spécifiques.Pour cela en utilisant les extensions conteneur, qui vous permettent de faire presque en termes de gestion de création de l'objet et de récupération.

Par exemple, le démarrage rapide inclus avec Unity illustrent une extension de conteneur qui implémente un mécanisme Publish\Subscribe pilotées par l'attribut simple.Comme Unity crée des instances d'objets, il lie des gestionnaires d'événements pour eux selon les attributs dans les fichiers de classe.Un autre exemple génère des informations détaillées enregistrement tel qu'il crée ou récupère chaque type dans le conteneur, qui vous aide à lors du débogage d'applications complexes.

Cette flexibilité énorme est fourni sur car Unity vous permet d'interagir avec le mécanisme de Générateur d'objets sous-jacent via votre extension de conteneur.Ah, vous pouvez dire, mais Object Builder est extrêmement difficile à utiliser et n'est pas entièrement documentée.En fait, la documentation Unity contiennent des informations sur Générateur d'objets en termes de la façon dont vous interagir avec celle-ci à partir d'une extension de conteneur, et les exemples de démarrage rapide fournissent beaucoup d'exemples de code vous pouvez utiliser et modifier.

Résumé

Il existe de nombreux affichages sur architecture d'application et la conception.Le 42010:2007 standard ISO/IEC/IEEE 1471 « recommandé exercice for Architecture Description de sollicitant beaucoup de logiciels Systems » décrit architecture logicielle comme l'organisation fondamentale d'un système de mises en œuvre dans ses composants, leurs relations entre eux et de l'environnement et les principes guidant sa conception et l'évolution.Toutefois, dans son livre modèles d'application Architecture d'entreprise (Addison-Wesley, 2002), Martin Fowler indique que «.. .in la fin, architecture revient à quel que soit le contenu important, " qui est un moyen beaucoup plus simple de capturer l'image de l'architecture logicielle !

Le guide Microsoft Application Architecture (2nd Edition) vous aideront à comprendre ce que le contenu important est afin que vous pouvez créer mieux, applications de qualité supérieures plus rapidement et plus efficacement.Comme vous l'avez vu dans cet article, une zone spécifique, tirant parti des motifs Inversion de contrôle et injection de dépendance, peut vous aider à atteindre la plupart des objectifs de conception promus par le guide.Cela inclut la séparation des problèmes, l'utilisation d'abstraction pour implémenter la libre association entre les couches, emplacement du service et implémentation de fonctionnalités de gestion améliorée de crosscutting problèmes.

Alex Homer est ingénieur de documentation travailler avec l'équipe motifs et méthodes Microsoft.Son ravings aléatoires sur durée de vie, technologie et le monde en général se trouve àhttps://blogs.msdn.com/alexhomer/ .