Partager via

Procédure pas à pas : connecter un hôte à un processeur de directive généré

  • Article

Vous pouvez écrire votre propre hôte qui traite les modèles de texte. Un hôte personnalisé de base est illustré 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 comme la génération de plusieurs fichiers de sortie.

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 directives. Quand vous définissez un langage dédié, il génère un processeur de directives pour le modèle de domaine. Le processeur de directives permet aux utilisateurs d’écrire plus facilement des modèles qui accèdent au modèle, ce qui réduit la nécessité d’écrire des directives d’assembly et d’importation dans les modèles.

Notes

Cette procédure pas à pas dépend de Procédure pas à pas : Création d’un hôte de modèle de texte personnalisé. Effectuez d’abord cette procédure pas à pas.

Cette procédure pas à pas comprend les tâches suivantes :

  • Utilisation des Outils de langage dédié pour générer un processeur de directives basé sur un modèle de domaine.

  • Connexion d’un hôte de modèle de texte personnalisé au processeur de directives généré.

  • Test de l’hôte personnalisé avec le processeur de directives généré.

Prérequis

Pour définir un DSL, vous devez avoir installé les composants suivants :

Composant Lien
Visual Studio http://go.microsoft.com/fwlink/?LinkId=185579
Kit de développement logiciel Visual Studio http://go.microsoft.com/fwlink/?LinkId=185580
Kit de développement logiciel (SDK) Visual Studio Visualization and Modeling

Notes

Le composant Transformation de modèle de texte est automatiquement installé dans le cadre de la charge de travail Développement d’extensions Visual Studio. Vous pouvez aussi l’installer à partir de l’onglet Composants individuels de Visual Studio Installer, sous la catégorie SDK, bibliothèques et frameworks. Installez le composant Modeling SDK à partir de l’onglet Composants individuels.

Par ailleurs, vous devez avoir la transformation de modèle de texte personnalisé que vous avez créée dans Procédure pas à pas : Création d’un hôte de modèle de texte personnalisé.

Utiliser les Outils de langage dédié pour générer un processeur de directives

Dans cette procédure pas à pas, vous utilisez l’Assistant Concepteur de langage dédié afin de créer un langage dédié pour la solution DSLMinimalTest.

  1. Créez une solution de langage dédié qui a les caractéristiques suivantes :

    • Nom : DSLMinimalTest

    • Modèle de solution : Langage minimal

    • Extension de fichier  min

    • Nom de l’entreprise : Fabrikam

    Pour plus d’informations sur la création d’une solution de langage dédié, consultez Guide pratique pour créer une solution de langage dédié.

  2. Dans le menu Générer, cliquez sur Générer la solution.

    Important

    Cette étape génère le processeur de directives et ajoute la clé correspondante dans le Registre.

  3. Dans le menu Déboguer , cliquez sur Démarrer le débogage.

    Une deuxième instance de Visual Studio s’ouvre.

  4. Dans la build expérimentale, dans l’Explorateur de solutions, double-cliquez sur le fichier sample.min.

    Le fichier s’ouvre dans le concepteur. Notez que le modèle a deux éléments, ExampleElement1 et ExampleElement2, et un lien entre eux.

  5. Fermez la deuxième instance de Visual Studio.

  6. Enregistrez la solution, puis fermez le Concepteur de langage dédié.

Connecter un hôte de modèle de texte personnalisé à un processeur de directives

Après avoir généré le processeur de directives, vous connectez le processeur de directives et l’hôte de modèle de texte personnalisé que vous avez créé dans Procédure pas à pas : Création d’un hôte de modèle de texte personnalisé.

  1. Ouvrez la solution CustomHost.

  2. Dans le menu Projet, cliquez sur Ajouter une référence.

    La boîte de dialogue Ajouter une référence s’ouvre avec l’onglet .NET affiché.

  3. 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

  4. Au début de Program.cs ou Module1.vb, ajoutez la ligne de code suivante :

    using Microsoft.Win32;

  5. Recherchez le code de la propriété StandardAssemblyReferences, puis remplacez-le par le code suivant :

    Notes

    Dans cette étape, vous ajoutez des références aux assemblys demandés par le processeur de directives généré que votre hôte doit prendre 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

        };
    }
}

  6. Recherchez le code de la fonction ResolveDirectiveProcessor, puis remplacez-le par le code suivant :

    Important

    Ce code contient des références codées en dur au nom du processeur de directives généré auquel vous souhaitez vous connecter. Vous pouvez facilement rendre cette action plus générale, auquel cas il recherche tous les processeurs de directives listés dans le Registre et tente de trouver une correspondance. Dans ce cas, l’hôte fonctionne avec n’importe quel processeur de directives 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");
        }

  7. Dans le menu Fichier , cliquez sur Enregistrer tout.

  8. Dans le menu Générer, cliquez sur Générer la solution.

Tester l’hôte personnalisé avec le processeur de directives

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 directives généré. Ensuite, vous exécutez l’hôte personnalisé, lui passez le nom du modèle de texte et vérifiez que la directive est traitée correctement.

Créer un modèle de texte pour tester l’hôte personnalisé

  1. Créez un fichier texte et nommez-le TestTemplateWithDP.tt. Vous pouvez utiliser n’importe quel éditeur de texte (par exemple, le Bloc-notes) pour créer le fichier.

  2. Ajoutez le code suivant au fichier texte :

    Notes

    Le langage de programmation du modèle de texte ne doit pas nécessairement 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("");
    }
#>

  3. Dans le code, remplacez <YOUR PATH> par le chemin du fichier Sample.min du langage dédié que vous avez créé dans la première procédure.

  4. Enregistrez et fermez le fichier.

Tester l’hôte personnalisé

  1. Ouvrez une fenêtre d’invite de commandes.

  2. 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, entrez :

    <YOUR PATH>CustomHost\bin\Debug\CustomHost.exe

    Notes

    Au lieu de taper l’adresse, vous pouvez accéder au fichier CustomHost.exe dans l’Explorateur Windows, puis le faire glisser dans la fenêtre d’invite de commandes.

  3. Tapez un espace.

  4. Tapez le chemin d'accès du fichier modèle de texte, puis appuyez sur ENTRÉE.

    Par exemple, entrez :

    <YOUR PATH>TestTemplateWithDP.txt

    Notes

    Au lieu de taper l’adresse, vous pouvez rechercher le fichier TestTemplateWithDP.tt dans l’Explorateur Windows, puis le faire 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 du modèle de texte.

  5. Dans l’Explorateur Windows, recherchez le dossier qui contient le fichier TestTemplateWithDP.tt.

    Ce dossier comprend également le fichier TestTemplateWithDP1.txt.

  6. 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é s’affichent et doivent ressembler à ceci :

    Text Template Host Test

Box: ExampleElement1
Linked to: ExampleElement2

Box: ExampleElement2
Linked from: ExampleElement1

Contenu connexe