pase un objeto a la plantilla T4

Question

Tengo un objeto u1 de clase User. El usuario tiene un atributo name. ¿Cómo puedo pasar el u1 a una plantilla T4? Estoy tratando de hacer algo muy simple: la escritura

User u1 = new User("John"); 

Plantilla:

Hello <# u1.Name #> 

Answer 1

¿Quieres utilizarlo en su plantilla? Luego debe agregar una referencia al ensamblaje que contiene el tipo. No puedes simplemente pasar la referencia existente al motor T4 a menos que lo alojes tú mismo de una manera muy poco ortodoxa (nunca he visto a nadie que intente hacer esto). E incluso si llegaras tan lejos e hicieras eso, ¿cómo lo manejarías? ¿De dónde se supone que proviene esta referencia?

Usar el tipo de una plantilla T4 es tan fácil como agregar la referencia o copiarla/pegarla en el código de clase <#+ /*stuff goes here*/ #>.

Answer 2

Las plantillas T4 procesan en un solo paso, por lo que la plantilla necesita para obtener todo lo que necesita durante su ejecución allí para que realmente no "Pase" nada en ellas. Dado que la Plantilla es texto, generalmente solo tendré algunos parámetros que el desarrollador puede establecer en la parte superior del archivo. Si necesita la entrada del usuario, puede tener una ventana emergente, pero el hombre que suena molesto al generar el código.

Otra solución es utilizar una plantilla personalizada que utiliza la sustitución de plantilla en su plantilla t4 similar a cómo funcionan muchas de las plantillas instaladas.

Answer 3

Hey - es necesario establecer los valores, etc dentro de la secuencia de comandos T4, por lo que la inicialización User debe ocurrir dentro de la etiqueta <# #>, lo que convertiría que ejemplo en algo similar a

 <# User u1 = new User() { .Name = "John" } #> 
    Hello <# u1.Name #> 

Como se mencionó anteriormente es posible que también necesita importar espacios de nombres He utilizado las declaraciones a continuación en el inicio de un TT-archivo para obtener acceso a System.Data:

 <#@ import namespace="System.Data" #> 
    <#@ import namespace="System.Data.SqlClient" #> 
    <#@ assembly name="System.Data" #> 

Answer 4

Suponiendo que desea tener el código de alguna aplicación o herramienta que finalmente se ejecuta la plantilla, a continuación, utilizando el tiempo de ejecución (preprocesado) las plantillas con propiedades personalizadas definidas en un bloque de función de clase < # + #> o la directiva < # @ parámetro #> debería darle lo que desea.

Tener un vistazo a los documentos aquí: http://msdn.microsoft.com/en-us/library/gg586944.aspx

Answer 5

Hicimos algo similar a esto. Nuestra solución tiene los siguientes elementos:

• host personalizado
• personalizado clase base de la plantilla ("hereda" la propiedad de directiva de plantilla) Plantillas
• host específico (propiedad "hostspecific" de la directiva de plantilla)

El host personalizado se agrega por el objeto que la galería de símbolos quiere invocar en los métodos.

interface ICallbackInterface 
{ 
    void CallbackFxn(); 
} 

[Serializable] 
public class MyCustomHost : ITextTemplatingEngineHost, ITextTemplatingSessionHost, IStencilFileRecordManagement 
{ 

    private ICallbackInterface callback = null; 
    public MyCustomHost(ICallbackInterface cb) 
    { 
     callback = cb; 
    } 

    public void CallbackFxn() 
    { 
     callback.CallbackFxn(); 
    } 
} 

public abstract class MyTemplateBase : TextTransformation 
{ 
    public virtual MyCustomHost CustomHost 
    { 
     get 
     { 
      dynamic metame = this; 
      MyCustomHost rval = null; 
      try 
      { 
       /// <summary> 
       /// The "Host" property will be added to the generated class by the T4 environment whenever a 
       /// "hostspecific" template is processed. 
       /// </summary> 
       rval = metame.Host as MyCustomHost; 
      } 
      catch (RuntimeBinderException e) 
      { 
       logger.ErrorException(
        "Received the following exception while processing a stencil template", e); 

      } 
      return rval; 
     } 
    } 
} 

Ahora, en alguna de nuestras plantillas, podemos invocar métodos en el objeto que realmente se inició el tratamiento mediante la propiedad de host personalizado, por ejemplo:

<# CustomHost.CallbackFxn(); #> 

Además, no utilizamos T4 en VS o usando un archivo ejecutable por separado: enlazamos con los ensamblajes Microsoft.VisualStudio.TextTemplating.10.0 y Microsoft.VisualStudio.TextTemplating.Interfaces.10.0.

EDITAR

Estamos utilizando plantillas T4 permiten a los usuarios definir sus propios plugins para su uso en un paso en particular en nuestro flujo de trabajo producto. Por lo que las plantillas de usuario se cargan en nuestro sistema, y ​​se procesan de esta manera:

using Microsoft.VisualStudio.TextTemplating; 

class UserPluginWorkflowComponent : ICallbackInterface 
{ 
    public void CallbackFxn() 
    { 
     // invoked by user plugin 
    } 

    public void ExecuteUserPlugin() 
    { 
     MyCustomHost host = new MyCustomHost(this); 
     host.TemplateFileValue = "UserPluginTemplateFilename"; 
     Engine engine = new Engine(); 
     string pluginResult = engine.ProcessTemplate(
      userPluginTemplateFileContents, 
      host);    
     if (!host.Errors.HasErrors) 
     { 
      // use pluginResult in some meaningful way 
     } 
    } 
}