Procédure pas à pas : connexion d'un hôte à un processeur de directive généré
Vous pouvez écrire votre propre hôte qui traite les modèles de texte. Un hôte de base de personnalisé est affiché dans Procédure pas à pas : création d'un hôte de modèle de texte personnalisé. Vous pouvez étendre cet hôte pour ajouter des fonctions telles que générer des fichiers à sorties threads.
Dans cette procédure pas - à - pas, vous développez votre hôte personnalisé afin qu'il prenne en charge les modèles de texte qui appellent des processeurs de directive. Lorsque vous définissez un langage spécifique au domaine, il génère un processeur de directive pour le modèle de domaine. Le processeur de directive simplifie les utilisateurs entrent les modèles qui accèdent au modèle, réduisant ainsi la nécessité d'écrire des directives d'assembly et d'importation dans les modèles.
Avertissement
Cette procédure pas - à - pas repose sur Procédure pas à pas : création d'un hôte de modèle de texte personnalisé.Effectuez cette procédure pas - à - pas première.
Cette procédure pas - à - pas inclut les tâches suivantes :
À l'aide de Outils DSL (Domain-Specific Language) pour générer un processeur de directive qui est basé sur un modèle de domaine.
connecter un hôte de modèle de texte personnalisé au processeur de directive généré.
tester l'hôte personnalisé avec le processeur de directive généré.
Composants requis
Pour définir un langage spécifique à un domaine, vous devez avoir installé les composants suivants :
Visual Studio |
|
Kit de développement logiciel Visual Studio |
|
Kit de développement logiciel de visualisation et de modélisation de Visual Studio |
En outre, vous devez disposer de transformation de modèle de texte personnalisée créée dans Procédure pas à pas : création d'un hôte de modèle de texte personnalisé.
À l'aide de outils de languages spécifique au domaine pour générer un processeur de directive
Dans cette procédure pas - à - pas, vous utilisez l'Assistant concepteur de langage spécifique au domaine pour créer un langage spécifique au domaine pour la solution DSLMinimalTest.
Pour utiliser les outils de languages spécifique au domaine pour générer un processeur de directive qui est basé sur un modèle de domaine
Créez une solution de langage spécifique au domaine qui possède les caractéristiques suivantes :
nom : DSLMinimalTest
modèle de solution : langage minimal
extension de fichier : min
nom de la société : Fabrikam
Pour plus d'informations sur la création d'une solution de langage spécifique au domaine, consultez Comment : créer une solution de langage spécifique à un domaine.
Dans le menu Générer, cliquez sur Générer la solution.
Important
Cette étape génère le processeur de directive et ajoute la clé correspondante dans le Registre.
Dans le menu Déboguer, cliquez sur Démarrer le débogage.
une deuxième instance de Visual Studio s'ouvre.
Dans la génération expérimentale, dans Explorateur de solutions, double-cliquez sur le fichier sample.min.
Le fichier s'ouvre dans le concepteur. Remarquez que le modèle deux éléments, ExampleElement1 et ExampleElement2, et un lien entre eux.
Fermez la deuxième instance de Visual Studio.
Enregistrez la solution, puis fermez le concepteur de langage spécifique au domaine.
connecter un hôte de modèle de texte personnalisé à un processeur de directive
Après avoir généré le processeur de directive, vous connectez le processeur de directive et l'hôte de modèle de texte personnalisé que vous avez créés dans Procédure pas à pas : création d'un hôte de modèle de texte personnalisé.
pour connecter un hôte de modèle de texte personnalisé au processeur de directive généré
ouvrez la solution de CustomHost.
Dans le menu Projet, cliquez sur Ajouter une référence.
La boîte de dialogue d' Ajouter une référence s'ouvre avec l'onglet de .NET affiche.
ajoutez les références suivantes :
Microsoft.VisualStudio.Modeling.Sdk.11.0
Microsoft.VisualStudio.Modeling.Sdk.Diagrams.11.0
Microsoft.VisualStudio.TextTemplating.11.0
Microsoft.VisualStudio.TextTemplating.Interfaces.11.0
Microsoft.VisualStudio.TextTemplating.Modeling.11.0
Microsoft.VisualStudio.TextTemplating.VSHost.11.0
En haut de Program.cs ou Module1.vb, ajoutez la ligne de code suivante :
using Microsoft.Win32;Imports Microsoft.Win32Localisez le code pour la propriété StandardAssemblyReferences, et remplacez -le par le code suivant :
Notes
Dans cette étape, vous ajoutez des références aux assemblys requis par le processeur de directive généré que votre hôte prend en charge.
//the host can provide standard assembly references //the engine will use these references when compiling and //executing the generated transformation class //-------------------------------------------------------------- public IList<string> StandardAssemblyReferences { get { return new string[] { //if this host searches standard paths and the GAC //we can specify the assembly name like this: //"System" //since this host only resolves assemblies from the //fully qualified path and name of the assembly //this is a quick way to get the code to give us the //fully qualified path and name of the System assembly //--------------------------------------------------------- typeof(System.Uri).Assembly.Location, typeof(System.Uri).Assembly.Location, typeof(Microsoft.VisualStudio.Modeling.ModelElement).Assembly.Location, typeof(Microsoft.VisualStudio.Modeling.Diagrams.BinaryLinkShape).Assembly.Location, typeof(Microsoft.VisualStudio.TextTemplating.VSHost.ITextTemplating).Assembly.Location, typeof(Microsoft.VisualStudio.TextTemplating.VSHost.ModelingTextTransformation).Assembly.Location }; } }Localisez le code pour la fonction ResolveDirectiveProcessor, et remplacez -le par le code suivant :
Important
Ce code contient des références codées en dur le nom du processeur de directive généré auquel vous souhaitez vous connecter.Vous pouvez facilement rendre ce problème plus général, auquel cas il recherche tous les processeurs de directive répertoriés dans le Registre et essaie de rechercher une correspondance.Dans ce cas, l'hôte doit s'exécuter avec tout processeur de directive généré.
//the engine calls this method based on the directives the user has //specified it in the text template //this method can be called 0, 1, or more times //--------------------------------------------------------------------- public Type ResolveDirectiveProcessor(string processorName) { //check the processor name, and if it is the name of the processor the //host wants to support, return the type of the processor //--------------------------------------------------------------------- if (string.Compare(processorName, "DSLMinimalTestDirectiveProcessor", StringComparison.InvariantCultureIgnoreCase) == 0) { try { string keyName = @"Software\Microsoft\VisualStudio\10.0Exp_Config\TextTemplating\DirectiveProcessors\DSLMinimalTestDirectiveProcessor"; using (RegistryKey specificKey = Registry.CurrentUser.OpenSubKey(keyName)) { if (specificKey != null) { List<string> names = new List<String>(specificKey.GetValueNames()); string classValue = specificKey.GetValue("Class") as string; if (!string.IsNullOrEmpty(classValue)) { string loadValue = string.Empty; System.Reflection.Assembly processorAssembly = null; if (names.Contains("Assembly")) { loadValue = specificKey.GetValue("Assembly") as string; if (!string.IsNullOrEmpty(loadValue)) { //the assembly must be installed in the GAC processorAssembly = System.Reflection.Assembly.Load(loadValue); } } else if (names.Contains("CodeBase")) { loadValue = specificKey.GetValue("CodeBase") as string; if (!string.IsNullOrEmpty(loadValue)) { //loading local assembly processorAssembly = System.Reflection.Assembly.LoadFrom(loadValue); } } if (processorAssembly == null) { throw new Exception("Directive Processor not found"); } Type processorType = processorAssembly.GetType(classValue); if (processorType == null) { throw new Exception("Directive Processor not found"); } return processorType; } } } } catch (Exception e) { //if the directive processor can not be found, throw an error throw new Exception("Directive Processor not found"); } } //if the directive processor is not one this host wants to support throw new Exception("Directive Processor not supported"); }Dans le menu Fichier, cliquez sur Enregistrer tout.
Dans le menu Générer, cliquez sur Générer la solution.
tester l'hôte personnalisé avec le processeur de directive
Pour tester l'hôte de modèle de texte personnalisé, vous devez d'abord écrire un modèle de texte qui appelle le processeur de directive généré. Ensuite exécuter l'hôte personnalisé, passez -lui le nom du modèle de texte, et vérifiez que la directive est traitée correctement.
Pour créer un modèle de texte pour tester l'hôte personnalisé
créez un fichier texte, et nommez-le TestTemplateWithDP.tt. Vous pouvez utiliser n'importe quel éditeur de texte, tel que le Bloc-notes, pour créer le fichier.
Ajoutez le code suivant au fichier texte :
Notes
Le langage de programmation du modèle de texte n'a pas besoin de correspondre à celui de l'hôte personnalisé.
Text Template Host Test <#@ template debug="true" inherits="Microsoft.VisualStudio.TextTemplating.VSHost.ModelingTextTransformation" #> <# //this is the call to the examplemodel directive in the generated directive processor #> <#@ DSLMinimalTest processor="DSLMinimalTestDirectiveProcessor" requires="fileName='<Your Path>\Sample.min'" provides="ExampleModel=ExampleModel" #> <# //uncomment this line to test that the host allows the engine to set the extension #> <# //@ output extension=".htm" #> <# //uncomment this line if you want to see the generated transformation class #> <# //System.Diagnostics.Debugger.Break(); #> <# //this code uses the results of the examplemodel directive #> <# foreach ( ExampleElement box in this.ExampleModel.Elements ) { WriteLine("Box: {0}", box.Name); foreach (ExampleElement linkedTo in box.Targets) { WriteLine("Linked to: {0}", linkedTo.Name); } foreach (ExampleElement linkedFrom in box.Sources) { WriteLine("Linked from: {0}", linkedFrom.Name); } WriteLine(""); } #>Text Template Host Test <#@ template debug="true" language="VB" inherits="Microsoft.VisualStudio.TextTemplating.VSHost.ModelingTextTransformation" #> <# 'this is the call to the examplemodel directive in the generated directive processor #> <#@ DSLMinimalTest processor="DSLMinimalTestDirectiveProcessor" requires="fileName='<Your Path>\Sample.min'" provides="ExampleModel=ExampleModel" #> <# 'Uncomment this line to test that the host allows the engine to set the extension. #> <# '@ output extension=".htm" #> <# 'Uncomment this line if you want to see the generated transformation class. #> <# 'System.Diagnostics.Debugger.Break() #> <# 'this code uses the results of the examplemodel directive #> <# For Each box as ExampleElement In Me.ExampleModel.Elements WriteLine("Box: {0}", box.Name) For Each LinkedTo as ExampleElement In box.Targets WriteLine("Linked to: {0}", LinkedTo.Name) Next For Each LinkedFrom as ExampleElement In box.Sources WriteLine("Linked from: {0}", LinkedFrom.Name) Next WriteLine("") Next #>Dans le code, remplacez <YOUR PATH> par le chemin d'accès du fichier de Sample.min du langage de création-détail que vous avez créé dans la première procédure.
Enregistrez et fermez le fichier.
Pour tester l'hôte personnalisé
Ouvrez une fenêtre d'invite de commandes.
Tapez le chemin d'accès du fichier exécutable de l'hôte personnalisé, mais n'appuyez pas encore sur ENTRÉE.
Par exemple, tapez :
<YOUR PATH>CustomHost\bin\Debug\CustomHost.exe
Notes
Au lieu de taper l'adresse, vous pouvez rechercher le fichier CustomHost.exe dans Explorateur Windows, puis faites glisser dans la fenêtre d'invite de commandes.
Tapez un espace.
Tapez le chemin d'accès du fichier modèle de texte, puis appuyez sur ENTRÉE.
Par exemple, tapez :
<YOUR PATH>TestTemplateWithDP.txt
Notes
Au lieu de taper l'adresse, vous pouvez rechercher le fichier TestTemplateWithDP.txt dans Explorateur Windows, puis faites glisser dans la fenêtre d'invite de commandes.
L'application hôte personnalisée s'exécute et démarre le processus de transformation de modèle de texte.
Dans Explorateur Windows, recherchez le dossier qui contient le fichier TestTemplateWithDP.txt.
le dossier contient également le fichier TestTemplateWithDP1.txt.
Ouvrez ce fichier pour afficher les résultats de la transformation du modèle de texte.
Les résultats de la sortie de texte générée s'affiche et doit ressembler à ceci :
Text Template Host Test Box: ExampleElement1 Linked to: ExampleElement2 Box: ExampleElement2 Linked from: ExampleElement1
Voir aussi
Tâches
Procédure pas à pas : création d'un hôte de modèle de texte personnalisé