Dieser Artikel wurde maschinell übersetzt.

T4-Vorlagen

Umgang mit Komplexität in T4 Codegenerierungslösungen

Peter Vogel

 

In meinem Artikel "Senkung der Barrieren zu Code Generation mit T4" in der April-Ausgabe des MSDN Magazins (msdn.microsoft.com/magazine/hh882448), ich beschrieben, wie das Microsoft Text Template Transformation Toolkit (T4) viel macht es für Entwickler einfacher, Code Generation Lösungen (und wie sie beginnen können Codegenerierung Chancen erkennen) zu erstellen. Wie bei jede Programmierumgebung können T4 Lösungen jedoch in komplexen, monolithischen Lösungen wachsen, die beibehalten oder ausgeweitet werden kann. Dieses Schicksal zu vermeiden erfordert erkennen die verschiedenen Möglichkeiten, die Code in T4-Lösungen-Lösungen integriert und umgestalteten Code Generation sein kann. Und das erfordert ein Verständnis der T4 Code-Generierung.

T4 Code-Generierung

Das Herz der T4 Code-Generierung ist die T4-Engine, die eine T4-Vorlage bestehend aus Standardcode, Steuerblöcke, Klasse Funktionen und Richtlinien akzeptiert. Aus dieser Eingaben erstellt die Engine eine temporäre Klasse ("Class generierten Transformation"), die von der Microsoft TextTransformation-Klasse erbt. Anschließend wird eine Anwendungsdomäne erstellt, und in dieser Domäne, die generierte Umwandlung-Klasse kompiliert und ausgeführt, um die Ausgabe zu produzieren, die alles von einer HTML-Seite in einem C#-Programm möglicherweise.

Die Textbausteine und Steuerblöcke in der Vorlage sind eine einzelne Methode (TransformText genannt) in der Transformationsklasse generierten integriert. Jedoch der Code in Funktionen der Unternehmensklasse (eingeschlossen < # + … # > Trennzeichen) befinden sich nicht in dieser Methode — die Klasse generierte Umwandlung außerhalb der Methoden der T4-Prozess erstellt wird Klasse Funktion Code hinzugefügt. In meinem früheren Artikel, zum Beispiel, ich verwendet einen Klasse Featureblock eine ArrayList hinzufügen — deklariert außerhalb einer beliebigen Methode — zur Transformationsklasse generierte. Ich zugegriffen dann die ArrayList in meine Codegenerierung Kontrollblöcke als Teil des Prozesses den Code zu generieren. Zusätzlich zum Hinzufügen von Feldern, wie ArrayList, können Funktionen der Unternehmensklasse auch verwendet werden, um private Methoden hinzuzufügen, die von Ihrem Code-Blöcke aufgerufen werden können.

Der Motor ist das Herzstück des Prozesses, aber zwei andere Komponenten auch die T4 Code-Generierung beteiligt: die Richtlinie Prozessor und dem Host. Richtlinien können Parametermessgrößen – Hinzufügen von Code oder anderweitig Kontrolle den Prozess. Die T4-Import-Direktive hat beispielsweise einen Namespace-Parameter für eine using- oder Imports-Anweisung in der generierten Transformationsklasse erstellen; die Include-Direktive hat einen Datei-Parameter zum Abrufen von Text aus einer anderen Datei und die generierte Umwandlung-Klasse hinzufügen. Der standardmäßige Richtlinie Prozessor verarbeitet die Richtlinien, die mit T4 kommen.

T4 Code-Generierung benötigt auch einen Host, den Prozess mit der Umgebung zu integrieren, die das Modul ausgeführt wird. Der Host bietet beispielsweise einen Standardsatz von Assemblys und Namespaces, die Engine, so dass nicht alle Assemblys, die die generierte Klasse Transformationscode muss in der Vorlage angegeben werden. Wenn der Motor oder die Direktivenprozessor angefordert, hinzugefügt der Host Verweise auf Assemblys; Ruft (und manchmal liest) Dateien für das Modul; und können sogar benutzerdefinierte Richtlinie Prozessoren abrufen oder stellen Standardwerte für Richtlinien, deren Parameter wurden weggelassen. Der Host bietet auch die AppDomain Klasse generierte Umwandlung führt und zeigt alle Fehler und Warnmeldungen, die vom Modul generiert. Visual Studio kann den T4 Motor (durch das benutzerdefinierte Tool TextTemplatingFileGenerator), host, wie das TextTransform-Befehlszeile-Dienstprogramm, das T4-Vorlagen außerhalb von Visual Studio verarbeitet.

Als ein Beispiel für diesen Prozess, nehmen Sie Blick auf die T4-Vorlage mit einer Kombination von statischen, Steuerblöcke und einer Klasse verfügen in gezeigt Abbildung 1.

Abbildung 1 Beispiel-T4-Vorlage

<#@ 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
#>

Klasse generierte Umwandlung würde aussehen wie in Abbildung 2.

Abbildung 2 die Klasse generierte Umwandlung

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

Da diese Beschreibung der T4 Code-Generierung, können Sie potenziell monolithische Lösungen in mehr verwaltbaren Bestandteile Verwendung aller dieser drei Optionen umgestalten:

1. Funktionen der Unternehmensklasse
2. Erweitern die Basisklasse TextTransformation
3. Benutzerdefinierte Richtlinie Prozessoren

Diese Mechanismen können auch Code in mehrere Codegenerierung Lösungen wiederzuverwenden. Diese Optionen zeigen verwende ich eine trivial einfache Fallstudie: der generierte Code hinzufügen einen copyright-Vermerk. Die "Meta-Ness" Schreiben von Code zum Generieren von Code erzeugt genug Komplexität ohne eine komplizierte Fallstudie — können Sie dies auf eigene Faust.

Zumindest gibt es eine andere Option, die ich nicht zu diskutieren: entwickeln Ihre eigenen Host, damit Sie Host-spezifische Features aus der T4-Vorlage aufrufen können. Erstellen einen neuen Host ist wirklich notwendig, nur wenn Sie T4 Verarbeitung von außerhalb von Visual Studio aufrufen wollen und nicht das TextTransform-Befehlszeilentool verwenden möchten.

Funktionen der Unternehmensklasse

Klasse Features bieten die einfachste Möglichkeit der Verringerung der Komplexität in Ihren T4-Prozess und die Wiederverwendung von Code. Klasse Features können Sie Teile Ihrer Code-Generierung in Methoden gekapselt, die Sie von die TransformText-Methode aufrufen können, die der "Hauptstrecke" des Codes bildet. Nutzen Sie auch die Include-Direktive, Klasse Funktionen in mehrere Lösungen wiederzuverwenden.

Der erste Schritt in eine Klasse Funktion ist es, Ihr Projekt mit den Funktionen die Klasse in mehrere Codegenerierung Lösungen, eingeschlossen in die T4 wiederverwenden möchten eine T4-Datei hinzufügen < # + … # > Trennzeichen. Dies kann Methoden, Eigenschaften und Felder einschließen. Die Vorlagendateien können auch T4-spezifische Features wie z. B. Richtlinien enthalten. Weil Ihr noch eine T4-Datei handelt, wird Code generiert, die in Ihre Anwendung kompiliert wird, sodass Sie Code-Generierung für die Datei unterdrücken sollten. Der einfachste Weg, dies zu tun ist, deaktivieren Sie die Eigenschaft Benutzerdefiniertes Tool Ihrer Klasse Feature-Dateien. In diesem Beispiel wird definiert eine Methode namens ReturnCopyright als Klasse Feature in Visual Basic geschrieben:

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

Sobald Sie ein Klasse Feature definiert haben, können Sie sie hinzufügen, um eine Vorlage unter Verwendung der Include-Direktive und die Funktion von einem Steuerelement block in einer T4-Vorlage verwenden. Das nächste Beispiel wird davon ausgegangen, dass die früheren Klasse-Funktion in eine Datei namens CopyrightFeature.tt definiert wurde, verwendet die ReturnCopyright-Methode als Ausdruck.

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

Alternativ können Sie einfach die T4 normal vorformulierten Syntax verwenden, um ähnlichen Code zu generieren:

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

Sie können die Methoden Write und WriteLine innerhalb Ihrer Klasse Feature auch zum Generieren von Code, wie diese Klasse Funktion:

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

Die letzteren beiden Ansätze würde den folgenden Code verwenden, um die Methode aufzurufen, sobald es eine Include-Direktive der Vorlage hinzugefügt:

<# WriteCopyright() #>

Sie können parametrisieren Klasse mit normalen Funktionsargumente und Features Reihenschaltung zusammen, indem Sie die Include-Direktive in T4-Dateien, die sich in anderen T4-Dateien zum Aufbau einer gut strukturierten und wiederverwendbaren Bibliothek enthalten sind.

Im Vergleich zu anderen Lösungen, hat mit Klasse Funktionen, mindestens einen Vorteil und einen Nachteil. Sie erleben den Vorteil, wie Sie Ihre Code-Lösung entwickelt: Klasse Funktionen (und enthält im allgemeinen) beinhalten nicht kompilierten Assemblys. Aus Performance-Gründen kann der T4 Motor die Assemblys sperren, die es verwendet, wenn es Klasse generierte Umwandlung in die Anwendungsdomäne geladen. Dies bedeutet, dass Sie testen und ändern Sie kompilierten Code, Sie finden, dass Sie die entsprechenden Assemblys ohne Herunterfahren und Neustart von Visual Studio nicht ersetzen können. Dies wird nicht passieren, mit Klasse Funktionen. Beachten Sie, dass dies in Visual Studio 2010 SP1, beseitigte die Assemblys nicht mehr sperren.

Entwickler können jedoch den Nachteil, auftreten, wenn sie Ihre Code-Generation-Lösung verwenden: Sie müssen nicht nur die T4-Vorlage ihres Projekts, sondern auch alle die T4 sind Hilfsdateien hinzufügen. Dies ist ein Szenario, in dem Sie könnte prüfen, Erstellen einer Visual Studio-Vorlage, die alle die T4-Dateien, die ein Entwickler für die Codegenerierung Projektmappe benötigt, so dass sie als Gruppe hinzugefügt werden können. Es wäre auch sinnvoll zu Ihrer Include-Dateien in einen Ordner innerhalb der Projektmappe zu trennen. Im folgenden Beispiel wird die Include-Direktive fügen Sie eine Datei, die Funktionen der Unternehmensklasse aus einem Ordner namens Vorlagen enthält:

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

Sie sind nicht, natürlich nur mit Klasse Funktionen in Include-Dateien beschränkt – Sie können jeden beliebigen Satz Steuerblöcke und Text, die Sie in der generierten Transformationsklasse TransformText-Methode einbezogen werden möchten einschließen. Allerdings hilft wie GoTos zu vermeiden, mit klar definierten Member in Include-Dateien, die begriffliche Komplexität der Projektmappe verwalten.

Erweitern der TextTransformation-Klasse

Ersetzen eine eigene Klasse die TextTransformation-Klasse können Sie benutzerdefinierten Funktionen in Methoden in dieser Klasse einbinden, die in die generierte Umwandlung-Klasse aufgerufen werden kann. Erweitern der TextTransformation-Klasse ist eine gute Wahl, wenn Sie über Code verfügen, die in viele (oder alle) Ihrer Codegenerierung Lösungen verwendet werden: im wesentlichen Faktor Sie diesen Code aus Ihren Lösungen und in der T4-Motor.

Der erste Schritt bei der Ausweitung der TextTransformation-Klasse ist eine abstrakte Klasse erstellen, die von der Klasse erbt:

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

Wenn Sie die Microsoft.VisualStudio.TextTemplating-DLL, die TextTransformation-Klasse enthält, nicht haben, downloaden Sie das SDK für Ihre Version von Visual Studio vor dem Hinzufügen des Verweises.

Je nach Ihrer Version von T4 müssen Sie eine Implementierung der die TransformText-Methode als Teil des TextTransformation vererben können. Wenn also Ihre Methode die Zeichenfolge, enthält die Ausgabe der Transformationsklasse generierten, die in der TextTransformation-Klasse Generation stattfindet zurückgeben muss­Umwelt-Eigenschaft. Die TransformText-Methode, überschreiben sollte bei Bedarf wie folgt aussehen:

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

Wie bei den Funktionen der Unternehmensklasse, haben Sie zwei Möglichkeiten zum Hinzufügen von Code zur Transformationsklasse generierte. Sie können Methoden, die Zeichenfolgenwerte zurückgeben erstellen, wie in diesem Beispiel:

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

Diese Methode kann entweder in einem Ausdruck oder mit dem T4 schreiben oder WriteLine-Methoden, wie in diesen Beispielen verwendet werden:

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

Alternativ können Sie Write oder WriteLine-Methoden die TextTransformation Basisklasse direkt in den Methoden, die Sie der TextTransformation-Basisklasse hinzufügen, wie in diesem Beispiel:

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

Diese Methode kann dann einen Steuerelementblock, wie folgt aufgerufen werden:

<# CopyRight(); #>

Im letzte Schritt ersetzt die standardmäßige TextTransformation-Klasse ist, geben in der T4-Vorlage, die die generierte Umwandlung-Klasse ist von der neuen Klasse erben. Dazu verwenden Sie die Inherits-Parameter des Attributs Vorlage:

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

Sie müssen auch die T4-Vorlage eine Assembly-Direktive hinzufügen, die die DLL, die base-Klasse, mit den vollständigen physikalischen Pfad-Namen auf die DLL verweist:

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

Alternativ können Sie Ihre Basisklasse auf den globalen Assemblycache (GAC) hinzufügen.

In Visual Studio 2010 können Umwelt und Makrovariablen Sie den Pfad zur DLL vereinfachen. Beispielsweise während der Entwicklung können das Makro $(ProjectDir) Sie die DLL mit Ihrer Basisklasse verweisen:

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

Zur Laufzeit, vorausgesetzt Sie installieren Ihre Klassendateien auf den Ordner Programme, können Sie die Umgebung Variable %ProgramFiles% auf 32-Bit-Versionen von Windows oder auf 64-Bit-Versionen oder % ProgramW6432 % für den Program Files Ordner % ProgramFiles(x86) % für die Programmdateien (X 86) Ordner. In diesem Beispiel wird davon ausgegangen, dass die DLL im Verzeichnis Files\PHVIS\T4Tools auf einem 64-Bit-Version von Windows gestellt wurde:

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

Als mit anderen Lösungen mit kompilierten Code, kann Visual Studio die DLL mit Code während der Ausführung der Transformationsklasse generierten sperren. Wenn dies geschieht, während Sie Ihre TextTransformation-Klasse entwickeln, müssen Sie Visual Studio neu starten – und der Code neu kompiliert — bevor Sie weitere Änderungen vornehmen können.

Am Rande: Warnungen und Fehler

Ein robuster Prozess bietet Feedback über ihre Fortschritte. In einem Klasse-KE oder wenn TextTransformation-Klasse erweitern können Sie über Probleme bei der Ausführung der Transformationsklasse generierten Berichten, indem Sie Aufrufe der TextTransformation Klasse Fehler und Warnung-Methoden. Beide Methoden Eingaben eine einzelne Zeichenfolge und übergeben Sie die Zeichenfolge an dem Microsoft Text Template Transformation Toolkit (T4)-Host (Host ist verantwortlich für die Entscheidung, wie Sie die Nachrichten anzeigen). In Visual Studio werden die Nachrichten im Fenster Fehlerliste angezeigt.

In diesem Beispiel berichtet über einen Fehler in einer Klasse-Funktion:

< # GetDatabaseData("") = # >
< # + private String GetDatabaseData (String ConnectionString)
{
Wenn (ConnectionString == "")
    {
Base.Fehler ("keine Verbindungszeichenfolge bereitgestellt.");
    }
  Zurück "";
    }
...

In einem Klasse-KE kann nicht Fehler- und Warnmeldungen verwendet werden, Bericht über Probleme in der T4-Prozess nur auf Störungen, die auftreten, wenn die Transformationsklasse generierte ausgeführt wird. Um es eine andere Möglichkeit, in einer Klasse Funktion, Fehler-und Warnmeldungen erscheinen nur, wenn die Transformationsklasse generierte aus der T4-Datei korrekt montiert werden kann, kompiliert und ausgeführt.

Wenn Sie einen benutzerdefinierten Richtlinie Prozessor erstellen, können Sie noch mit dem T4-Fehler reporting-Prozess durch das Hinzufügen von Compiler integrieren­Error-Objekte in der Errors-Eigenschaft-Klasse. Das CompilerError-Objekt unterstützt mehrere Stücke von Informationen über den Fehler (einschließlich Zeile Anzahl und Dateiname) übergeben, aber in diesem Beispiel wird einfach die ErrorText-Eigenschaft:

Äh von System.CodeDom.Compiler.CompilerError = new 
  System.CodeDom.Compiler.CompilerError();
äh.ErrorText = "Fehlende Richtlinie Parameter";
Dies.Errors.Add(err);

          — P.V.

Benutzerdefinierte Richtlinie Prozessoren

Die mächtigsten und flexible Komplexität in die Code-Generierung verwalten lässt sich benutzerdefinierte Richtlinie Prozessoren verwenden. Unter anderem können Richtlinie Prozessoren fügen Sie Verweise auf die generierte Umwandlung-Klasse und fügen Code in Methoden, die vor und nach der generierten Transformationsklasse TransformText-Methode ausführen. Richtlinien sind auch leicht für Entwickler zu verwenden: Sie müssen nur geben Sie Werte für die Richtlinie Parameter und verwenden Sie dann die Mitglieder, die die Richtlinien zur Verfügung stellen.

Das zentrale Problem mit Richtlinie Prozessoren ist, dass Sie einen Schlüssel in der Windows-Registrierung in Reihenfolge für einen Entwickler mit Ihren Prozessor hinzufügen müssen. Hier wieder, ist es sinnvoll, Verpackung Ihrer T4-Lösung betrachten, so dass der Registrierungseintrag automatisch erfolgen kann. Auf 32-Bit-Versionen von Windows muss der Schlüssel sein:

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

Für 64-Bit-Versionen von Windows ist der Schlüssel:

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

Der Name Ihres Schlüssels ist der Name der Klasse Direktivenprozessor, die folgende Microsoft-Namenskonvention, sollte enden mit "DirectiveProcessor." Sie müssen die folgenden Unterschlüssel:

• Standard: Leer oder eine Beschreibung der Richtlinie.
• Klasse: Der vollständige Name der Klasse in das Format Namespace.ClassName.
• Montage/CodeBase: Der Name der DLL, wenn Sie Ihre Richtlinie DLL in den GAC (Assembly) oder den vollständigen Pfad zu Ihrer Richtlinie DLL (Codebasis) gesetzt habe.

Bei der Entwicklung von Ihrem Prozessor, wenn Sie diesen Eintrag nicht richtig generiert Visual Studio einen Fehler, dass es nicht finden Ihre Direktivenprozessor oder seinen Typ auflösen konnte. Nachdem Sie alle Fehler in Ihrer Registry-Einträge zu beheben, müssen Sie starten Visual Studio, um Ihre Änderungen zu übernehmen.

Um Ihre Direktivenprozessor verwenden, ein Entwickler einer T4-Vorlage eine Richtlinie unter einem beliebigen Namen hinzugefügt und bindet die Richtlinie Ihren Prozessor durch die Richtlinie Prozessor Parameter (die auf den Windows-Registrierungsschlüssel verweist). Wenn die T4-Vorlage ausgeführt wird, wird Ihre Direktivenprozessor den Namen der Richtlinie übergeben, dass der Entwickler zusammen mit allen Parametern den Entwickler angegeben verwendet.

In diesem Beispiel verbindet eine Richtlinie mit dem Namen Copyright auf einen Prozessor namens CopyrightDirectiveProcessor und enthält einen Parameter namens Jahr:

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

Wie bei ein Klasse Feature, ist die Ausgabe von einem Direktivenprozessor Klasse generierte Umwandlung außerhalb der die TransformText-Methode hinzugefügt. Als Ergebnis Sie verwenden Ihren Prozessor Transformationsklasse generierte neue Mitglieder hinzu, dass Devel­Operatoren können Sie in ihre Vorlage-Kontrollblöcke. Die vorherige Beispiel Richtlinie möglicherweise hinzugefügt haben, eine Eigenschaft oder eine String-Variable, die ein Entwickler verwenden könnte in einem Ausdruck wie folgt:

<#= Copyright #>

Natürlich ist der nächste Schritt, um eine Richtlinie Prozessen dieser Richtlinie zu erstellen.

Erstellen eines benutzerdefinierten Richtlinie Prozessors

T4 Richtlinie Prozessoren erben von der Klasse Microsoft.VisualStudio.TextTemplating.DirectiveProcessor (Herunterladen des Visual Studio SDK zu erhalten, die TextTemplating-Bibliothek). Ihre Direktivenprozessor muss, von der GetClassCodeForProcessingRun-Methode, den Code zurückgeben, der Transformationsklasse generierte hinzugefügt wird. Jedoch vor dem Aufrufen der GetClassCodeForProcessingRun-Methode rufen die T4-Engine des Prozessors IsDirectivetrue­unterstützten Methode (übergeben Sie den Namen der Richtlinie) und die ProcessDirective-Methode (Übergabe von den Namen der Richtlinie und die Werte der Parameter). Von der IsDirectiveSupported-Methode sollte Sie false zurück, wenn Ihre Richtlinie sollten nicht ausgeführt werden, und anders wahr.

Da die ProcessDirective-Methode alle Informationen über die Richtlinie übergeben wird, ist das, wo Sie in der Regel den Code erstellen, den der GetClassCodeForProcessingRun zurückgegeben wird. Sie können die Werte der Parameter in der Richtlinie festgelegten lesen sie aus der zweite Parameter der Methode (so genannte Argumente) extrahieren. Dieser Code in der ProcessDirective-Methode sucht einen Parameter namens Jahr und wird verwendet, um eine Zeichenfolge, die Deklaration eine Variable erstellen. Die Zeichenfolge wird dann von GetClassCodeForProcessingRun zurückgegeben:

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;
}

Ihre Direktivenprozessor kann auch Referenzen und mit Hinzufügen /­import-Anweisungen zur Klasse generierte Umwandlung den Code hinzugefügt, durch GetClassCodeForProcessingRun zu unterstützen. Um Verweise auf die Klasse generierte Umwandlung hinzuzufügen, müssen Sie nur die Namen der Bibliotheken von der GetReferencesForProcessingRun-Methode in ein String-Array zurück. Wenn beispielsweise der Code hinzugefügte Klasse generierte Umwandlung Klassen aus dem System.XML-Namespace erforderlich, verwenden Sie Code wie den folgenden:

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

Ebenso können Sie Namespaces, Transformationsklasse generierte (als entweder using oder Imports-Anweisungen) hinzugefügt werden soll angeben, aus der GetImportsForProcessingRun-Methode ein String-Array zurückgegeben.

Die generierten Code Transformation-Klasse enthält auch vor- und Post-initialization Methoden, bevor die TransformText-Methode aufgerufen werden. Sie können Code zurückgeben, die diese Methoden aus den Methoden GetPreInitializationCodeForProcessingRun und GetPostInitializationCodeForProcessingRun hinzugefügt werden.

Wie Sie Debuggen, denken Sie daran, dass mit Custom Tool ausführen nicht Visual Studio eine Projektmappe erstellt. Wenn Sie Änderungen an Ihrem Direktivenprozessor vornehmen, müssen Sie Ihre Lösung zu holen Ihre neuesten Änderungen vor der Ausführung Ihrer Vorlage erstellen. Und wieder, weil T4 die Assemblys, die es verwendet sperrt, vielleicht finden Sie müssen Sie Visual Studio neu gestartet und der Code neu kompiliert Ausgangsstoffs.

T4 senkt erheblich die Hindernisse für die Integration von Code-Generierung in Ihr Toolkit. Jedoch, als mit einer anderen Anwendung müssen Sie berücksichtigen, wie Sie komplette Lösungen zur Unterstützung von Verwaltbarkeit und Erweiterbarkeit Architekt werden. T4 Code-Generierung bietet mehrere Orte — jeweils ihre eigenen Kosten und nutzen — wo Sie Umgestalten von Code und fügen Sie ihn in den Prozess. Egal welche Mechanismen, die Sie verwenden, werden Sie sicherstellen, dass Ihr T4 Lösungen rierte sind.

Am Rande: Verwenden T4 zur Laufzeit

Sie erhalten einen Einblick, welche Klasse generierte Umwandlung aussieht wie durch die Nutzung von vorverarbeitet Textvorlagen, die Sie Text zur Laufzeit generieren lassen. Beim Kompilieren oder ausführen die Ergebnisse von Microsoft Text Template Transformation Toolkit (T4) Generierung von Code zur Laufzeit ist wahrscheinlich nicht etwas, das meisten Entwickler angehen wollen. Allerdings benötigen Sie mehrere "ähnliche aber unterschiedliche" Versionen von ein XML- oder ein HTML-Dokument (oder einen anderen Text), Ihnen Textvorlagen vorverarbeitet T4 verwenden, um diese Dokumente zur Laufzeit generieren.

Als mit anderen T4-Lösungen ist der erste Schritt bei der Verwendung von T4 zur Laufzeit eine T4-Datei Ihrem Projekt aus dem Dialogfeld Neues Element hinzufügen. Aber statt eine Text Template-Datei hinzufügen, fügen Sie eine Textvorlage vorverarbeitet (auch im Dialogfeld Visual Studio neue Element aufgeführt). Eine Textvorlage vorverarbeitet ist identisch mit einer standard T4 Text Template-Datei, mit der Ausnahme, dass die Eigenschaft Benutzerdefiniertes Tool auf TextTemplatingFileProcessor statt der üblichen TextTemplatingFileGenerator festgelegt ist.

Im Gegensatz zu enthalten nicht mit einer Text-Vorlage, die untergeordnete Datei, enthält des generierten Codes aus einer Textvorlage vorverarbeitet die Code-Ausgabe von der Transformationsklasse generierten. Stattdessen enthält die Datei etwas, das sehr viel wie eine der generierten Transformation Klassen aussieht: eine Klasse mit dem gleichen Namen wie die vorverarbeitet Text Template-Datei mit einer Methode namens TransformText. Aufrufen die TransformText-Methode als Zeichenfolge zur Laufzeit gibt, was Sie erwarten finden Sie in der Codedatei einer T4-Vorlage: der generierte Code. Also, für eine vorverarbeitet Text Template-Datei namens GenerateHTML, würde Sie den generierten Text mithilfe von Code wie folgt zur Laufzeit abrufen:

GenerateHTML HtmlGen = neue GenerateHTML();
Zeichenfolge html = HtmlGen.TransformText();

      — P.V.

Peter Vogel ist ein Principal in PH & V Information Services. Sein letzte Buch war "praktische Codegenerierung in."NET" (Addison-Wesley Professional, 2010). PH & V Information Services ist spezialisiert auf das Design von Service-basierte Architekturen zu erleichtern und bei der Integration.NET-Technologien in diesen Architekturen. Neben seiner Beratungstätigkeit schrieb Vogel Learning Tree International Service-orientierte Architektur Design Kurs, weltweit gelehrt.

Unser Dank gilt dem folgenden technischen Experten für die Durchsicht dieses Artikels: Gareth Jones