Métodos de utilidad de las plantillas de texto

Hay varios métodos que siempre están disponibles al escribir código en una plantilla de texto de Visual Studio. Estos métodos se definen en TextTransformation.

Sugerencia

También puede usar otros métodos y servicios proporcionados por el entorno del host en una plantilla de texto normal (no procesada previamente). Por ejemplo, puede resolver rutas de acceso de archivos, errores de registro y obtener servicios proporcionados por Visual Studio y los paquetes cargados. Para más información, consulte Acceso a Visual Studio desde una plantilla de texto.

Métodos de escritura

Puede usar los métodos Write() y WriteLine() para anexar texto dentro de un bloque de código estándar, en lugar de usar un bloque de código de expresión. Los dos siguientes bloques de código tienen una función equivalente.

Bloque de código con un bloque de expresión

<#
int i = 10;
while (i-- > 0)
    { #>
        <#= i #>
    <# }
#>

Bloque de código mediante WriteLine()

<#
    int i = 10;
    while (i-- > 0)
    {
        WriteLine((i.ToString()));
    }
#>

Es posible que le resulte útil usar uno de estos métodos de utilidad en lugar de un bloque de expresión dentro de un bloque de código largo con estructuras de control anidadas.

Los métodos Write() y WriteLine() tienen dos sobrecargas, una que toma un único parámetro de cadena y otra que toma una cadena de formato compuesto más una matriz de los objetos que se van a incluir en la cadena (como el método Console.WriteLine()). Los siguientes dos usos de WriteLine() tienen una función equivalente:

<#
    string msg = "Say: {0}, {1}, {2}";
    string s1 = "hello";
    string s2 = "goodbye";
    string s3 = "farewell";

    WriteLine(msg, s1, s2, s3);
    WriteLine("Say: hello, goodbye, farewell");
#>

Métodos de sangría

Puede usar métodos de sangría para dar formato a la salida de la plantilla de texto. La clase TextTransformation tiene una propiedad CurrentIndent de cadena que muestra la sangría actual de la plantilla de texto y un campo indentLengths que es una lista de las sangrías que se han agregado. Puede agregar una sangría con el método PushIndent() y restar una sangría con el método PopIndent(). Si desea quitar todas las sangrías, use el método ClearIndent(). El siguiente bloque de código muestra el uso de estos métodos:

<#
    WriteLine(CurrentIndent + "Hello");
    PushIndent("    ");
    WriteLine(CurrentIndent + "Hello");
    PushIndent("    ");
    WriteLine(CurrentIndent + "Hello");
    ClearIndent();
    WriteLine(CurrentIndent + "Hello");
    PushIndent("    ");
    WriteLine(CurrentIndent + "Hello");
#>

Este bloque de código genera el siguiente resultado:

Hello
        Hello
                Hello
Hello
        Hello

Métodos de error y advertencia

Puede usar métodos de utilidad de error y advertencia para agregar mensajes a la lista de errores de Visual Studio. Por ejemplo, el código siguiente agregará un mensaje de error a la lista de errores.

<#
  try
  {
    string str = null;
    Write(str.Length.ToString());
  }
  catch (Exception e)
  {
    Error(e.Message);
  }
#>

Acceso al host y al proveedor de servicios

La propiedad this.Host puede proporcionar acceso a las propiedades expuestas por el host que ejecuta la plantilla. Para usar this.Host, debe establecer el atributo hostspecific en la directiva <@template#>:

<#@template ... hostspecific="true" #>

El tipo de this.Host depende del tipo de host en el que se ejecuta la plantilla. En una plantilla que se ejecuta en Visual Studio, puede convertir this.Host en IServiceProvider para acceder a servicios como el IDE. Por ejemplo:

EnvDTE.DTE dte = (EnvDTE.DTE) ((IServiceProvider) this.Host)
                       .GetService(typeof(EnvDTE.DTE));

Uso de un conjunto diferente de métodos de utilidad

Como parte del proceso de generación de texto, el archivo de plantilla se transforma en una clase, que siempre se denomina GeneratedTextTransformation y hereda de TextTransformation. Si quiere usar un conjunto diferente de métodos en su lugar, puede escribir su propia clase y especificarla en la directiva de plantilla. La clase abstracta debe heredarse de TextTransformation.

<#@ template inherits="MyUtilityClass" #>

Use la directiva assembly para que haga referencia al ensamblado donde se puede encontrar la clase compilada.