Compartilhar via

Passo a passo: conectar um host a um processador de diretiva gerado

  • Artigo

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

Neste passo a passo, você expande seu host personalizado para que ele dê suporte a modelos de texto que chamam processadores de diretiva. Quando você define uma linguagem específica de domínio, ela gera um processador de diretiva para o modelo de domínio. O processador de diretiva torna mais fácil para os usuários escrever modelos que acessam o modelo, reduzindo a necessidade de escrever diretivas de assembly e de importação nos modelos.

Observação

Este passo a passo se baseia em Passo a passo: criar um host de modelo de texto personalizado. Execute esse passo a passo primeiro.

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

  • Usar Ferramentas de Linguagem Específica de Domínio para gerar um processador de diretiva baseado em um modelo de domínio.

  • Como conectar um host de modelo de texto personalizado ao processador de diretiva gerado.

  • Testar o host personalizado com o processador de diretiva gerado.

Pré-requisitos

Para definir uma DSL, é necessário ter instalados os seguintes componentes:

Componente Link
Visual Studio http://go.microsoft.com/fwlink/?LinkId=185579
SDK do Visual Studio http://go.microsoft.com/fwlink/?LinkId=185580
SDK de Visualização e Modelagem do Visual Studio

Observação

O componente Transformação de Modelo de Texto é instalado automaticamente como parte da carga de trabalho de Desenvolvimento de extensões do Visual Studio. Você também pode instalá-lo na guia Componentes individuais do Instalador do Visual Studio, na categoria SDKs, bibliotecas e estruturas. Instale o componente SDK de Modelagem na guia Componentes individuais.

Além disso, você precisa ter a transformação de modelo de texto personalizado criada em Passo a passo: criar um host de modelo de texto personalizado.

Usar Ferramentas de Linguagem Específica de Domínio para gerar um processador de diretiva

Neste passo a passo, você usa 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.

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

    • Nome: DSLMinimalTest

    • Modelo de solução: linguagem mínima

    • 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, confira Como criar uma solução de linguagem específica de domínio.

  2. No menu Compilar, clique em Compilar Solução.

    Importante

    Esta etapa gera o processador de diretiva e adiciona a chave para ele no Registro.

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

    Uma segunda instância do Visual Studio é aberta.

  4. No build experimental, em Gerenciador de Soluções, clique duas vezes no arquivo sample.min.

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

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

  6. Salve a solução e feche o Designer de Linguagem Específica de Domínio.

Conectar um host de modelo de texto personalizado a um processador de diretiva

Depois de gerar o processador de diretiva, conecte o processador de diretiva e o host de modelo de texto personalizado que você criou em Passo a passo: criar um host de modelo de texto personalizado.

  1. Abra a solução CustomHost.

  2. No menu Projeto, clique em Adicionar Referência.

    A caixa de diálogo Adicionar Referência é aberta com a guia .NET 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 de Program.cs ou Module1.vb, adicione a seguinte linha de código:

    using Microsoft.Win32;

  5. Localize o código da propriedade StandardAssemblyReferences e substitua-o pelo seguinte código:

    Observação

    Nesta etapa, você adicionará referências aos assemblies exigidos pelo processador de diretiva gerado ao qual o host dará suporte.

    //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 da função ResolveDirectiveProcessor e substitua-o pelo seguinte código:

    Importante

    Esse código contém referências embutidas em código para o nome do processador de diretiva gerado ao qual você deseja se conectar. Você pode facilmente tornar isso mais geral; nesse caso, ele procura todos os processadores de diretiva listados no registro e tenta encontrar uma correspondência. Nesse caso, o host funcionaria com qualquer processador de diretiva 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 Arquivo , clique em Salvar Tudo.

  8. No menu Compilar, clique em Compilar Solução.

Testar o host personalizado com o processador de diretiva

Para testar o host de modelo de texto personalizado, primeiro você precisa escrever um modelo de texto que chame o processador de diretiva gerado. Em seguida, execute o host personalizado, passe para ele o nome do modelo de texto e verifique se a diretiva foi processada corretamente.

Criar um modelo de texto para testar o host personalizado

  1. Crie um arquivo de texto e nomeie-o TestTemplateWithDP.tt. Você pode usar qualquer editor de texto (por exemplo, o Bloco de Notas) para criar o arquivo.

  2. Adicione o seguinte ao arquivo de texto:

    Observação

    A linguagem de programação do modelo de texto não precisa corresponder à linguagem do 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("");
    }
#>

  3. No código, substitua <SEU CAMINHO> pelo caminho do arquivo Sample.min da linguagem específica de domínio 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ção

    Em vez de digitar o endereço, procure o arquivo CustomHost.exe no Windows Explorer e depois 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ção

    Em vez de digitar o endereço, procure o arquivo TestTemplateWithDP.txt no Windows Explorer e depois arraste o arquivo para a janela Prompt de Comando.

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

  5. No 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 esse arquivo para ver os resultados da transformação do modelo de texto.

    Os resultados da saída de texto gerada são exibidos e devem ter esta aparência:

    Text Template Host Test

Box: ExampleElement1
Linked to: ExampleElement2

Box: ExampleElement2
Linked from: ExampleElement1

Conteúdo relacionado