Compartir a través de

Tutorial: Conectar un host a un procesador de directivas personalizadas

  • Artículo

Puede escribir dispone del host que los procesos el texto a las plantillas.Un host personalizado básico se muestra en Tutorial: Crear un host de plantillas de texto personalizadas.Puede extender que hospedará para agregar funciones como generar archivos de salida múltiple.

En este tutorial, expande el host personalizado de modo que admita plantillas de texto que llamen los procesadores de directivas.Cuando se define un lenguaje específico de dominio, genera un procesador de directivas para el modelo de dominio.El procesador de directivas permite a los usuarios escriban las plantillas que tienen acceso al modelo, reduce la necesidad de escribir directivas de ensamblado e importación en las plantillas.

Nota de precauciónPrecaución

este tutorial compila en Tutorial: Crear un host de plantillas de texto personalizadas.Realice este tutorial primero.

este tutorial incluye las tareas siguientes:

  • Mediante Domain-Specific Language Tools para generar un procesador de directivas que se basa en un modelo de dominio.

  • Conexión de un host de plantilla de texto personalizado con el procesador de directivas generado.

  • Probar el host personalizado con el procesador de directivas generado.

Requisitos previos

Para definir un DSL, debe haber instalado los siguientes componentes:

Visual Studio

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

Visual Studio SDK

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

El SDK de visualización y modelado de Visual Studio

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

Además, debe tener la transformación personalizada de plantilla de texto creada en Tutorial: Crear un host de plantillas de texto personalizadas.

Mediante las herramientas de lenguaje específico de dominio para generar un procesador de directivas

En este tutorial, se utiliza el asistente del diseñador de lenguaje específico de dominio para crear un lenguaje específico para la solución DSLMinimalTest.

Para utilizar las herramientas de lenguaje específico de dominio para generar un procesador de directivas que se basa en un modelo de dominio

  1. Cree una solución específica del dominio del lenguaje que tenga las siguientes características:

    • nombre: DSLMinimalTest

    • Plantilla de solución: lenguaje mínimo

    • extensión de archivo: minuto

    • nombre de la compañía: Fabrikam

    Para obtener más información sobre cómo crear una solución específica del dominio del lenguaje, vea Cómo: Crear soluciones de lenguajes específicos de dominio.

  2. En el menú Compilar, haga clic en Compilar solución.

    Nota importanteImportante

    Este paso genera el procesador de directivas y agrega la clave para él en el registro.

  3. En el menú Depurar, haga clic en Iniciar depuración.

    Una segunda instancia de Visual Studio abra.

  4. En la compilación experimental, en Explorador de soluciones, haga doble clic en el archivo sample.min.

    El archivo se abre en el diseñador.observe que el modelo tiene dos elementos, ExampleElement1 y ExampleElement2, y un vínculo entre ellos.

  5. Cierre la segunda instancia de Visual Studio. 

  6. Guarde la solución, y luego cierre el Diseñador de lenguaje específico.

Conexión de un host de plantilla de texto personalizado con un procesador de directivas

Después de generar el procesador de directivas, conecte el procesador de directivas y el host de plantilla de texto personalizado que creó en Tutorial: Crear un host de plantillas de texto personalizadas.

Para conectar un host de plantilla de texto personalizado al procesador de directivas generado

  1. Abra la solución de CustomHost.

  2. Haga clic en la opción Agregar referencia del menú Proyecto.

    El cuadro de diálogo de Agregar referencia se abre con la ficha de .NET mostrada.

  3. agregue las referencias siguientes:

    • 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. En la parte superior Program.cs o Module1.vb, agregue la siguiente línea de código:

    using Microsoft.Win32;

    Imports Microsoft.Win32

  5. Busque el código para la propiedad StandardAssemblyReferences, y sustitúyalo con el código siguiente:

    [!NOTA]

    En este paso, agrega referencias a los ensamblados requeridos por el procesador de directivas generado que el host admitirá.

    //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. Busque el código de la función ResolveDirectiveProcessor, y sustitúyalo con el código siguiente:

    Nota importanteImportante

    Este código contiene referencias codificadas de forma rígida al nombre del procesador de directivas generado al que desea conectarse.Puede crear fácilmente esto más general, en este caso busca todos los procesadores de directivas enumerados en el registro y los intenta buscar una coincidencia.En ese caso, el host funciona con cualquier procesador de directivas generado.

    		 
    //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. En el menú Archivo, haga clic en Guardar todo.

  8. En el menú Compilar, haga clic en Compilar solución.

Probar el host personalizado con el procesador de directivas

Para probar el host personalizado de plantilla de texto, primero debe escribir una plantilla de texto que llame al procesador de directivas generado.Ejecute el host personalizado, pasa el nombre de la plantilla de texto, y comprueba que la directiva se procesa correctamente.

Para crear una plantilla de texto para probar el host personalizado

  1. Cree un archivo de texto, y denomínelo TestTemplateWithDP.tt.Puede usar cualquier editor de texto, como Bloc de notas, para crear el archivo.

  2. Agregue lo siguiente al archivo de texto:

    [!NOTA]

    El lenguaje de programación de la plantilla de texto no tiene que coincidir con el 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. En el código, reemplace <SU PATH> con la ruta de Sample.min de lenguaje diseño-específico que creó en el primer procedimiento.

  4. Guarde y cierre el archivo.

Para probar el host personalizado

  1. Abra una ventana de símbolo del sistema.

  2. Escriba la ruta de acceso del archivo ejecutable del host personalizado, pero no presione ENTRAR todavía.

    Por ejemplo, escriba:

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

    [!NOTA]

    En lugar de escribir la dirección, puede ir al archivo CustomHost.exe en El Explorador de Windows, y luego arrastre el archivo en la ventana del símbolo del sistema.

  3. Escriba un espacio.

  4. Escriba la ruta de acceso del archivo de plantilla de texto y, a continuación, presione ENTRAR.

    Por ejemplo, escriba:

    <YOUR PATH>TestTemplateWithDP.txt

    [!NOTA]

    En lugar de escribir la dirección, puede ir al archivo TestTemplateWithDP.txt en El Explorador de Windows, y luego arrastre el archivo en la ventana del símbolo del sistema.

    La aplicación host personalizada se ejecuta y comienza el proceso de transformación de plantillas de texto.

  5. En El Explorador de Windows, vaya a la carpeta que contiene el archivo TestTemplateWithDP.txt.

    la carpeta también contiene el archivo TestTemplateWithDP1.txt.

  6. Abra este archivo para ver el resultados de la transformación de la plantilla de texto.

    Los resultados de la salida de texto generada aparecen y deben tener esta apariencia:

    Text Template Host Test


Box: ExampleElement1
Linked to: ExampleElement2

Box: ExampleElement2
Linked from: ExampleElement1

Vea también

Tareas

Tutorial: Crear un host de plantillas de texto personalizadas