Condividi tramite

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

  • Articolo

È possibile scrivere un host personalizzato che elabora modelli di testo. Un host personalizzato di base è illustrato in Procedura dettagliata: Creazione di un host modello di testo personalizzato. È possibile estendere l'host per aggiungere funzioni come la generazione di più file di output.

In questa procedura dettagliata si espande l'host personalizzato in modo che supporti modelli di testo che chiamano processori di direttiva. Quando si definisce un linguaggio specifico del dominio, viene generato un processore di direttiva per il modello di dominio. Il processore di direttiva semplifica la scrittura di modelli che accedono al modello, riducendo la necessità di scrivere direttive di assembly e importazione nei modelli.

Nota

Questa procedura dettagliata si basa su Procedura dettagliata: Creazione di un host modello di testo personalizzato. Eseguire prima la procedura dettagliata.

In questa procedura dettagliata sono incluse le attività seguenti:

  • Uso di Strumenti di linguaggio specifici del dominio per generare un processore di direttiva basato su un modello di dominio.

  • Connessione un host di modelli di testo personalizzato al processore di direttiva generato.

  • Test dell'host personalizzato con il processore di direttiva generato.

Prerequisiti

Per definire un linguaggio specifico di dominio (Domain-Specific Language, DSL) devono essere installati i componenti seguenti:

Componente Collega
Visual Studio http://go.microsoft.com/fwlink/?LinkId=185579
Visual Studio SDK http://go.microsoft.com/fwlink/?LinkId=185580
SDK di visualizzazione e modellazione di Visual Studio

Nota

Il componente Trasformazione modello di testo viene installato automaticamente come parte del carico di lavoro sviluppo di estensioni di Visual Studio. È anche possibile installarlo dalla scheda Singoli componenti di Programma di installazione di Visual Studio, nella categoria SDK, librerie e framework. Installare il componente Modeling SDK dalla scheda Singoli componenti .

Inoltre, è necessario avere la trasformazione modello di testo personalizzata creata in Procedura dettagliata: Creazione di un host modello di testo personalizzato.

Usare strumenti di linguaggio specifici del dominio per generare un processore di direttiva

In questa procedura dettagliata si usa la Progettazione guidata linguaggio specifica del dominio per creare un linguaggio specifico del dominio per la soluzione DSLMinimalTest.

  1. Creare una soluzione del linguaggio specifica del dominio con le caratteristiche seguenti:

    • Nome: DSLMinimalTest

    • Modello di soluzione: linguaggio minimo

    • Estensione file: min

    • Nome società: Fabrikam

    Per altre informazioni sulla creazione di una soluzione di linguaggio specifica del dominio, vedere Procedura: Creare una soluzione di linguaggio specifica del dominio.

  2. Nel menu Compila scegliere Compila soluzione.

    Importante

    Questo passaggio genera il processore di direttiva e lo aggiunge nel Registro di sistema.

  3. Dal menu Debug scegliere Avvia debug.

    Viene aperta una seconda istanza di Visual Studio.

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

    Il file viene aperto nella finestra di progettazione. Si noti che il modello include due elementi, ExampleElement1 e ExampleElement2, e un collegamento tra di essi.

  5. Chiudere la seconda istanza di Visual Studio.

  6. Salvare la soluzione e quindi chiudere Progettazione linguaggio specifico del dominio.

Connessione un host di modelli di testo personalizzato a un processore di direttiva

Dopo aver generato il processore di direttiva, connettere il processore di direttiva e l'host modello di testo personalizzato creato in Procedura dettagliata: Creazione di un host modello di testo personalizzato.

  1. Aprire la soluzione CustomHost.

  2. Scegliere Aggiungi riferimento dal menu Progetto.

    Verrà visualizzata la finestra di dialogo Aggiungi riferimento con la scheda .NET visualizzata.

  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. Nella parte superiore di Program.cs o Module1.vb aggiungere la riga di codice seguente:

    using Microsoft.Win32;

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

    Nota

    In questo passaggio si aggiungono riferimenti agli assembly richiesti dal processore di direttiva generato supportato dall'host.

    //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:

    Importante

    Questo codice contiene riferimenti hardcoded al nome del processore di direttiva generato a cui si vuole connettersi. È possibile rendere questo più generale, nel qual caso cerca tutti i processori di direttiva elencati nel Registro di sistema e tenta di trovare una corrispondenza. In tal caso, l'host funzionerà con qualsiasi 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 Save All (Salva tutti) dal menu File.

  8. Nel menu Compila scegliere Compila soluzione.

Testare l'host personalizzato con il processore di direttiva

Per testare l'host modello di testo personalizzato, è prima necessario scrivere un modello di testo che chiama il processore di direttiva generato. Eseguire quindi l'host personalizzato, passarvi il nome del modello di testo e verificare che la direttiva sia elaborata correttamente.

Creare un modello di testo per testare l'host personalizzato

  1. Creare un file di testo e denominarlo TestTemplateWithDP.tt. È possibile usare qualsiasi editor di testo, ad esempio Blocco note, per creare il file.

  2. Aggiungere quanto segue al file di testo:

    Nota

    Il linguaggio di programmazione del modello di testo 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("");
    }
#>

  3. Nel codice sostituire <YOUR PATH> con il percorso del file Sample.min dal linguaggio specifico della progettazione creato nella prima procedura.

  4. Salva e chiude il file.

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.

    Ad esempio, digitare il comando seguente:

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

    Nota

    Invece di digitare l'indirizzo, è possibile passare al file CustomHost.exe in Esplora risorse e quindi trascinare il file nella finestra del prompt dei comandi.

  3. Digitare uno spazio.

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

    Ad esempio, digitare il comando seguente:

    <YOUR PATH>TestTemplateWithDP.txt

    Nota

    Invece di digitare l'indirizzo, è possibile passare al file TestTemplateWithDP.txt in Esplora risorse e quindi trascinare il file 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 che contiene 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 vengono visualizzati e dovrebbero essere simili al seguente:

    Text Template Host Test

Box: ExampleElement1
Linked to: ExampleElement2

Box: ExampleElement2
Linked from: ExampleElement1

Contenuto correlato