Artikel
03/16/2017

Dieser Artikel wurde maschinell übersetzt.

T4-Vorlagen

Codeerstellung mit T4 ohne große Hindernisse

Die Microsoft.NET Framework macht intensiven Gebrauch von Codegenerierung sowohl (wenn Sie ein Steuerelement auf einer Entwurfsoberfläche ziehen Code generiert) zur Entwurfszeit und zur Laufzeit (Wenn LINQ für SQL-Anweisungen, die Daten abrufen generiert). Codegenerierung offensichtlich macht Entwickler produktiver durch Verringerung der Menge an Code, die ein Entwickler zu schreiben hat, aber es kann besonders nützlich sein, wenn mehr oder weniger identischen Code in vielen Lösungen verwendet wird. Wie Sie diesen ähnliche (aber nicht identische) Code in eine neue Anwendung zu implementieren, ist es nur allzu leicht zu neue Fehlern führen.

Obwohl Entwickler alle Code Generation Tools nutzen können die.NET Framework beim Erstellen von Anwendungen verwendet, nur sehr wenige machen umfassenden Gebrauch von Codegenerierung in ihrer täglichen Entwicklung Praxis. Es gibt eine Reihe von Gründen: Sie befürchten, dass die Einbeziehung der Codegenerierung ein neues Toolset erfordert, das Sie nicht die Zeit zu lernen haben; Ihnen fehlt Erfahrung im erkennen von Problemen, die Code-Generierung lösen wird und Entwerfen von Lösungen, die mit "handschriftliche" Code generierten Code integrieren; und sie verstehen, dass einige Code-Generation-Lösungen mehr Zeit erfordern zu halten (oder sogar verwenden) als durch die Anwendung der Projektmappe gespeichert werden.

Das Microsoft Text Template Transformation Toolkit (T4) Adressen viele dieser Probleme bietet eine einfache Möglichkeit zum Codeerzeugung Lösungen implementieren, die Tools nutzen und Techniken Entwickler bereits mit vertraut sind. T4 wird dies durch die Erkenntnis, dass eine typische Lösung zwei Arten von Code beinhaltet: Standardcode, der aus einem Code-Generierung auf einen anderen nicht ändern, und dynamische Code, der sich ändert. T4 vereinfacht Codegenerierung, da Entwickler geben Sie einfach den häufig verwendeten Code Teil einer Lösung in eine Datei. In T4 ist der dynamische Code (in der Regel ein kleiner Teil der LГ¶sung Codegenerierung) generiert mithilfe eines Satzes von Tags, die die eine ASP-Tags sehr ähnlich aussehen.NET MVC Entwickler würden beim Erstellen einer Ansicht oder das Verwenden einer ASP.NET-Entwickler würde verwenden, um serverseitige Code in einer ASPX-Datei einbetten.

Mit einem T4-basierte Lösung nutzt die Fähigkeiten haben Sie bereits von lassen Sie angeben die Eingänge zum Generieren von Code in welcher Programmiersprache, die Sie bereits verwenden. T4 generiert keine Code-neutrale Lösungen (der Code generiert eine T4-Lösung ist immer in einer bestimmten Programmiersprache), aber die meisten Entwickler müssen nicht Code-neutrale Lösungen.

Codegenerierung Lösungen

Während T4-Codegenerierung Lösungen erstellen erleichtert, Probleme nicht es die, die Entwickler haben in erkennen, wann eine Codegenerierung Lösung sinnvoll wäre und tatsächlich eine Lösung entwerfen. Probleme, die Code-Generierung in der Regel löst haben drei Gemeinsamkeiten:

Der generierte Code geht in eine separate Datei aus den DevelOper des Code. Dadurch wird sichergestellt, dass die Code-Generierung nicht die Entwickler Code beeinträchtigen. In der Regel bedeutet dies, dass der generierte Code geht in eine neue Klasse, die der Entwickler verwenden wird aus seiner "handschriftliche" Code. Es könnte sinnvoll sein, eine partielle Klasse generiert, die der Entwickler nicht nur nennen, sondern erweitern kann – aber der Entwickler und der generierte Code sind noch immer in separaten Dateien.
Der generierte Code ist wiederholend: Der Code in der Projektmappe ist eine Vorlage, die viele Male, oft mit kleinen Varianten wiederholt werden kann. Dies stellt sicher, dass die Code-Generierung ist einfacher und leichter zu verwalten als die äquivalente handgeschriebenen Code.
Im Vergleich zu der handschriftlichen Lösung, die generierte Lösung erfordert viel weniger Eingaben (im Idealfall keine Eingaben überhaupt — die Lösung zur Code-Generierung bestimmt, was aus der Umwelt getan werden muss). Wenn die Anzahl der Eingänge groß oder schwer zu bestimmen ist, können Entwickler die handschriftliche Lösung als einfacher als die erzeugte Lösung betrachten.

Aufgrund dieser Merkmale, sind drei Arten von Szenarien für die Codegenerierung Untersuchung Wert. Entwickler neigen dazu, sich auf das erste Szenario ("das ultimative Szenario"), in der nur wenige Eingaben verwendet werden, um eine Menge Code generieren, die häufig verwendet wird (beispielsweise von Entity Framework, denken). In der Tat, die fruchtbarsten Code -Generation Möglichkeiten lassen sich in zwei anderen Szenarien.

Das zweite Szenario ist das offensichtlichste: Wenn viel muss Code generiert werden soll. Mehrere sich wiederholende Codezeilen schreiben zu vermeiden ist in diesem Fall eindeutig von Vorteil. Während die meisten Codegenerierung Lösungen in mehreren Anwendungen verwendet werden, können Lösungen in dieser Kategorie lohnt sich selbst wenn in nur einer einzigen Anwendung verwendet werden. Als generalisierte schreiben Sie Code mit vielen If Anweisungen mit jeder Situation umzugehen — jedes If Anweisung verdoppelt die logische Komplexität des Codes — LГ¶sung Codegenerierung erzeugt den speziellen Code für jeden Satz von Bedingungen erforderlich. Statt der Hand-Codierung viele Klassen, die eine Schnittstelle zu teilen, kann Codegenerierung zum Erstellen der einzelnen Klassen (vorausgesetzt, die Klassen teilen eine gemeinsame Struktur).

Aber die dritte Art von Szenario ist am häufigsten: Wenn ein paar Eingänge erzeugt ein wenig Code, der in vielen Anwendungen verwendet werden. In diesem Szenario die wiederholten Code in einer bestimmten Anwendung ist gering, aber die Aktivität den Code unterstützt ist so verbreitet, dass die Lösung landet viel Code generieren — nicht nur in einer Anwendung.

Zum Beispiel, hier ist einige typische code, auf dem ADO.NET-Entwickler schreiben aller Zeiten:

string conString =
  System.Configuration.ConfigurationManager.
ConnectionStrings["Northwind"].ConnectionString;

Obwohl dies eine triviale Menge Code, es ist Code, der wiederholt wird – mit nur den Namen der Verbindung Zeichenfolge ändern — in Anwendung nach der Anwendung. Darüber hinaus ist fehlen keine IntelliSense-Unterstützung für den Namen der Verbindungszeichenfolge, der Code anfällig für Fehler: Es ist offen für "Grafen" Rechtschreibfehler, die erst zur Laufzeit entdeckt werden (wahrscheinlich wenn jemand für Ihre Beurteilung Eingabe hat ist über die Schulter schaut). Ein weiteres Beispiel implementiert INotifyPropertyChanged, die den Entwickler für jede Eigenschaft auf "Rechtschreibfehler zählt" offen lässt.

Dieser Code zum Abrufen einer Verbindungszeichenfolge mit dem Namen Northwind wäre nützlicher, wenn einige Code-Generation-Lösung zum Erstellen einer ConnectionManager-Klasse für jede Verbindungszeichenfolge wie folgt:

string conString = ConnectionManager.Northwind;

Wenn Sie eine Chance für eine Lösung der Code-Generation erkennen, ist der nächste Schritt ein Beispiel des Codes zu schreiben, die die Lösung generieren würden. In diesem Fall könnte die ConnectionManager-Klasse wie folgt aussehen:

public partial class ConnectManager
{
  public static string Northwind
    {
      get
        {
          return System.Configuration.ConfigurationManager.
ConnectionStrings["Northwind"].ConnectionString;
        }
    }
}

Dieser Code erfüllt die Kriterien für eine Lösung der Code-Generation: Es ist wiederholend (der Eigenschaft Code wiederholt für jede Verbindungszeichenfolge) mit nur kleinen Änderungen (der Name der Verbindungszeichenfolge) und den Namen der Eigenschaft und die Anzahl der Eingänge ist klein (nur die Namen der die Verbindungszeichenfolgen).

Der erste Code-Generation-Vorlage

Eine T4-Lösung besteht aus einem "Codegenerierung Paket": eine Datei, wo der Entwickler fügt die Eingaben für die Code-Generierung und eine Vorlagendatei, die Code aus diesen Eingaben generiert. Beide Dateien sind Vorlagendateien T4 und entstehen mit denselben Programmier-Tools, die Sie verwenden, um Ihre Anwendungen zu schreiben. Dieses Design erlaubt es Ihnen, Ihre Vorlage Code-Generierung aus der Datei zu trennen, die der Entwickler verwendet, um die Eingaben für den Prozess bereitzustellen.

Zum Erstellen Ihrer Lösung Codegenerierung beginnen, müssen Sie die T4 Vorlagendatei, die Ihren Code zu einer Anwendung generiert, wo können Sie es testen — vorzugsweise, ähnlich denen einer Anwendung erwarten Sie Ihre Lösung in verwendet werden. Die T4-Vorlage-Datei hinzufügen in das Dialogfeld Neues Element hinzufügen in Visual Studio angezeigt, Abbildung 1, fügen Sie ein Text-Vorlage angeben einen Namen für Ihre Vorlage Code Generation (z. B. ConnectionManagerGenerator). Wenn Ihre Version von Visual Studio nicht die Option Textvorlage, fügen Sie eine neue Textdatei (auch im Abschnitt Allgemein gefunden), dass der Datei die Erweiterung ".tt" Trigger T4 Verarbeitung. Wenn Sie eine Textdatei hinzufügen, erhalten Sie eine Warnmeldung, die Sie ruhigen Gewissens ignorieren können.

Adding a T4 Template
Abbildung 1 Hinzufügen einer T4-Vorlage

Wenn Sie die Eigenschaften für die neue Vorlagendatei zu überprüfen, finden die seine Custom Tool Sie Eigenschaft auf TextTemplatingFileGenerator festgelegt wurde. Dieses benutzerdefinierte Tool wird automatisch von Visual Studio ausführen und ist der Host, der die Code-Generierung verwaltet. In T4 werden der Inhalt der Vorlagendatei an den Host Code-Generation übergeben, die den resultierenden generierten Code in die Vorlagendatei geschachtelte untergeordnete Datei stellt.

Wenn Sie eine Textdatei zu Ihrem Projekt hinzugefügt haben, wird die Vorlagendatei leer sein; Wenn Sie eine Vorlagendatei hinzufügen konnten, enthält es zwei T4-Richtlinien, gekennzeichnet mit < # @... # > Trennzeichen (wenn Sie eine Textdatei hinzugefügt, Sie müssen diese Richtlinien hinzufügen). Diese Richtlinien geben die Sprache, die die Vorlage in (nicht die Sprache für den generierten Code) geschrieben werden und die untergeordnete Datei-Endung. In diesem Beispiel die beiden Richtlinien legen die Programmiersprache für die Vorlage für Visual Basic und die Dateierweiterung für die Kind-Datei mit den generierten Code in. generated.cs:

<#@ template language="VB" #>
<#@ output extension=".generated.cs" #>

Um die traditionelle "Hello, World"-Anwendung erstellen, fügen Sie den Code nur in der Vorlagendatei (Beachten Sie, dass die Vorlage zwar die Sprache, die die Vorlage in geschrieben wird Visual Basic, C#-Code generieren ist):

public class HelloWorld
{
  public static string HelloWorld(string value)
  {
    return "Hello, " + value;
  }
}

Dieses Beispiel verwendet nur Standardcode. In T4 ist Standardcode direkt aus der Vorlage in der Codedatei kopiert. In Visual Studio 2010 sollte das passieren, wenn Sie weg von der Vorlagendatei wechseln, oder speichern Sie es. Sie können auch Code-Generierung durch die Vorlagendatei im Projektmappen-Explorer mit der rechten Maustaste und Auswählen von benutzerdefinierten Tool ausführen im Kontext-Menü oder durch Klicken auf die Schaltfläche Transform alle Vorlagen an die Spitze des Projektmappen-Explorers auslösen.

Nach Generierung auslösen, wenn Sie öffnen die Vorlage Code-Datei (die jetzt die Erweiterung in die Vorlage Ausgabe Richtlinie angegeben wird), finden Sie sie in Ihre Vorlage angegebene Code aufweist. Visual Studio wird auch getan haben eine Hintergrund-Kompilierung des neuen Codes, so dass Sie finden, dass Sie den generierten Code vom Rest der Anwendung verwenden können.

Generieren von Code

Standardcode ist jedoch nicht ausreichend. Die ConnectionManager-Lösung muss dynamisch eine Eigenschaft für jede Verbindungszeichenfolge generieren, die die Anwendung benötigt. Um diesen Code zu generieren, müssen Sie hinzufügen Code des Steuerelements zu verwalten, die Code-Generierung und einige Variablen, die die Eingänge vom Entwickler mithilfe der Projektmappe Code Generation halten werden.

Die ConnectionManager verwendet ArrayList (die ich genannt habe, Verbindungen) aus dem System.Collections-Namespace, die Liste der Verbindungszeichenfolgen enthalten, die die Eingabe für die Code-Generierung zu bilden. Um diesen Namespace für die Verwendung von Code innerhalb der Vorlage zu importieren, verwenden Sie die Richtlinie T4 importieren:

<#@ Import Namespace="System.Collections" #>

Jetzt können Sie statischen Code hinzufügen, der die generierte Klasse beginnt. Weil ich von C#-Code generieren bin sieht den Anfangscode für die ConnectionManager:

public partial class ConnectionManager
{

Ich muss jetzt den Steuercode hinzufügen, der dynamisch den Ausgabecode generiert wird. Code, der steuert die Generierung (Code, der ausgeführt, anstatt auf die untergeordnete Datei kopiert) beizufügen, der < #... # > Trennzeichen. In diesem Beispiel machen es einfach, zu unterscheiden zwischen der Kontrolle und der Code generiert wird, ich den Kontrolle-Code in Visual Basic geschrieben (Dies ist keine Anforderung der Code-Generierung). Das Steuerzeichen für die ConnectionManager-Lösung durchläuft der Connections-Auflistung für jede Verbindungszeichenfolge:

<#
  For Each conName As String in Connections
#>

Neben jedem Steuerelement Code in der Vorlage müssen Sie auch alle Ausdrücke enthalten, deren Werte sind in der dynamisch generierten Code integriert werden. In der ConnectionManager-Lösung hat den Namen der Verbindungszeichenfolge in die Eigenschaftendeklaration und an der ConnectionStrings-Auflistung übergebene Parameter einbezogen werden. Um einen Ausdruck auszuwerten und dessen Wert in den Standardcode eingefügt haben, muss in der Ausdruck eingeschlossen werden die < # … # = > Trennzeichen. In diesem Beispiel fügt dynamisch den Wert aus der ConName-Variablen in zwei Stellen im statischen Code innerhalb der For Each-Schleife:

public static string <#= conName #>
{
  get
  {
    return System.Configuration.ConfigurationManager.
ConnectionStrings["<#= conName #>"].ConnectionString;
  }
}
<#
  Next
#>
}

Alles, was übrig ist wird die ArrayList zu definieren, die die Liste der Verbindung Zeichenfolgennamen halten wird. Hierzu verwende ich ein T4 Klasse Feature. T4-Klasse Funktionen sind in der Regel definieren Sie Hilfsfunktionen verwendet, aber können auch verwendet werden, definieren Sie Felder oder alle anderen auf Klassenebene Elemente, die während der Codegenerierung Prozess verwendet werden. Klasse Funktionen müssen am Ende einer Vorlage angezeigt werden, wie dieser:

<#+
  Dim Connections As New ArrayList()
#>

Dieser T4-Vorlage bildet den ersten Teil der ConnectionManager-Lösung — die Codegenerierung Vorlage. Sie müssen nun den zweiten Teil der Lösung zu erstellen: Die Eingabedatei, die der Entwickler verwenden wird, um die Eingaben für die Code-Generierung bereitzustellen.

Mithilfe des Code-Generation-Pakets

Um einen Platz für den Entwickler zu geben die Eingaben für die Code-Generierung zu ermöglichen, fügen Sie eine zweite T4-Vorlage für die Anwendung, in der Sie Ihre Code-Generation-Lösung testen wollen. Diese Vorlage muss eine Include-Direktive, die Ihre Vorlage Code-Generierung in diese Vorlage kopiert. Da ich meine Codegenerierung Vorlagendatei ConnectionManagerGenerator genannt, sieht die Eingabemaske-Datei für die ConnectionManager-Lösung:

<#@ template language="VB" #>
<#@ output extension=".generated.cs" #>
<#@ Import Namespace="System.Collections" #>
<#
#>
<#@ Include file="ConnectionManagerGenerator.tt" #>

Wenn Code-Generierung durchgeführt wird, baut der Host-Prozess tatsächlich Vermittler.NET-Programm von Richtlinien, Steuerzeichen und statische Code in Ihren Vorlagen angegeben, und führt dann das daraus resultierende Programm. Es ist die Ausgabe von dieser zwischengeschaltete Programm, das in der Vorlage untergeordnete Datei gegossen wird. Das Ergebnis der Verwendung der Include-Direktive ist Ihre Vorlage Code Generation (mit seiner Deklaration der Verbindungen ArrayList) Zusammenführen mit dem Inhalt dieser Datei um das zwischengeschaltete Programm zu erstellen. Alles, was der Entwickler mit Ihrer Lösung zu tun hat ist den Code dieser Vorlage hinzufügen, die von Ihrer Vorlage Codegenerierung verwendeten Variablen festgelegt wird. Dieser Prozess ermöglicht Entwicklern das Angeben von Eingaben für die Codegenerierung unter Verwendung der Programmiersprache, die, der Sie gewohnt sind.

Für die ConnectionManager-Lösung muss der Entwickler hinzufügen den Namen der die Verbindungszeichenfolgen, die in der Anwendung Datei app.config oder Web.config der ArrayList Verbindungen aufgeführt. Da diese Einstellungen Teil des Steuerelementcode, der ausgeführt werden muss, muss dieser Code eingeschlossen werden, innerhalb der < #... # > Trennzeichen. Die Entwickler Code muss auch die Include-Direktive stehen, so dass die Variablen festgelegt werden, bevor der Code ausgeführt wird.

Um ein ConnectionManager für zwei Verbindungszeichenfolgen namens Northwind und PHVIS zu generieren, würde der Entwickler diesen Code Eingabe vor die Include-Direktive hinzufügen:

<#
  Me.connections.Add("Northwind")
  Me.connections.Add("PHVIS")
#>
<#@ Include file="ConnectionManagerGenerator.tt" #>

Sie haben nun eine Paket Code-Generation, die der die Codegenerierung Vorlage und die Eingabemaske-Datei besteht. Entwickler, die mit Ihrer Lösung müssen kopieren Sie beide Dateien in ihrer Anwendung, setzen Sie die Variablen in der Eingabedatei und schließen oder speichern die Eingabedatei zum Generieren des Codes Lösung. Ein unternehmungslustige Codegenerierung Entwickler könnte die Codegenerierung Paket als eine Vorlage Visual Studio Element einrichten, die beide Vorlagendateien enthält. Während nicht angebracht, die ConnectionManager-Lösung, wenn ein Entwickler einen anderen Satz von Code basierend auf unterschiedlichen Eingaben generieren muss, müsste er nur eine zweite Kopie der Eingabedatei, die zweite Reihe von Eingaben zu halten machen.

Es ist ein Falten in dieser Lösung Struktur: Jede Anwendung, die diese Lösung verwendet, wird die Eingabemaske und die Codegenerierung Vorlage haben. In der ConnectionManager-Lösung wenn beide Vorlagen Code, die Visual Studio kompiliert wird generieren, werden die resultierende zwei Codedateien beide definieren Sie eine Klasse namens Verbindungs-Manager und die Anwendung nicht kompiliert. Es gibt eine Reihe von Möglichkeiten, dies zu verhindern, aber am einfachsten ist es, die Codegenerierung Vorlage ändern, so dass seine generierte Codedatei eine Erweiterung verfügt, die nicht Visual Studio erkennt. Ändern die Ausgabeanweisung in der Vorlagendatei Codegenerierung funktioniert der Trick:

<#@ output extension=".ttinclude" #>

Tools zur Generierung von Code und Ressourcen

Neben den MSDN Library-Seiten, ist Ihre beste Quelle für Informationen zur Verwendung von T4 Oleg Sych Blog unter olegsych.com— ich habe sicherlich kommen abhängen, seine Erkenntnisse (und Werkzeuge) in meinem eigenen Code Generation-Lösungen zu entwickeln. Seine T4-Toolbox enthält mehrere Vorlagen für die Entwicklung von T4-Lösungen (einschließlich einer Vorlage zum Generieren von mehrere Ausgabedateien aus einer einzigen T4-Vorlage und andere Tools für die Verwaltung von Code-Generierung). Sych des Toolkit enthält auch Pakete für verschiedene Codegenerierung Szenarien.

Visual Studio behandelt im wesentlichen T4-Vorlagen als Textdateien – was bedeutet, dass Sie nicht bekommen, IntelliSense-Unterstützung oder Hervorhebung oder, wirklich alles, was Entwickler erwarten von einem Editor. Im Visual Studio-Erweiterungs-Manager finden Sie, dass mehrere Tools, die Ihr T4-Entwicklung zu fördern, werden erleben. Sowohl Visual T4 von Clarius Consulting (bit.ly/maZFLm) und T4 Editor von Red Lizard (bit.ly/wEVEVa) bietet Ihnen viele Features Sie Selbstverständlichkeit in einem Editor. Alternativ können Sie das T4 Editor (entweder im Freien oder PRO EDITION) von greifbaren Engineering (siehe Abbildung 2) bei bit.ly/16jvGY, die enthält einen visuellen Designer Sie die Code-Generierung Pakete aus die Unified Modeling Language (UML) erstellen können-wie Diagramme.

The Default Editor for T4 Template Files (Left) Isn’t Much Better than NotePad—Adding the Tangible Editor (Right) Gives You the Kind of Features You Expect in Visual Studio
Abbildung 2 der Standard-Editor für T4 Template-Dateien (links) ist nicht viel besser als NotePad — hinzufügen den greifbaren Editor (rechts) gibt Ihnen die Art von Features erwarten Sie in Visual Studio

Wie bei jeder anderen Code-basierte Lösung, es unwahrscheinlich ist wird Ihre Lösung zum erste Mal arbeiten. Kompilierungsfehler in Ihre Vorlagensteuerelement Code in der Fehler-Liste gemeldet sind, nachdem Sie benutzerdefiniertes Tool ausführen eine Vorlage-Datei im Kontextmenü auswählen. Jedoch selbst wenn der Steuerelement-Code kompiliert wird, können Sie feststellen, dass die Vorlagendatei Kind außer für das Wort ErrorGeneratingOutput leer ist. Dies bedeutet, dass das Steuerzeichen in Ihrem Code Generation-Paket einen Fehler generiert, wenn es ausgeführt wird. Es sei denn, Ihre Fehler offensichtlich ist, wirst du die Kontrollcode Debuggen müssen.

Um Ihre Generation-Paket Debuggen, müssen Sie zuerst das Debug-Attribut auf die Vorlage-Direktive auf true fest, wie folgt festlegen:

<#@ template language="VB" debug="True"#>

Sie können nun legen Sie einen Haltepunkt im Code Steuerelement und Visual Studio, die es zu respektieren. Dann ist das zuverlässigste Verfahren zum Debuggen Ihrer Anwendung um eine zweite Version von Visual Studio starten, und wählen Sie im Menü Debuggen auf an den Prozess anhängen. Im angezeigten Dialog Sie die andere ausgeführte Kopie von devenv.exe wählen und klicken Sie auf die Schaltfläche Anfügen. Sie können jetzt zurück zu der ursprünglichen Kopie von Visual Studio und führen Sie benutzerdefiniertes Tool Ihre Eingabedatei Kontext-Menü starten, Ausführen von Code.

Wenn dieser Prozess nicht funktioniert, können Sie veranlassen, durch Einfügen dieser Zeile in der Vorlage-Steuerelement Code Debuggen:

System.Diagnostics.Debugger.Break()

Mit Visual Studio 2010 auf Windows 7 sollten Sie diese Zeile vor Ihrem Anruf auf die Pause-Methode hinzufügen:

System.Diagnostics.Debugger.Launch()

Wenn Sie Vorlagencode ausführen, öffnet diese Zeile ein Dialogfeld, mit dem Sie Visual Studio neu starten oder Debuggen.Wählen Sie die Debugoption startet eine zweite Kopie von Visual Studio bereits an den Prozess Vorlagencode angefügt.Die erste Instanz von Visual Studio wird deaktiviert, während Sie Ihren Code Debuggen sind.Leider, wenn die Debugsitzung beendet ist, wird Visual Studio in diesem Modus deaktiviert bleiben.Um dies zu verhindern, müssen Sie eines der Visual Studio-Einstellungen in der Windows-Registrierung ändern (siehe Sych die Post zum Debuggen von T4 auf bit.ly/aXJwPx für die Details).Sie müssen auch daran denken, diese Anweisung zu löschen, sobald Sie Ihr Problem gelöst haben.

Natürlich zählt diese Lösung immer noch auf den Entwickler in die Namen der die Verbindungszeichenfolgen korrekt in der Eingabedatei.Eine bessere Lösung hätte ConnectionManager Code enthalten, der die Verbindungszeichenfolgen aus der Config-Datei der Anwendung, wodurch die Notwendigkeit für die Entwickler Eingaben geben liest.Leider, weil Code zur Entwurfszeit statt zur Laufzeit generiert wird, Sie können nicht die ConfigurationManager verwenden, um die Config-Datei gelesen und müssen die System.XML-Klassen verwenden, um die Config-Datei zu verarbeiten.Sie müssen auch hinzufügen eine Assembly-Direktive zu holen dieser Klassen, wie ich früher zu ArrayList von System.Collections.Sie können auch Verweise auf Ihre eigenen benutzerdefinierten Bibliotheken hinzufügen, indem Sie die Assembly Richtlinie Name-Attribut auf den vollständigen Pfad zu der DLL:

<#@ assembly name="C:\PHVIS\GenerationUtilities.dll" #>

Dies sind die Grundlagen für die Codegenerierung zu Ihrem Toolkit hinzufügen und Steigerung Ihrer Produktivität — zusammen mit des Codes-Qualität und Zuverlässigkeit.T4 macht es Ihnen leicht zu beginnen, indem Sie Code Generation Lösungen mit eine vertraute Toolset erstellen.Das größte Problem, mit denen, das Sie konfrontiert werden mit T4, ist zu lernen, Möglichkeiten für die Anwendung dieser Tools zu erkennen.

Peter Vogel ist ein Prinzipal 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 SOA Design Kurs, das weltweit unterrichtet wird.

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