Einführung in T4 Templates

by Erik Stroeken 03. August 2017· 4 Min. lesen

0 Copy link Share on X Share on Facebook Share on LinkedIn

Mit dem Text Template Transformation Toolkit ist es möglich Vorlagen (die T4 Templates) mit Nutzdaten abzufüllen und Textdateien von irgendeinem Format (z.B. C#, VB, XML, HTML oder XAML) zu generieren.

Obwohl das Text Template Transformation Toolkit schon seit Jahren einen Teil vom Visual Studio ausmacht, kennen auffällig wenig Programmierer dieses Werkzeug und sein Potential. Dieser Blog stellt das Werkzeug vor und gibt an Hand von zwei Beispielen eine kurze Einführung wie man es anwenden kann.

Übersicht

T4 Templates werden verwendet, um irgendwelche Dateien zu Ausgabedateien (T4-Laufzeit-Textvorlagen) zu transformieren oder zum Generieren von z.B. C# / VB Dateien (T4-Entwurfszeit-Textvorlagen).

Das Text Template Transformation Toolkit wurde in 2005 zum ersten Mal als Option mit Visual Studio 2005 ausgeliefert und ist mittlerweile vollständig in Visual Studio integriert.

Anwendungsbeispiele von Microsoft selber sind:

Entity Framework: Entity Generierung
NET MVC: Generierung von Views und Controllers
NET Dynamic Data

Entwickler Anwendungsbeispiele:

Proxy-Klassen aus z.B. WSDL Information
Ressource-Klassen aus z.B. RESX-, INI-, CSV- oder XML-Dateien
Domain-Objekte definiert in XSD-Dateien
Generieren von Schnittstellen aus XSD-Dateien, z.B. für REST-Schnittstelle
Generieren von XML- oder HTML-Dateien ähnlich wie Razor

Eine Textvorlagedatei hat die Extension „tt“. Die resultierende generierte Datei wird im Visual Studio als Unterdatei der Textvorlagedatei dargestellt.

Es gibt ein paar Entwickler-Plugins für T4 Templates. Eines ist „ForTea“ von ReSharper, welches die Syntax einfärbt und IntelliSense möglich macht.

Zwei Typen von Textvorlagedateien

Es gibt zwei Typen von Textvorlagedateien: T4-Laufzeit-Textvorlagen und T4-Entwurfszeit-Textvorlagen.

Unten stehende Übersicht ordnet die beide Verfahren im Vergleich zu anderen Weaving- und Code Generierung Frameworks ein.

Noser Blog T4 Templates

T4-Laufzeit-Textvorlagen

Runtime T4 text templates („vorverarbeitete“ Vorlagen) werden in Ihrer Anwendung ausgeführt, um Textzeichenfolgen zu erstellen (meist als Teil der Ausgabe der Anwendung). Das Studio generiert dabei eine C# oder VB Datei welche zur Laufzeit aufgerufen wird.

T4-Entwurfszeit-Textvorlagen

Designtime T4 text templates werden in Visual Studio ausgeführt, um einen Teil des Quellcodes (C# / VB), sowie andere Ressourcen Ihrer Anwendung zu definieren. Das Resultat selber wird als Unterdatei vom „tt“ Script im Solution Explorer dargestellt.

Eine T4-Entwurszeit-Textvorlage wird konvertiert wenn:

Menu „Build“ -> „Transform All T4 templates“ ausgeführt wird
Nach einem Rebuild
Rechtemaustaste auf die Textvorlagedatei -> „Run Custom Tool“
Nach einer Änderung in der Textvorlagedatei

Beispiel T4-Laufzeit-Textvorlagen

Die Laufzeit-Textvorlagen findet man unter Visual C# Items, wenn man ein neues Element zum Projekt hinzufügt.

Noser Blog T4 Laufzeit Textvorlagen

Inhalt der T4Runtime.tt Datei:

<#@ template language="C#" #>
<html>
    <head> <link rel="stylesheet" type="text/css" href="default.css" /> </head>
    <body>
        <table class="bordered">
            <tr>
                <th>Vorname</th>
                <th>Name</th>
                <th>Adresse</th>
            </tr>
            <# foreach (PersonItem personItem in _personItems) 
            { #>
                <tr>
                    <td> <#= personItem.FirstName #> </td>
                    <td> <#= personItem.LastName #> </td>
                    <td> <#= personItem.Address #> </td>
                </tr>
            <# } 
        #>
        </table>
    </body>
</html>

Der Entwickler kann jetzt einer partiellen Klasse mit gleichem Namen C# oder VB Code in Kombination mit dem T4-Script ausführen lassen.

Inhalt der T4Runtime.cs Datei:

partial class T4Runtime
{
    private readonly List<PersonItem> _personItems;

    public T4Runtime(List<PersonItem> personItems)
    {
        _personItems = personItems;
    }
}

Das Konstrukt kann zur Laufzeit aufgerufen werden:

public class T4HtmlPage
{
    public void GeneratePage()
    {
        List<PersonItem> personItems = new List<PersonItem>();
        personItems.Add(new PersonItem() {FirstName = "Peter", LastName = "Muster", Address = "Rudolf-Diesel-Strasse 3, 8404 Winterthur"});
        personItems.Add(new PersonItem() {FirstName = "Michael", LastName = "Steiner", Address = "Effingerstrasse 4a, 3001 Bern"});
        personItems.Add(new PersonItem() { FirstName = "Erik", LastName = "Stroeken", Address = "Beispielstrasse 4, 8359 Dietikon" });
        T4Runtime t4Runtime = new T4Runtime(personItems);
        string pageContent = t4Runtime.TransformText();
        File.WriteAllText("outputPage.html", pageContent, Encoding.UTF8);
    }
}

Das Resultat ist die HTML-Datei „outputPage.html“:

<html>
    <head>
        <link rel="stylesheet" type="text/css" href="default.css" />
    </head>
    <body>
        <table class="bordered">
            <tr>
                <th>Vorname</th>
                <th>Name</th>
                <th>Adresse</th>
            </tr>
                            <tr>
                    <td> Peter </td>
                    <td> Muster </td>
                    <td> Rudolf-Diesel-Strasse 3, 8404 Winterthur </td>
                </tr>
                            <tr>
                    <td> Michael </td>
                    <td> Steiner </td>
                    <td> Effingerstrasse 4a, 3001 Bern </td>
                </tr>
                            <tr>
                    <td> Erik </td>
                    <td> Stroeken </td>
                    <td> Beispielstrasse 4, 8359 Dietikon </td>
                </tr>
                    </table>
    </body>
</html>

Beispiel T4-Entwurfszeit-Textvorlagen

Die Laufzeit-Textvorlagen findet man unter Visual C# Items, wenn man ein neues Element zum Projekt hinzufügt.

Noser Blog T4 Entwurfszeit Textvorlagen

Inhalt der T4Designtime.tt Datei:

<#@ template debug="true" hostspecific="true" language="C#" #>
<#@ assembly name="System.Core" #>
<#@ assembly name="System.Xml.dll" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ import namespace="System.Xml" #>
<#@ import namespace="System.IO" #>
<#@ import namespace="System.Linq" #>
<#@ output extension="tt.cs" #>
<#
  List<string> properties = File.ReadLines(this.Host.ResolvePath("Properties.txt")).ToList();
#>
namespace Spi.TipsAndTricks.T4Designtime
{
    public class T4Designtime {
    <#
    foreach (string propertyName in properties) 
    { #>
        public string <#= propertyName #> { get; set;}
    <# } #>
    }
}>

Die generierte Klasse befindet sich nach der Ausführung vom T4 Script unter der TT-Datei:

Noser Blog T4 design time templates

Inhalt der T4Designtime.tt.cs Klasse:

namespace Spi.TipsAndTricks.T4Designtime
{
    public class T4Designtime {
            public string FirstName { get; set;}
            public string LastName { get; set;}
            public string Address { get; set;}
    }
}

Fazit

Das Text Template Transformation Toolkit ist ein sehr nützlicher Visual Studio Diamant mit dem man auf elegante Weise automatisch im Precompile Schritt C# oder VB Dateien generieren lassen kann, die im weiteren Verlauf des Übersetzungsprozesses als normale Quellcodedateien behandelt werden. Nur wenige Entwickler kennen das Tool mit seinen Möglichkeiten. Hoffentlich hat dieser Blog dazu beigetragen, das ein wenig zu ändern.

Kommentare