Il presente articolo è stato tradotto automaticamente.

Modelli T4

Gestione della complessità in soluzioni per la generazione di modelli T4

Peter Vogel

 

Nel mio articolo, "Abbassando le barriere per codice generazione con T4" nel numero di aprile di MSDN Magazine (msdn.microsoft.com/magazine/hh882448), ho descritto come Microsoft Text Template Toolkit trasformazione (T4) rende molto più facile per gli sviluppatori di creare soluzioni di generazione del codice (e come si può iniziare a riconoscere le opportunità di generazione del codice). Tuttavia, come con qualsiasi ambiente di programmazione, soluzioni T4 possono crescere in soluzioni complesse, monolitici che non possono essere mantenute o esteso. Evitando che il destino è necessario riconoscere i vari modi in cui codice nelle soluzioni T4 può essere soluzioni refactoring e integrato nella generazione di codice. E che richiede di comprendere un po' meglio il processo di generazione del codice T4.

T4 Processo di generazione del codice

Il cuore del processo di generazione del codice T4 è il motore T4, che accetta un modello T4 costituito codice standard, blocchi di controllo, funzionalità di classe e delle direttive. Da questi ingressi, il motore viene creata una classe temporanea (la "classe di trasformazione generata") che eredita dalla classe Microsoft TextTransformation. Un dominio dell'applicazione viene quindi creato e, in tale dominio, la classe di trasformazione generata viene compilata ed eseguita per produrre l'output che potrebbe essere qualsiasi cosa, da una pagina HTML di un programma c#.

Il testo testo standard e i blocchi di controllo nel modello sono incorporati in un singolo metodo (chiamato TransformText) nella classe trasformazione generata. Tuttavia, il codice nella funzionalità di classe (racchiuso in < # + … # > i delimitatori) non siano immessi in quel metodo — codice classe caratteristica viene aggiunto alla classe di trasformazione generata di fuori di qualsiasi metodo che crea il processo T4. Nel mio articolo precedente, per esempio, ho usato un blocco di funzionalità di classe per aggiungere un oggetto ArrayList — dichiarò di fuori di qualsiasi metodo — alla classe trasformazione generata. Quindi accedere a quel ArrayList in blocchi di controllo della mia generazione codice come parte del processo di generazione del codice. Oltre ad aggiungere campi, come ArrayList, funzionalità di classe può anche essere utilizzato per aggiungere metodi privati che possono essere chiamati da vostri blocchi di codice.

Il motore è il cuore del processo, ma due altri componenti anche partecipano al processo di generazione del codice T4: il processore di direttiva e l'host. Direttive forniscono un modo basata su parametri per aggiungere codice o altrimenti controllo del processo. Ad esempio, la direttiva Import T4 dispone di un parametro di Namespace per la creazione di un'istruzione using o le importazioni della classe trasformazione generata. la direttiva Include ha un parametro di file per il recupero da un altro file di testo e l'aggiunta alla classe trasformazione generata. Il processore di direttiva predefinita gestisce le direttive che vengono con T4.

Il processo di generazione del codice T4 ha anche bisogno di un host per integrare il processo con il motore è in esecuzione in ambiente. L'host, ad esempio, fornisce un insieme standard di assembly e di spazi dei nomi al motore di modo che non tutti gli assembly di codice della classe trasformazione generata ha bisogno devono essere specificati nel modello. Quando richiesto dal motore o il processore di direttiva, l'host aggiunge riferimenti agli assembly. Recupera (e a volte si legge) i file per il motore; e possono anche recuperare i processori di direttiva personalizzate o fornire valori predefiniti per le direttive cui parametri sono stati omessi. L'host fornisce anche l'oggetto AppDomain la classe trasformazione generata viene eseguito e visualizza qualsiasi errore e i messaggi di avviso generati dal motore. Visual Studio può ospitare il motore T4 (tramite lo strumento personalizzato TextTemplatingFileGenerator), come può l'utilità della riga di comando di TextTransform che elabora modelli T4 di fuori di Visual Studio.

Come un esempio di questo processo, prendere guardare il modello T4 con una combinazione di codice statico, blocchi di controllo e una classe funzione indicati nella Figura 1.

Figura 1 modello di esempio T4

<#@ template language="VB" #>
public partial class ConnectionManager
{
<#
  For Each conName As String in Connections
#>
  private void <#= conName #>(){}
<#
  Next
#>
<#+
  Private Function GetFormattedDate() As String
    Return DateTime.Now.ToShortDateString()
  End Function
#>

La classe trasformazione generata apparirebbe qualcosa di simile a ciò che viene mostrato Figura 2.

Figura 2 la classe di trasformazione generata

Public Class GeneratedTextTransformation
  Inherits Microsoft.VisualStudio.TextTemplating.TextTransformation
  Public Overrides Function TransformText() As String
    Me.Write("public partial class ConnectionManager{")
    For Each conName As String in Connections
      Me.Write("private void ")
      Me.Write(Me.ToStringHelper.ToStringWithCulture(conName))
      Me.Write("(){}")    
    Next
  End Function
  Private Function GetFormattedDate() As String
    Return DateTime.Now.ToShortDateString()
  End Fuction
End Class

Data questa descrizione del processo di generazione del codice T4, può rifattorizzare soluzioni potenzialmente monolitici in più componenti gestibile utilizzando uno qualsiasi di questi tre opzioni:

1. Funzionalità di classe
2. Estendere la classe di base TextTransformation
3. Processori di direttiva personalizzati

Questi meccanismi consentono di riutilizzare il codice attraverso molteplici soluzioni di generazione del codice. Per dimostrare queste opzioni si utilizzerà un banalmente semplice caso di studio: aggiunta di una nota di copyright per il codice generato. La "meta-ness" di scrivere del codice per generare il codice crea sufficiente complessità senza raccogliendo un complicato caso di studio — può farlo per conto proprio.

Almeno, c'è un'altra opzione che non ho intenzione di discutere: così è possibile richiamare le caratteristiche specifiche dell'host dal tuo modello T4, sviluppando il proprio ospite. Creazione di un nuovo ospite è veramente necessaria solo se si intende richiamare l'elaborazione T4 da esterno di Visual Studio e non desidera utilizzare lo strumento da riga di comando di TextTransform.

Funzionalità di classe

Classe funzionalità offrono il modo più semplice di riduzione della complessità nel processo di T4 e riutilizzo del codice. Funzionalità di classe consentono di incapsulare le parti del vostro processo di generazione del codice nei metodi che può essere chiamato dal metodo TransformText che forma la linea "principale" del codice. È anche possibile sfruttare la direttiva Include riutilizzare le funzionalità di classe attraverso molteplici soluzioni.

Il primo passo per utilizzare una funzionalità di classe è quello di aggiungere un file T4 al progetto che contiene le caratteristiche di classe che si desidera riutilizzare in molteplici soluzioni di generazione del codice, racchiusi tra il T4 < # + … # > delimitatori. Questo può includere metodi, proprietà e campi. I file di modello possono contenere anche funzionalità T4-specifiche quali direttive. Poiché il file è ancora un file T4, esso genera codice che verrà compilato nell'applicazione, quindi si deve omettere la generazione del codice per il file. Il modo più semplice per farlo è quello di cancellare la proprietà strumento personalizzato dei tuoi file di funzionalità di classe. In questo esempio viene definito un metodo denominato ReturnCopyright come una caratteristica di classe, scritta in Visual Basic:

<#+
 Public Function ReturnCopyright() As String
   Return "Copyright by PH&V Information Services, 2012"
 End Function
#>

Una volta che hai definito una funzionalità di classe, è possibile aggiungere a un modello utilizzando la direttiva Include e utilizzare la funzionalità di un controllo blocco in un modello T4. Nell'esempio successivo, che si presuppone che la precedente funzionalità di classe è stata definita in un file chiamato CopyrightFeature.tt, utilizza il metodo ReturnCopyright come un'espressione:

<#@ Template language="VB"   #>
<#@ Output extension=".generated.cs" #>
<#= ReturnCopyright() #>
<#@ Include file="CopyrightFeature.tt" #>

In alternativa, è possibile utilizzare semplicemente la sintassi standard normali T4 per generare codice simile:

<#+
  Public Function ReturnCopyright() As String
#>
  Copyright by PH&V Information Services, 2012
<#+
  End Function
#>

È anche possibile utilizzare i metodi Write e WriteLine all'interno della vostra caratteristica di classe per generare il codice, come fa questa caratteristica di classe:

<#+
  Public Sub WriteCopyright()
    Write("Copyright by PH&V Information Services, 2012")
  End Function
#>

I due approcci di quest'ultimi sarebbero utilizzare il codice seguente per chiamare il metodo una volta una direttiva Include ha aggiunto al modello:

<# WriteCopyright() #>

È possibile parametrizzare insieme Margherita caratteristiche e funzionalità di classe utilizzando gli argomenti della funzione normale utilizzando la direttiva Include nel file T4 che sono essi stessi incluso in altri file T4 per costruire una libreria, ben strutturata e riutilizzabile.

Rispetto alle altre soluzioni, utilizzando le funzionalità di classe ha almeno un vantaggio e uno svantaggio. Si verifica il vantaggio quando si sviluppa la vostra soluzione di generazione del codice: classe caratteristiche (e comprende in generale) non comportano l'assembly. Per motivi di prestazioni, il motore T4 può bloccare gli assembly che utilizza durante il caricamento della classe trasformazione generata nel suo dominio applicazione. Ciò significa che come testare e modificare il codice compilato, si potrebbe trovare non può sostituire gli assembly pertinenti senza arrestare e riavviare Visual Studio. Questo non accadrà con funzionalità di classe. Si noti che questo è stato affrontato in Visual Studio 2010 SP1, che non è più blocca gli assembly.

Gli sviluppatori possono incontrare l'inconveniente, però, quando utilizzano la vostra soluzione di generazione del codice: Deve aggiungono non solo il modello T4 per il loro progetto, ma anche tutti i vostri T4 includere file di supporto. Questo è uno scenario dove si potrebbe considerare di creazione di un modello di Visual Studio che contiene tutti i file T4 uno sviluppatore ha bisogno per la soluzione di generazione del codice in modo che può essere aggiunto come gruppo. Inoltre sarebbe sensato per segregare i file inclusi in una cartella all'interno della soluzione. Nell'esempio seguente viene utilizzata la direttiva Include per aggiungere un file che contiene le funzionalità di classe da una cartella di modelli:

<#@ Include file="Templates\classfeatures.tt" #>

Non, sono naturalmente, limitata al solo usando la funzionalità di classe nel file Include — è possibile includere qualsiasi insieme arbitrario di blocchi di controllo e il testo che si desidera essere incorporato il metodo TransformText della classe trasformazione generata. Tuttavia, come evitare Goto, utilizzando i membri ben definiti nel file Include aiuta a gestire la complessità concettuale della soluzione.

Si estende la classe TextTransformation

Sostituendo la classe TextTransformation con una classe personalizzata consente di incorporare funzionalità personalizzate nei metodi in quella classe che può essere chiamato nella classe trasformazione generata. Si estende la classe TextTransformation è una buona scelta quando si dispone di codice che verrà utilizzato in molti (o tutte) delle vostre soluzioni di generazione del codice: in sostanza, si fattore che il codice fuori le soluzioni e nel motore T4.

Il primo passo che estende la classe TextTransformation è quello di creare una classe astratta che eredita dalla classe:

public abstract class PhvisT4Base:
  Microsoft.VisualStudio.TextTemplating.TextTransformation
{
}

Se non avete la DLL Microsoft.VisualStudio.TextTemplating che contiene la classe TextTransformation, scaricare il SDK per la versione di Visual Studio prima di aggiungere il riferimento.

In base alla vostra versione di T4, potrebbe essere necessario fornire un'implementazione del metodo TransformText come parte dell'eredità da TextTransformation. Se così, il metodo deve restituire la stringa contenente l'output della classe trasformazione generata, che si tiene nella classe TextTransformation generazione­proprietà di ambiente. L'override del metodo TransformText, se necessario, dovrebbe essere simile a questo:

public override string TransformText()
{
  return this.GenerationEnvironment.ToString();
}

Come con funzionalità di classe, si hanno due opzioni per l'aggiunta di codice per la classe di trasformazione generata. È possibile creare metodi che restituiscono valori stringa, come fa questo esempio:

protected string Copyright()
{
  return @"Copyright PH&V Information Services, 2012";
}

Questo metodo può essere utilizzato in un'espressione o con i metodi T4 scrivere o WriteLine, come nei seguenti esempi:

<#= CopyRight() #>
<#  WriteLine(CopyRight()); #>

In alternativa, è possibile utilizzare i metodi Write o WriteLine del classe base di TextTransformation direttamente nei metodi che aggiungere alla classe base TextTransformation, come fa questo esempio:

protected void Copyright()
{
  base.Write(@"Copyright PH&V Information Services, 2012");
}

Questo metodo può essere chiamato poi da un blocco di controllo, come questo:

<# CopyRight(); #>

Il passaggio finale nel sostituire la classe TextTransformation predefinita consiste nello specificare nel tuo modello T4 che la classe trasformazione generata è ereditare dalla nuova classe. Farlo con il parametro Inherits dell'attributo Template:

<#@ Template language="C#" inherits="PhvT4Utils.PhvisT4Base" #>

Deve anche aggiungere al modello T4 una direttiva assembly che fa riferimento la DLL contenente la classe base, usando il nome del percorso fisico completo della dll:

<#@ Assembly name="C:\T4Support\PhvT4Utils.dll" #>

In alternativa, è possibile aggiungere la classe base alla global assembly cache (GAC).

In Visual Studio 2010, è possibile utilizzare variabili macro e ambiente per semplificare il percorso della DLL. Per esempio, durante lo sviluppo, si potrebbe utilizzare la macro projectdir per la DLL contenente la classe base di riferimento:

<#@ Assembly name="$(ProjectDir)\bin\PhvT4Utils.dll" #>

In fase di esecuzione, supponendo che si installa i file di classe nella cartella Program Files, è possibile utilizzare l'ambiente variabile % programfiles % sulle versioni a 32 bit di Windows, o in versioni a 64 bit, % ProgramW6432% per la cartella programmi o % ProgramFiles (x86) % per i file di programma (x86) cartella. In questo esempio si presuppone che la DLL è stato messo in C:\Program Files\PHVIS\T4Tools su una versione a 64 bit di Windows:

<#@ Assembly name="%ProgramW6432%\PHVIS\T4Tools\PHVT4Utils.DLL" #>

Come con altre soluzioni con la compilazione del codice, Visual Studio potrebbe bloccare la DLL contenente il codice durante l'esecuzione della classe trasformazione generata. Se questo accade mentre si sta sviluppando la classe TextTransformation, sarà necessario riavviare Visual Studio — e ricompilare il codice — prima di poter apportare ulteriori modifiche.

Intestazione laterale: Errori e avvisi

Qualsiasi processo robusto fornisce feedback sui progressi compiuti. In una caratteristica di classe o quando si estende la classe TextTransformation, è possibile segnalare problemi nell'esecuzione della classe trasformazione generata aggiungendo chiamate alla classe TextTransformation errore e di avviso metodi. Entrambi i metodi accettano una singola stringa di input e passare la stringa all'host Microsoft Text Template trasformazione Toolkit (T4) (l'host è responsabile per decidere come visualizzare i messaggi). In Visual Studio, i messaggi vengono visualizzati nella finestra Elenco errori.

Questo esempio segnala un errore in una caratteristica di classe:

< # = GetDatabaseData("") # >
< # + private string GetDatabaseData (string ConnectionString)
{
Se (ConnectionString = = "")
    {
base.Errore ("nessuna stringa di connessione fornito.");
    }
  return "";
    }
...

In una funzione di classe, errore e avviso non può essere utilizzato per relazione sui problemi nel processo di T4, solo su errori che si verificano quando la classe trasformazione generata viene eseguito. Per dirla presentano un altro modo, in una classe, i messaggi di errore e di avviso verranno visualizzati solo se la classe trasformazione generata può essere montata correttamente dal tuo file T4, compilato ed eseguito.

Se si sta creando un processore di direttiva personalizzato, è possibile integrare ancora con il T4 errore segnalato il processo con l'aggiunta del compilatore­oggetti errore alla classe proprietà Errors. L'oggetto CompilerError supporta passando più pezzi di informazioni sull'errore (tra cui linea numero e il nome file), ma questo esempio semplicemente imposta la proprietà ErrorText:

System.CodeDom.Compiler.CompilerError err = new 
  System.CodeDom.Compiler.CompilerError();
peccare per eccesso.ErrorText = "Missing direttiva parametro";
ciò.Errors.Add(Err);

          — P.V.

Processori di direttiva personalizzato

Il modo più potente e flessibile per gestire la complessità del processo di generazione del codice è di utilizzare processori di direttiva personalizzati. Tra le altre caratteristiche, processori di direttiva possono aggiungere riferimenti alla classe trasformazione generata e inserire del codice in metodi che vengono eseguite prima e dopo il metodo TransformText della classe trasformazione generata. Le direttive sono anche facile per gli sviluppatori di utilizzare: Essi hanno solo fornire i valori per i parametri della direttiva e quindi utilizzare i membri di che mettono a disposizione le direttive.

Il problema principale con processori di direttiva è che è necessario aggiungere una chiave del Registro di sistema di Windows in modo che uno sviluppatore di utilizzare il processore. Qui, ancora una volta, vale la pena di considerare imballaggio fino T4 soluzione affinché la voce del Registro di sistema può essere fatta automaticamente. Sulle versioni a 32 bit di Windows, la chiave deve essere:

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\
  visualstudioversion\TextTemplating\DirectiveProcessors

Per le versioni a 64 bit di Windows, la chiave è:

HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\
  VisualStudio\10.0\TextTemplating\DirectiveProcessors

Il nome della tua chiave è il nome della classe del processore di direttiva che, seguendo la convenzione di denominazione di Microsoft, dovrebbe terminare con "DirectiveProcessor." Avrete bisogno di seguenti sottochiavi:

• Valore predefinito: Vuoto o una descrizione della vostra direttiva.
• Classe: Il nome completo della classe nel formato namespace. ClassName.
• Assemblaggio/base di codice: Il nome della DLL se hai inserito DLL della vostra direttiva nella Global Assembly Cache (Assembly) o il percorso completo DLL della vostra direttiva (CodeBase).

Quando si sviluppa il tuo processore, se non si ottiene questa voce giusta, Visual Studio verrà generato un errore che era impossibile trovare il vostro processore di direttiva o risolvere il relativo tipo. Dopo correggere eventuali errori nel tuo voci del Registro di sistema, potrebbe essere necessario riavviare Visual Studio per raccogliere le modifiche.

Per utilizzare il vostro processore di direttiva, uno sviluppatore aggiunge una direttiva con qualsiasi nome a un modello T4 e legami la direttiva per il processore tramite parametro di processore della direttiva (che fa riferimento la chiave del Registro di sistema di Windows). Quando viene eseguito il modello T4, processore di direttiva viene passato il nome della direttiva che lo sviluppatore utilizzato insieme con tutti i parametri sviluppatore specificato.

In questo esempio si lega una direttiva denominata Copyright a un processore chiamato CopyrightDirectiveProcessor e include un parametro denominato anno:

<#@ Copyright Processor="CopyrightDirectiveProcessor" Year=”2012” #>

Come con una caratteristica di classe, l'uscita da un processore di direttiva viene aggiunto alla classe di trasformazione generata di fuori del metodo TransformText. Come risultato, si utilizzerà il processore per aggiungere nuovi membri alla classe trasformazione generata che devel­pers può utilizzare nei loro blocchi di controllo del modello. La direttiva precedente campione potrebbe hanno aggiunto una proprietà o una variabile stringa che uno sviluppatore potrebbe usare in un'espressione, come questo:

<#= Copyright #>

Naturalmente, il passaggio successivo è creare una direttiva processo al processo presente direttiva.

Creazione di un processore di direttiva Custom

I processori di direttiva T4 ereditano dalla classe Microsoft.VisualStudio.TextTemplating.DirectiveProcessor (Scarica Visual Studio SDK per ottenere la libreria TextTemplating). Processore di direttiva deve, dal relativo metodo GetClassCodeForProcessingRun, restituire il codice che verrà aggiunto alla classe di trasformazione generata. Tuttavia, prima di chiamare il metodo GetClassCodeForProcessingRun, il motore T4 chiamerà IsDirective del processore­supportato metodo (passando il nome del vostro direttiva) e il metodo ProcessDirective (passando il nome della direttiva e i valori dei parametri del). Dal metodo IsDirectiveSupported, deve restituire false se la direttiva non dovrebbe essere eseguito e vero altrimenti.

Perché il metodo ProcessDirective viene passato tutte le informazioni circa la direttiva, che è in cui di solito sviluppare il codice che restituirà il GetClassCodeForProcessingRun. È possibile estrarre i valori dei parametri specificati nella direttiva leggendo dal secondo parametro del metodo (chiamato argomenti). Questo codice nel metodo ProcessDirective, cerca un parametro denominato anno e viene utilizzato per costruire una stringa che contiene una dichiarazione di variabile. La stringa viene quindi restituita da GetClassCodeForProcessingRun:

string copyright = string.Empty;
public override void ProcessDirective(
  string directiveName, IDictionary<string, string> arguments)
{
  copyright = "string copyright " +
              "= \"Copyright PH&V Information Services, " +
              arguments["Year"] +"\";";
}
public override string GetClassCodeForProcessingRun()
{
  return copyright;
}

Processore di direttiva anche aggiungere riferimenti e utilizzando /­importare le istruzioni per la classe di trasformazione generata per supportare il codice aggiunto attraverso GetClassCodeForProcessingRun. Per aggiungere i riferimenti alla classe trasformazione generata, solo bisogno di restituire i nomi delle librerie in una matrice di stringhe dal metodo GetReferencesForProcessingRun. Se, ad esempio, il codice viene aggiunto alla classe di trasformazione generata necessarie classi dello spazio dei nomi System. xml, utilizzare codice simile al seguente:

public override string[] GetReferencesForProcessingRun()
{
  return new string[] {"System.Xml"};
}

Analogamente, è possibile specificare gli spazi dei nomi da aggiungere alla classe (come sia utilizzando o le istruzioni Imports) trasformazione generata da una matrice di stringhe di ritorno dal metodo GetImportsForProcessingRun.

La classe di trasformazione del codice generato include anche pre- e post-initialization metodi che sono chiamati prima del metodo TransformText. È possibile restituire il codice che verrà aggiunto a quei metodi dai metodi GetPreInitializationCodeForProcessingRun e GetPostInitializationCodeForProcessingRun.

Come esegue il debug, ricordare che usando strumento personalizzato eseguito non causi Visual Studio per generare la soluzione. Come si apportano modifiche al processore di direttiva, è necessario generare la soluzione a raccogliere le ultime modifiche prima dell'esecuzione del modello. E, ancora una volta, perché T4 blocca gli assembly che utilizza, si potrebbe trovare che devi riavviare Visual Studio e ricompilare il codice prima di riprovare.

T4 riduce significativamente le barriere per l'integrazione di generazione del codice nel vostro toolkit. Tuttavia, come con qualsiasi altra applicazione, è necessario considerare come voi avrete architetto soluzioni complete per supportare la gestibilità e l'estensibilità. Il processo di generazione del codice T4 fornisce diverse località — ognuno con i propri costi e benefici — dove potrete effettuare il refactoring del codice e inserirlo nel processo. Non importa quale meccanismo si utilizza, si ti garantisce che le soluzioni T4 si sono ritrovate.

Intestazione laterale: Utilizzando T4 in fase di esecuzione

È possibile ottenere un assaggio di quello che la classe trasformazione generata assomiglia sfruttando di pre-elaborato modelli di testo, che ti permette di generare testo in fase di esecuzione. La compilazione o l'esecuzione dei risultati di Microsoft Text Template trasformazione Toolkit (T4) la generazione di codice in fase di esecuzione è probabilmente non qualcosa che maggior parte degli sviluppatori vorrebbe affrontare. Tuttavia, se avete bisogno di diverse versioni "simili ma diverse" di un XML o un documento HTML (o qualche altro testo), modelli di testo pre-elaborati consentono di utilizzare T4 per generare tali documenti in fase di esecuzione.

Come con altre soluzioni T4, il primo passo per utilizzare T4 in fase di esecuzione è quello di aggiungere un file T4 al progetto dalla finestra di dialogo nuovo elemento. Ma, invece di aggiungere un file modello di testo, aggiungere un modello di testo pre-elaborato (anche elencati nella finestra di dialogo nuovo elemento di Visual Studio). Un modello di testo pre-elaborato è identico a un file modello di testo T4 standard, tranne per il fatto che la proprietà strumento personalizzato è impostata su TextTemplatingFileProcessor, anziché il solito TextTemplatingFileGenerator.

A differenza con un modello di testo, file bambino che contiene il codice generato da un modello di testo pre-elaborato non contiene l'output del codice dalla classe trasformazione generata. Al contrario, il file contiene qualcosa che assomiglia molto ad una delle classi di trasformazione generata: una classe con lo stesso nome del file del modello di testo pre-elaborato con un metodo chiamato TransformText. Chiamata a quel metodo TransformText in fase di esecuzione ritorni, come stringa, che cosa si aspetterebbe di trovare nel file di codice di un modello T4: il codice generato. Così, per un modello di testo pre-elaborato file chiamato GenerateHTML, recuperare il testo generato utilizzando il codice di questo tipo in fase di esecuzione:

GenerateHTML HtmlGen = GenerateHTML() nuovo;
stringa html = HtmlGen.TransformText();

      — P.V.

Peter Vogel è dei principali in PH e servizi di informazione di V. Il suo ultimo libro è stato "generazione codice pratica nei.NET"(Addison-Wesley Professional, 2010). PH & V Information Services è specializzata nel facilitare la progettazione di architetture basate su servizi e nell'integrazione.NET technologies in quelle architetture. Oltre alla sua pratica consulenza, Vogel ha scritto corso di apprendimento albero International service-oriented architecture design, ha insegnato in tutto il mondo.

Grazie all'esperto tecnica seguente per la revisione di questo articolo: Gareth Jones