Partager via

Fonctionnement du code DSL

  • Article

Une solution de langage (DSL) spécifique génère une API que vous pouvez utiliser pour lire et mettre à jour des instances du domaine (dans Visual Studio.Cette API est définie dans le code généré à partir de la définition de langage spécifique à un domaine.Cette rubrique décrit l'API générée.

La solution de l'exemple : diagrammes de composant

Pour créer la solution qui est la source de la plupart des exemples de cette rubrique, créez un DÉSOLÉ du modèle de solution de modèles composants .C'est l'un des modèles standard qui s'affiche lorsque vous créez une solution DÉSOLÉ.

[!REMARQUE]

Le modèle des diagrammes de composant DÉSOLÉ n'est pas lié aux diagrammes de composants UML que vous pouvez créer à l'aide de le menu d'architecture dans Visual Studio Ultimate.Dans la boîte de dialogue de Nouveau projet , développez L'autre projet types \Extensibility puis cliquez sur Concepteur de langage spécifique au domaine.

Appuyez sur F5 et expérience, si vous n'êtes pas familiarisé avec ce modèle de solution.Notez en particulier que vous créez des ports en faisant glisser un outil de port sur un composant, que vous pouvez connecter les ports.

Composants et ports interconnectés

La structure de la solution DÉSOLÉ

Le projet d' Dsl définit l'API de votre DÉSOLÉ.Le projet d' DslPackage définit la façon dont elle s'intègre à Visual Studio.Vous pouvez également ajouter vos propres projets, qui peuvent également contenir le code généré du modèle.

Bb286947.collapse_all(fr-fr,VS.110).gifles répertoires de code

La majeure partie du code dans chacun de ces projets est générée à partir de Dsl\DslDefinition.dsl.Le code généré se trouve dans le dossier d' Generated Code .Pour consulter un fichier généré, cliquez sur [+] en regard de le fichier générer d' .tt .

Nous vous recommandons de inspectez le code généré pour vous aider à comprendre le langage spécifique à un domaine.Pour consulter les fichiers générés, développez l'explorateur de fichiers de *.tt de solutions.

Les fichiers de *.tt contiennent le code de génération très petit.À la place, elles utilisent les directives d' <#include> pour inclure les fichiers modèles partagés.L'à fichiers partagés peut être trouvé dans \Program Files\Microsoft Visual Studio 10.0\Common7\IDE\Extensions\Microsoft\DSL SDK\DSL Designer\11.0\TextTemplates

Lorsque vous ajoutez votre propre code de programme à la solution DÉSOLÉ, ajoutez -la dans un fichier séparé, en dehors de le dossier de code généré.Vous pouvez créer un dossier d' Custom Code .(Lorsque vous ajoutez un nouveau fichier de code à un dossier personnalisé, n'oubliez pas de corriger l'espace de noms dans la structure initiale de code.)

Nous vous recommandons vivement de ne pas modifier le code généré directement, parce que vos modifications seront perdues lorsque vous régénérez la solution.À la place, pour personnaliser votre DÉSOLÉ :

  • Ajustez les nombreux paramètres dans la définition de langage spécifique à un domaine.

  • Entrez les classes partielles dans des fichiers séparés de code, pour remplacer les méthodes qui sont définies dans, ou hérité par, les classes générées.Dans certains cas, vous devez définir l'option de génère double dérivé d'une classe dans la définition DÉSOLÉ, afin de pouvoir substituer une méthode générée.

  • Définissez les options dans la définition de langage spécifique à un domaine qui font pour fournir le code généré en « raccordements » pour votre propre code.

    Par exemple, si vous définissez l'option d' A un constructeur personnalisé d'une classe de domaine, générez la solution, des messages d'erreur.Lorsque vous double-cliquez sur un de ces messages d'erreur, les commentaires dans le code généré qui expliquent ce que votre code personnalisé doit fournir.

  • Écrivez vos propres modèles de texte pour générer du code spécifique à votre application.Vous pouvez utiliser des fichiers Include pour partager des parties des modèles communs à de nombreux projets, et vous pouvez créer des modèles de projet de Visual Studio aux projets d'installation qui sont initialisés avec votre propre structure de fichiers.

Fichiers générés dans le langage DÉSOLÉ

les fichiers générés suivants apparaissent dans le projet d' Dsl .

Nom du fichier

Description

YourDslSchema.xsd

Le schéma des fichiers qui contient des instances de votre DÉSOLÉ.Ce fichier est copié dans le répertoire de compilation (bin).Lorsque vous installez votre DÉSOLÉ, vous pouvez copier ce fichier à \Program Files\Microsoft Visual Studio 11.0\Xml\Schemas afin que les fichiers de modèle puissent être validés.Pour plus d'informations, consultez Déploiement de solutions de langage spécifique à un domaine.

Si vous personnalisez la sérialisation en définissant des options dans l'explorateur DÉSOLÉ, le schéma change en conséquence.Toutefois, si vous écrivez votre propre code de sérialisation, ce fichier ne peut plus représenter le schéma réel.Pour plus d'informations, consultez Personnalisation du stockage de fichiers et de la sérialisation XML.

ConnectionBuilders.cs

un générateur de connexion est une classe qui crée des relations.Voici le code derrière un outil de connexion.ce fichier contient une paire de classes pour chaque outil de connexion.Leurs noms sont dérivées des noms du domaine relation et de l'outil de connexion : concepteur de relation, et ConnectorToolConnectAction.

(Dans l'exemple composant de solution, l'un des générateurs de connexion est appelé ConnectionBuilder, cela est une coïncidence, étant donné que la relation de domaine est nommée Connexion.)

la relation est créée dans la méthode de relationBuilder.Connect() .La version par défaut vérifie que les éléments de modèle source et cible sont acceptables, puis instancie la relation.Par exemple :

CommentReferencesSubject(sourceAccepted, targetAccepted);

Chaque classe de concepteur est générée à partir d'un nœud dans la section de générateurs de connexion dans l'explorateur DÉSOLÉ.Une méthode d' Connect peut créer des relations entre une ou plusieurs paires de classes de domaine.Chaque paire est définie par un lien connecte la directive, qui se trouve dans l'explorateur DÉSOLÉ sous le nœud du concepteur.

Par exemple, vous pouvez ajouter à un concepteur de connexion que le lien connectent des directives pour les trois types de relations dans l'exemple DÉSOLÉ.Cela fournit à l'utilisateur un seul outil de connexion.Le type de relation instancié dépend des types d'éléments de source et cible sélectionné par l'utilisateur.Pour ajouter le lien connectez les directives, cliquez avec le bouton droit sur un concepteur dans l'explorateur DÉSOLÉ.

Pour écrire du code personnalisé qu'un type spécifique de relation de domaine est créé, sélectionnez le lien approprié connectent la directive sous le nœud du concepteur.Dans la fenêtre Propriétés, affectez Le personnalisé en charge se connectent.Régénérez la solution, puis fournissez le code pour corriger les erreurs résultante.

Pour écrire du code personnalisé qui s'exécute chaque fois que l'utilisateur utilise cet outil de connexion, affectez à la propriété d' est personnalisé de connexion.Vous pouvez écrire du code qui détermine si un élément source est autorisé, si une combinaison spécifique de source et cible est autorisée, et ce qui met à jour doit être effectuée sur le modèle lorsqu'un rapport est généré.Par exemple, vous pourriez permettre une connexion uniquement si elle ne créent pas de boucle dans le diagramme.Au lieu d'un seul lien de relation, vous pouvez instancier un modèle plus complexe de plusieurs éléments en corrélation entre la source et la cible.

Connectors.cs

Contient des classes pour les connecteurs, qui sont des éléments de diagramme qui représentent généralement des relations de référence.Chaque classe est générée à partir d'un connecteur dans la définition de langage spécifique à un domaine.chaque classe de connecteur est dérivée d' BinaryLinkShape

Pour que la couleur et une autre variable de fonctionnalités de style au moment de l'exécution, cliquez avec le bouton droit sur la classe du diagramme et le point de définition DÉSOLÉ à ajoutez exposé.

Pour que la variable de fonctionnalités supplémentaires de style au moment de l'exécution, consultez par exemple TextField et l' ShapeElement.

Diagram.cs

contient la classe qui définit le diagramme.il est dérivé d' Diagram.

Pour que la couleur et une autre variable de fonctionnalités de style au moment de l'exécution, cliquez avec le bouton droit sur la classe du diagramme et le point de définition DÉSOLÉ à ajoutez exposé.

En outre, ce fichier contient la règle d' FixupDiagram , qui répond lorsqu'un nouvel élément est ajouté au modèle.la règle ajoute une nouvelle forme et lie la forme à l'élément de modèle.

DirectiveProcessor.cs

Ce processeur de directive aide les utilisateurs à créer des modèles de texte qui indiquent une instance de votre DÉSOLÉ.Le processeur de directive charge les assemblys (DLL) de votre DÉSOLÉ, puis insère efficacement les instructions d' using pour votre espace de noms.Cela permet au code dans les modèles de texte pour utiliser les classes et les relations que vous avez définis dans votre DÉSOLÉ.

Pour plus d'informations, consultez Génération de code à partir d'un langage spécifique à un domaine et Création de processeurs de directives de modèles de texte T4 personnalisés.

DomainClasses.cs

Implémentations des classes de domaine que vous avez définies, y compris les classes abstraites et la classe racine modèle.ils sont dérivés d' ModelElement.

chaque classe de domaine contient :

  • une définition de propriété et une classe imbriquée de gestionnaire pour chaque propriété de domaine.vous pouvez substituer OnValueChanging() et OnValueChanged().Pour plus d'informations, consultez Gestionnaire de modification de la valeur de propriété du domaine.

    Dans l'exemple DÉSOLÉ, la classe d' Comment contient une propriété Text et une classe TextPropertyHandlerde gestionnaire.

  • propriétés d'accès pour les relations auxquelles cette classe de domaine participe.(Il n'y a aucune classe imbriquée pour le rôle de propriétés.)

    Dans l'exemple DÉSOLÉ, la classe d' Comment a les accesseurs qui accèdent à son modèle de parent via la relation ComponentModelHasCommentsd'incorporation.

  • constructeurs.si vous souhaitez substituer ces derniers, définissez A un constructeur personnalisé sur la classe de domaine.

  • Méthodes de groupe gestionnaire de prototype (EGP) d'élément.Ce sont nécessaires si l'utilisateur peut fusionner (ajouter) un autre élément sur des instances de cette classe.En général l'utilisateur effectue ceci en faisant glisser d'un outil ou les autres d'élément forme, ou collant.

    Dans l'exemple DÉSOLÉ, un port d'entrée ou le port de sortie peut être fusionné sur un composant.En outre, les composants et les commentaires peuvent être fusionnés sur le modèle.La méthode

    Les méthodes de gestionnaire d'EGP dans la classe Component permettent à un composant pour recevoir des ports, mais pas aux commentaires.Le gestionnaire d'EGP dans la classe de modèle racine reçoit des commentaires et des composants, mais pas se déplace.

DomainModel.cs

la classe qui représente le modèle de domaine.il est dérivé d' DomainModel.

RemarqueRemarque
Ce n'est pas identique à la classe racine du modèle.

Les clôtures de copie et de suppression définissent ce que d'autres éléments doivent être inclus lorsqu'un élément est copié ou supprimé.vous pouvez contrôler ce comportement en définissant les propriétés de copie de propagations et de suppression de propagations des rôles sur chaque côté de chaque relation.Si vous souhaitez les valeurs à déterminer dynamiquement, vous pouvez écrire du code pour substituer les méthodes des classes de fermeture.Pour plus d'informations, consultez Comment : programmer le comportement de la commande copier-coller - redirection.

DomainModelResx.resx

Cela comprend les chaînes telles que les descriptions des classes et des propriétés de domaine, les noms de propriété, les noms de boîte à outils, des messages d'erreur standard, et d'autres chaînes qui peuvent être affichées à l'utilisateur.Il contient également des icônes et les images d'outil pour les formes d'image.

Ce fichier est lié dans l'assembly généré, et fournit des valeurs par défaut de ces ressources.Vous pouvez localiser votre DÉSOLÉ en créant un assembly satellite contenant une version localisée des ressources.Cette version est utilisée lorsque le langage DÉSOLÉ est installé dans une culture correspondant à des ressources localisées.Pour plus d'informations, consultez Déploiement de solutions de langage spécifique à un domaine.

DomainRelationships.cs

chaque lien entre deux éléments dans un modèle est représenté par une instance d'une classe de relation de domaine.toutes les classes de relation sont dérivées d' lElementLink, qui est ensuite dérivé d' ModelElement.Comme il s'agit d'un ModelElement, une instance d'une relation peut avoir des propriétés et peut être la source ou la cible de la relation.

HelpKeywordHelper.cs

Fournit les fonctions utilisées lorsque l'utilisateur appuie sur F1.

MultiplicityValidation.cs

Dans les rôles de relation dans lequel vous spécifiez une multiplicité de 1..1 ou 1. *, l'utilisateur doit être prévenu qu'au moins une instance de la relation est requise.Ce fichier fournit des contraintes de validation qui implémentent ces avertissements.le lien 1..1 vers un parent d'incorporation n'est pas vérifié.

Pour ces contraintes seront effectuées, vous devez avoir défini une des options d' Utilise… dans le nœud de éditeur \Validation dans l'explorateur DÉSOLÉ.Pour plus d'informations, consultez Validation dans un langage spécifique à un domaine.

PropertiesGrid.cs

Ce fichier contient le code uniquement si vous avez attaché un descripteur de type personnalisé à une propriété de domaine.Pour plus d'informations, consultez Personnalisation de la fenêtre Propriétés.

SerializationHelper.cs

Serializer.cs

Une classe de sérialiseur de chaque classe, relation, la forme, connecteur, diagramme, et modèle de domaine.

Plusieurs fonctionnalités de ces classes peuvent être contrôlées par les paramètres dans l'explorateur DÉSOLÉ sous Comportement de sérialisation XML.

Shapes.cs

Une classe pour chaque classe de forme dans la définition de langage spécifique à un domaine.les formes sont dérivées d' NodeShape.Pour plus d'informations, consultez Personnalisation du stockage de fichiers et de la sérialisation XML.

Pour substituer les méthodes générées avec vos propres méthodes dans une classe partielle, définissez génère double dérivé pour le connecteur dans la définition de langage spécifique à un domaine.Pour remplacer un constructeur par votre propre code, affectez A un constructeur personnalisé.

Pour que la couleur et une autre variable de fonctionnalités de style au moment de l'exécution, cliquez avec le bouton droit sur la classe du diagramme et le point de définition DÉSOLÉ à ajoutez exposé.

Pour que la variable de fonctionnalités supplémentaires de style au moment de l'exécution, consultez par exemple TextField et l' ShapeElement

ToolboxHelper.cs

Crée la boîte à outils en installant les prototypes de groupe d'éléments dans des outils d'élément.Des copies de ces prototypes sont fusionnées avec les éléments cibles lorsque l'utilisateur exécute l'outil.

Vous pouvez substituer CreateElementPrototype() pour définir un élément de boîte à outils qui crée un groupe de plusieurs objets.Par exemple, vous pouvez définir un élément pour représenter les objets qui ont des sous-composants.Après avoir modifié le code, réinitialisez l'instance expérimentale de Visual Studio pour effacer le cache de boîte à outils.

fichiers générés dans le projet de DslPackage

DslPackage associe le modèle DÉSOLÉ au shell de Visual Studio , la gestion de la fenêtre, la boîte à outils, et les commandes de menu.La plupart des classes sont dérivées double, afin que vous puissiez substituer chacune de leurs méthodes.

Nom du fichier

Description

CommandSet.cs

Les commandes de menu contextuel qui sont visibles dans le diagramme.Vous pouvez recevoir ou ajouter à ce groupe.Ce fichier contient le code pour les commandes.L'emplacement des commandes dans les menus est déterminé par le fichier de Commands.vsct.Pour plus d'informations, consultez Écriture de commandes et d'actions utilisateur.

Constants.cs

GUID.

DocData.cs

YourDslDocData gère le chargement et d'enregistrement un modèle au fichier, et crée l'instance de le magasin.

Par exemple, si vous souhaitez enregistrer votre DÉSOLÉ dans une base de données au lieu d'un fichier, vous pouvez substituer Load et des méthodes d' Save .

DocView.cs

YourDslDocView gère la fenêtre dans laquelle le diagramme s'affiche.Par exemple, vous pouvez inclure le diagramme à l'intérieur d'un formulaire windows :

ajoutez un fichier de contrôle utilisateur au projet de DslPackage.Ajouter un panneau auquel le diagramme peut afficher.Ajoutez des boutons et d'autres contrôles.En mode Code du formulaire, ajoutez le code suivant, l'ajustement des étiquettes à votre DÉSOLÉ :

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using Microsoft.VisualStudio.Modeling;
using Microsoft.VisualStudio.Modeling.Shell;
namespace Company.EmbedInForm
{
  public partial class UserControl1 : UserControl
  {
    public UserControl1()
    {
      InitializeComponent();
    }
    
    private DiagramDocView docView;
    public UserControl1(DiagramDocView docView, Control content)
      : this()
    {
      this.docView = docView;
      panel1.Controls.Add(content);
    }
    private void button1_Click(object sender, EventArgs e)
    {
      ExampleModel modelRoot = this.docView.CurrentDiagram.ModelElement as ExampleModel;
      foreach (ExampleElement element in modelRoot.Elements)
      {
       listBox1.Items.Add(element.Name);
      }
    }
  }
  internal partial class EmbedInFormDocView
  {
    private ContainerControl container;
    /// <summary>
    /// Return a User Control instead of the DSL window. 
    /// The user control will contain the DSL window.
    /// </summary>
    public override System.Windows.Forms.IWin32Window Window
    {
      get
      {
        if (container == null)
        {
          // Put the normal DSL Window inside our control
          container = new UserControl1(this, (Control)base.Window);
        }
        return container;
      }
    }
  }
}

EditorFactory.cs

instanciés DocData et DocView.Il accomplit une interface standard que Visual Studio utilise pour ouvrir un éditeur lorsque votre package DÉSOLÉ démarre.il est référencé dans l'attribut d' ProvideEditorFactory dans Package.cs

GeneratedVSCT.vsct

Localise les commandes de menu standard dans les menus, tels que le menu contextuel de diagramme, le menu Edition, et ainsi de suite.Le code des commandes est dans CommandSet.cs.Vous pouvez déplacer ou modifier les commandes standard, et vous pouvez ajouter vos propres commandes.Pour plus d'informations, consultez Écriture de commandes et d'actions utilisateur.

ModelExplorer.cs

Définit l'explorateur de modèles pour votre DÉSOLÉ.Il s'agit de l'arborescence du modèle que l'utilisateur voit le long de le diagramme.

Par exemple, vous pouvez substituer InsertTreeView() pour modifier l'ordre dans lequel ils apparaissent dans l'explorateur de modèles.

Si vous souhaitez que la sélection dans l'explorateur de modèles pour stocker synchronisé avec la sélection de diagramme, vous pouvez utiliser le code suivant :

protected override void OnSelectionChanged(global::System.EventArgs e)
{
base.OnSelectionChanged(e);
// get the selected element
DslModeling::ModelElement selectedElement = 
this.PrimarySelection as DslModeling::ModelElement;
// Select in the model explorer
SelectInModelExplorer<YOURLANGUAGEExplorerToolWindow>(selectedElement);
}
private void SelectInModelExplorer<T>(DslModeling::ModelElement modelElement)
where T : DslShell.ModelExplorerToolWindow
{
DslShell::ModelingPackage package = 
this.GetService(typeof(VSShell.Package)) as DslShell::ModelingPackage;
if (package != null)
{
// find the model explorer window
T explorerWindow = package.GetToolWindow(typeof(T), true) as T;
if (explorerWindow != null)
{
// get the tree container
DslShell.ModelExplorerTreeContainer treeContainer = 
explorerWindow.TreeContainer;
// find the tree node
DslShell.ExplorerTreeNode treeNode = 
treeContainer.FindNodeForElement(modelElement);
// select the node
explorerWindow.TreeContainer.ObjectModelBrowser.SelectedNode = treeNode;
}
}
}

ModelExplorerToolWindow.cs

Définit la fenêtre dans laquelle l'explorateur de modèles s'affiche.gère la sélection des éléments dans l'explorateur.

Package.cs

Ce fichier définit la façon dont le langage DÉSOLÉ intègre à Visual Studio.Les attributs sur la classe du package reportent le domaine (comme gestionnaire des fichiers avec votre extension de fichier, de définir sa boîte à outils, puis définissez comment ouvrir une nouvelle fenêtre.La méthode d'Initialize() est appelée une fois lorsque le premier DÉSOLÉ est chargé dans une instance de Visual Studio .

Source.extension.vsixmanifest

pour personnaliser ce fichier, modifiez le fichier d' .tt .

Mise en gardeAttention
Si vous modifiez le fichier.tout pour inclure des ressources telles que des icônes ou des images, assurez -vous que la ressource est incluse dans la génération VSIX.Dans l'explorateur de solutions, sélectionnez le fichier et assurez -vous que la propriété d' Incluez dans VSIX est True.

Contrôles de ce fichier comment le langage DÉSOLÉ est empaqueté dans une extension d'intégration Visual Studio (VSIX).Pour plus d'informations, consultez Déploiement de solutions de langage spécifique à un domaine.

Voir aussi

Concepts

Comment : définir un langage spécifique à un domaine

Présentation des modèles, des classes et des relations

Personnalisation et extension d'un langage spécifique à un domaine

Autres ressources

Écriture de code pour personnaliser un langage spécifique à un domaine