Supercharge Your Code with T4 Text Templates

Question

Introduction

As developers, we often find ourselves writing repetitive code, whether it's boilerplate classes, data access layers, or UI components. Wouldn't it be great if there was a way to automate these repetitive tasks while maintaining consistency and reducing errors? Enter T4 Text Templates, a powerful yet underutilized feature in Visual Studio and JetBrains Rider that allows developers to generate code dynamically.

In this blog post, we’ll explore what T4 Text Templates are, how they can fast-track design pattern implementations, and how you can integrate them into your workflow to enhance productivity. If you’re a C# developer working with .NET, this is a tool you don’t want to miss.

---

What are T4 Text Templates?

T4 (Text Template Transformation Toolkit) is a code generation tool built into Microsoft Visual Studio and JetBrains Rider that allows you to create text-based files dynamically. It’s particularly useful for generating C# classes, SQL scripts, configuration files, or even documentation.

A T4 template is essentially a mix of C# code and text, where the C# part determines how the text is generated. When executed, the template outputs a file that can be used within your project.

Why Use T4?

• Eliminates Repetitive Coding – Automates code generation for common design patterns.
• Enhances Maintainability – Reduces the likelihood of human errors in repetitive tasks.
• Improves Productivity – Saves time by reducing boilerplate code.
• Customizable and Extendable – You can modify templates to suit your project needs.

---

How T4 Text Templates Work

T4 templates have two key types:

1. Design-time Templates: Generates static code files at design time (before compilation).
2. Runtime Templates: Generates code dynamically at runtime.

Basic Structure of a T4 Template

A T4 template file has the .tt extension and typically consists of:

• Directives (<#@ ... #>): Define metadata, imports, and file types.
• Standard Text: The static content that gets generated.
• Control Code (<# ... #>): C# logic for dynamic content.
• Expressions (<#= ... #>): Embedded expressions for generating output.

Let’s take a simple example:

<#@ template language="C#" #>
<#@ output extension=".cs" #>
using System;

namespace AutoGenerated
{
    public class HelloWorld
    {
        public static void SayHello()
        {
            Console.WriteLine("<#= DateTime.Now #>: Hello, T4 Templates!");
        }
    }
}

Breaking Down the Template

• <#@ template language="C#" #> – Specifies that we’re using C#.
• <#@ output extension=".cs" #> – Defines the output file format.
• <#= DateTime.Now #> – Dynamically injects the current timestamp.

When processed, this template generates a HelloWorld.cs file with dynamic content.

---

T4 in Design Patterns

T4 Text Templates can be a game-changer when working with design patterns. Let’s look at how T4 can help streamline some common patterns.

1. Generating Repository Pattern

Instead of manually creating repositories for each entity, we can use a T4 template to automate the process.

Template (RepositoryTemplate.tt)

<#@ template language="C#" #>
<#@ output extension=".cs" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System" #>
<#@ import namespace="System.Collections.Generic" #>

namespace DataAccess
{
    public class <#= ClassName #>Repository
    {
        public IEnumerable<<#= ClassName #>> GetAll()
        {
            // Fetch all records
            return new List<<#= ClassName #>>();
        }

        public <#= ClassName #> GetById(int id)
        {
            // Fetch record by ID
            return new <#= ClassName #>();
        }
    }
}

Usage

You can specify a class name at the top of the template:

<# string ClassName = "Product"; #>

This will generate:

namespace DataAccess
{
    public class ProductRepository
    {
        public IEnumerable<Product> GetAll()
        {
            return new List<Product>();
        }

        public Product GetById(int id)
        {
            return new Product();
        }
    }
}

Now, instead of writing repositories manually for each model, you can generate them dynamically by modifying ClassName.

---

2. Automating Factory Pattern

Another example is using T4 templates to generate factory classes.

Factory Template (FactoryTemplate.tt)

<#@ template language="C#" #>
<#@ output extension=".cs" #>
namespace FactoryPattern
{
    public static class <#= ClassName #>Factory
    {
        public static <#= ClassName #> Create()
        {
            return new <#= ClassName #>();
        }
    }
}

With ClassName = "User", it generates:

namespace FactoryPattern
{
    public static class UserFactory
    {
        public static User Create()
        {
            return new User();
        }
    }
}

This is a huge time saver when dealing with multiple factory classes.

---

Which IDEs Support T4 Templates?

1. Visual Studio

T4 Templates are natively supported in Visual Studio (including Community, Professional, and Enterprise editions). You can create a .tt file inside your project, and it will generate the output file automatically.

How to Enable T4 in Visual Studio:

1. Right-click your project.
2. Select Add → New Item.
3. Choose Text Template (.tt file).
4. Edit and save the template to generate code.

2. JetBrains Rider

JetBrains Rider supports T4 Templates with the help of the T4 Support Plugin.

To use T4 in Rider:

1. Install the T4 Plugin via Preferences → Plugins → T4 Support.
2. Create a new .tt file and write your template.
3. Build the project to generate the output file.

Both IDEs allow you to preview and regenerate T4 templates when needed.

---

Best Practices for T4 Templates

1. Keep Templates Modular – Avoid putting too much logic inside one template. Break it down into reusable components.
2. Use Parameterized Templates – Pass parameters dynamically to make templates flexible.
3. Leverage Partial Classes – Use T4 to generate partial classes that complement manually written code.
4. Automate Execution – Use build events or scripts to regenerate templates when needed.
5. Version Control Generated Code – Track T4 outputs to prevent inconsistencies.

---

Conclusion

T4 Text Templates are a powerful automation tool for .NET developers, enabling the rapid generation of repetitive code while ensuring consistency and maintainability. Whether you're implementing design patterns, generating configuration files, or automating model-based classes, T4 can save you countless hours.

Both Visual Studio and JetBrains Rider support T4 templates, making it easy to integrate into your workflow. If you haven't used T4 before, now is the time to explore it and start automating your code generation!

Have you used T4 Templates in your projects? Share your experiences in the comments!

Sponsor: Clip2Title

Comments

Great breakdown of T4 Text Templates! The automation potential here is huge, especially for maintaining consistency across large projects. Have you faced any challenges when using T4 with more complex scenarios, like generating code that involves multiple related classes or dependencies? Would love to hear how you tackled that!