Condividi tramite

Procedura dettagliata: connessione di un host a un processore di direttiva generato

  • Articolo

È possibile scrivere il proprio host che elabora i modelli di testo.Un host personalizzato di base è illustrato in Procedura dettagliata: creazione di un host del modello di testo personalizzato.È possibile estendere tale host per aggiungere funzioni come generazione di file all'uscita da input.

In questa procedura dettagliata, espandere l'host personalizzato in modo che supporti i modelli di testo che chiamano processori di direttiva.Quando si definisce un linguaggio specifico di dominio, genera un'eccezione processore di direttiva per il modello di dominio.Il processore di direttiva rende più semplice l'individuazione gli utenti scrivere nei modelli che accedono al modello, riducendo la necessità di scrivere direttive dell'assembly e di importazione nei modelli.

Nota di avvisoAttenzione

Compilazione di questa procedura dettagliata su Procedura dettagliata: creazione di un host del modello di testo personalizzato.Eseguire tale procedura precedente.

In questa procedura dettagliata sono incluse le attività seguenti:

  • Tramite Domain-Specific Language Tools per generare un processore di direttiva basato su un modello di dominio.

  • Connettere un host del modello di testo personalizzato al processore di direttiva generato.

  • testare l'host personalizzato con il processore di direttiva generato.

Prerequisiti

Per definire un modello DSL, è necessario installare i componenti seguenti:

Visual Studio

https://go.microsoft.com/fwlink/?LinkId=185579

Visual Studio SDK

https://go.microsoft.com/fwlink/?LinkId=185580

L'sdk di visualizzazione e modellazione di Visual Studio

https://go.microsoft.com/fwlink/?LinkID=186128

Inoltre, è necessario eseguire per creare la trasformazione del modello di testo personalizzato in Procedura dettagliata: creazione di un host del modello di testo personalizzato.

Utilizzando gli strumenti di linguaggio specifico di dominio per generare un processore di direttiva

In questa procedura dettagliata, si utilizza Domain-Specific Language Designer Wizard per creare un linguaggio specifico di dominio per la soluzione DSLMinimalTest.

Per utilizzare gli strumenti di linguaggio specifico di dominio per generare un processore di direttiva basato su un modello di dominio

  1. Creare una soluzione di linguaggio specifico di dominio con le caratteristiche seguenti:

    • nome: DSLMinimalTest

    • Modello della soluzione: linguaggio minimo

    • estensione di file: min

    • Nome della società: Fabrikam

    Per ulteriori informazioni sulla creazione di una soluzione di linguaggio specifico di dominio, vedere Procedura: creare una soluzione per un linguaggio specifico di dominio.

  2. Scegliere Compila soluzione dal menu Compila.

    Nota importanteImportante

    Questo passaggio viene generato il processore di direttiva e aggiunge la chiave per nel Registro di sistema.

  3. Scegliere Avvia debug dal menu Debug.

    una seconda istanza di Visual Studio verrà visualizzata la.

  4. Nella compilazione sperimentale, in Esplora soluzioni, fare doppio clic sul file sample.min.

    Il file verrà aperto nella finestra di progettazione.Si noti che il modello dispone di due elementi, ExampleElement1 e ExampleElement2 e un collegamento tra loro.

  5. Chiudere la seconda istanza di Visual Studio. 

  6. Salvare la soluzione e quindi chiudere la finestra di progettazione del linguaggio specifico di dominio.

Connettere un host del modello di testo personalizzato a un processore di direttiva

Dopo avere generato il processore di direttiva, si connette il processore di direttiva e l'host del modello di testo personalizzato creato in Procedura dettagliata: creazione di un host del modello di testo personalizzato.

Per connettere un host del modello di testo personalizzato al processore di direttiva generato

  1. aprire la soluzione di CustomHost.

  2. Scegliere Aggiungi riferimento dal menu Progetto.

    aggiungere il riferimento verrà visualizzata la finestra di dialogo con .NET scheda.

  3. Aggiungere i riferimenti seguenti:

    • 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. In Module1.vb o Program.cs, aggiungere la seguente riga di codice:

    using Microsoft.Win32;

    Imports Microsoft.Win32

  5. individuare il codice per la proprietà StandardAssemblyReferencese sostituirlo con il codice seguente:

    [!NOTA]

    In questo passaggio, aggiungere riferimenti agli assembly che vengono richiesti dal processore di direttiva generato che l'host supporterà.

    //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. individuare il codice per la funzione ResolveDirectiveProcessore sostituirlo con il codice seguente:

    Nota importanteImportante

    Questo codice contiene riferimenti specificati a livello di codice al nome del processore di direttiva generato al quale si desidera connettersi.È possibile facilmente renderla più generale, nel qual caso viene eseguita la ricerca di tutti i processori di direttiva elencati nel Registro di sistema e tenta di trovare una corrispondenza.In tal caso, l'host eseguito con il processore di direttiva generato.

    		 
    //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. Scegliere Salva tutto dal menu File.

  8. Scegliere Compila soluzione dal menu Compila.

testare l'host personalizzato con il processore di direttiva

Per testare l'host personalizzato il modello di testo, è innanzitutto necessario scrivere un modello di testo che chiama il processore di direttiva generato.Eseguire l'host personalizzato, passare il nome del modello di testo e verrà verificato che la direttiva essere eseguita correttamente.

Per creare un modello di testo per testare l'host personalizzato

  1. creare un file di testo e denominarlo TestTemplateWithDP.tt.È possibile utilizzare qualsiasi editor di testo, come Blocco Note, per creare il file.

  2. Aggiungere quanto segue al file di testo:

    [!NOTA]

    Il linguaggio di programmazione non deve corrispondere a quello dell'host personalizzato.

    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 
#>

  3. Nel codice, sostituire <A VOSTRO PATH> con il percorso del file di Sample.min dal linguaggio Design-specifico creato nella prima procedura.

  4. Salvare e chiudere il file.

Per testare l'host personalizzato

  1. Aprire una finestra del prompt dei comandi.

  2. Digitare il percorso del file eseguibile per l'host personalizzato, ma non premere ancora INVIO.

    Digitare ad esempio:

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

    [!NOTA]

    Anziché digitare l'indirizzo, è possibile passare al file CustomHost.exe in Esplora risorsee trascinarlo nella finestra del prompt dei comandi.

  3. Digitare uno spazio.

  4. Digitare il percorso del file modello di testo, quindi premere INVIO.

    Digitare ad esempio:

    <YOUR PATH>TestTemplateWithDP.txt

    [!NOTA]

    Anziché digitare l'indirizzo, è possibile passare al file TestTemplateWithDP.txt in Esplora risorsee trascinarlo nella finestra del prompt dei comandi.

    L'applicazione host personalizzata viene eseguita e avvia il processo di trasformazione del modello di testo.

  5. in Esplora risorse, passare alla cartella contenente il file TestTemplateWithDP.txt.

    La cartella contiene anche il file TestTemplateWithDP1.txt.

  6. Aprire questo file per vedere i risultati della trasformazione del modello di testo.

    I risultati dell'output di testo generato viene visualizzato e devono essere simile al seguente:

    Text Template Host Test


Box: ExampleElement1
Linked to: ExampleElement2

Box: ExampleElement2
Linked from: ExampleElement1

Vedere anche

Attività

Procedura dettagliata: creazione di un host del modello di testo personalizzato