Compartilhar via

Passo a passo: Conectando a um Host para um processador de diretiva gerados

  • Artigo

Você pode escrever seu próprio host que processa os modelos de texto.Um host personalizado básico é demonstrado em Passo a passo: Criando um Host de modelo de texto personalizado.Você pode estender esse host para adicionar funções, como gerar vários arquivos de saída.

Esta explicação passo a passo, você expandir seu host personalizado para que ele oferece suporte a modelos de texto que chamam os processadores de diretriz.Quando você define uma linguagem específica de domínio, ele gera uma processador de diretriz para o modelo de domínio.Processador de diretriz torna mais fácil para os usuários escrevam modelos que acessar o modelo, reduzindo a necessidade de escrever o assembly e importar diretivas nos modelos.

Observação de cuidadoCuidado

Esta explicação passo a passo baseia-se na Passo a passo: Criando um Host de modelo de texto personalizado.Execute esse passo a passo pela primeira vez.

Esta explicação passo a passo inclui as seguintes tarefas:

  • Usando Ferramentas de Linguagem Específica do Domínio para gerar um processador de diretriz que se baseia em um modelo de domínio.

  • Conectando-se um host de modelo de texto personalizado para o processador de diretriz gerado.

  • Testando o host personalizado com o processador de diretriz gerado.

Pré-requisitos

Para definir uma DSL, você deve ter instalado os seguintes componentes:

Visual Studio

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

SDK do Visual Studio

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

SDK de modelagem e visualização de Visual Studio

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

Além disso, você deve ter a transformação do modelo de texto personalizado criada em Passo a passo: Criando um Host de modelo de texto personalizado.

Usando ferramentas de linguagem específica de domínio para gerar um processador de diretiva

Esta explicação passo a passo, você pode usar o Assistente de Designer de linguagem específica de domínio para criar uma linguagem específica de domínio para a solução DSLMinimalTest.

Usar ferramentas de linguagem específica de domínio para gerar um processador de diretriz que se baseia em um modelo de domínio

  1. Crie uma solução de linguagem específica de domínio que tem as seguintes características:

    • Nome: DSLMinimalTest

    • Modelo de solução: mínimo de idioma

    • Extensão de arquivo: min

    • Nome da empresa: Fabrikam

    Para obter mais informações sobre como criar uma solução de linguagem específica de domínio, consulte Como: criar uma solução de linguagem específica do domínio.

  2. Sobre o Build menu, clique em Build Solution.

    Observação importanteImportante

    Esta etapa gera o processador de diretriz e adiciona a chave para ele no registro.

  3. No menu Depuração, clique em Iniciar Depuração.

    Uma segunda instância do Visual Studio abre.

  4. Na compilação experimental, em Solution Explorer, duas vezes no arquivo sample.min.

    O arquivo é aberto no designer.Observe que o modelo possui dois elementos, ExampleElement1 e ExampleElement2 e um link entre eles.

  5. Feche a segunda instância de Visual Studio. 

  6. Salve a solução e, em seguida, feche o Designer de linguagem específica de domínio.

Conectando a um Host de modelo de texto personalizado para um processador de diretiva

Depois de gerar o processador de diretriz, conecte o processador de diretriz e o host de modelo de texto personalizado que você criou na Passo a passo: Criando um Host de modelo de texto personalizado.

Para se conectar a um host de modelo de texto personalizado para o processador de diretriz gerado

  1. Abra a solução de CustomHost.

  2. No menu Project, escolha Add Reference.

    O Add Reference caixa de diálogo é aberta com o .NET guia exibida.

  3. Adicione as seguintes referências:

    • 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. Na parte superior do Program. cs ou Module1. vb, adicione a seguinte linha de código:

    using Microsoft.Win32;

    Imports Microsoft.Win32

  5. Localize o código para a propriedade StandardAssemblyReferencese substituí-lo com o seguinte código:

    ObservaçãoObservação

    Nesta etapa, você pode adicionar referências aos assemblies que são necessários para o processador de diretriz gerado que suportará o seu 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. Localize o código para a função ResolveDirectiveProcessore substituí-lo com o seguinte código:

    Observação importanteImportante

    Esse código contém referências embutido para o nome do processador de diretriz gerado para o qual você deseja se conectar.Você pode facilmente fazer isso mais geral, caso em que ele procura todos os processadores de diretriz listados no registro e tenta encontrar uma correspondência.Nesse caso, o host funcionaria com qualquer processador de diretriz gerado.

    		 
    //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. No menu File, clique em Save All.

  8. Sobre o Build menu, clique em Build Solution.

Testando o Host personalizado com o processador de diretiva

Para testar o host do modelo de texto personalizado, primeiro você deve escrever um modelo de texto que chama o processador de diretriz gerado.Em seguida, você executa o host personalizado, passa para ele o nome do modelo de texto e verificar que a diretiva seja processada corretamente.

Para criar um modelo de texto para testar o host personalizado

  1. Crie um arquivo de texto e o nome de TestTemplateWithDP.tt.Você pode usar qualquer editor de texto, como o bloco de notas, para criar o arquivo.

  2. Adicione o seguinte para o arquivo de texto:

    ObservaçãoObservação

    A linguagem de programação do modelo de texto não precisa coincidir com o host personalizado.

    		 
    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. No código, substitua < caminho > com o caminho do arquivo Sample.min do idioma específico do design que você criou no primeiro procedimento.

  4. Salve e feche o arquivo.

Para testar o host personalizado

  1. Abra uma janela de Prompt de comando.

  2. Digite o caminho do arquivo executável para o host personalizado, mas não pressione ENTER ainda.

    Por exemplo, digite:

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

    ObservaçãoObservação

    Em vez de digitar o endereço, você pode procurar o arquivo CustomHost.exe na Windows Explorere, em seguida, arraste o arquivo para a janela do Prompt de comando.

  3. Digite um espaço.

  4. Digite o caminho do arquivo de modelo de texto e pressione ENTER.

    Por exemplo, digite:

    <YOUR PATH>TestTemplateWithDP.txt

    ObservaçãoObservação

    Em vez de digitar o endereço, você pode procurar o arquivo TestTemplateWithDP.txt na Windows Explorere, em seguida, arraste o arquivo para a janela do Prompt de comando.

    O aplicativo host personalizado é executado e inicia o processo de transformação do modelo de texto.

  5. Em Windows Explorer, navegue até a pasta que contém o arquivo TestTemplateWithDP.txt.

    A pasta também contém o arquivo TestTemplateWithDP1.txt.

  6. Abra este arquivo para ver os resultados da transformação do modelo de texto.

    Os resultados da saída de texto gerado é exibido e deve ficar assim:

    Text Template Host Test


Box: ExampleElement1
Linked to: ExampleElement2

Box: ExampleElement2
Linked from: ExampleElement1

Consulte também

Tarefas

Passo a passo: Criando um Host de modelo de texto personalizado