T4 templates generally support a single output file, so whatever you write in the templates is copied into a single output file. This makes the T4 templating system unusable as most of the time we may be required to create multiple files and add them to the solution.

As I have already explained that you can use GenerationEnvironment to get a reference to the already written text on the buffer, you can use a normal file writer object to write the files to the location:

<#@ template debug="false" hostspecific="true" language="C#" #>
<#@ import namespace="System.IO" #>
<#@ output extension=".txt" #>
<#
string templateDirectory = Path.GetDirectoryName(Host.TemplateFile);
string outputFilePath = Path.Combine(templateDirectory, "1.txt");
Write("This goes to file1");
File.WriteAllText(outputFilePath, this.GenerationEnvironment.ToString()); 

this.GenerationEnvironment.Clear();

outputFilePath = Path.Combine(templateDirectory, "2.txt");
Write("This goes to file2");
File.WriteAllText(outputFilePath, this.GenerationEnvironment.ToString()); 
#>

The preceding code uses Host.TemplateFile to get the directory location path, where the template file exists and write files directly in the same folder. The File.WriteAllText method writes all the output text to the output files 1.txt and 2.txt. Once all the file content is written, we need to remove the content by calling Clear on the StringBuilder object.

After saving the preceding code, if you look at the Solution Explorer pane, as shown in the following screenshot, you will see that two files 1.txt and 2.txt have been created, but the problem is that they are not included in the solution:

Now to include the file in the solution, we need to use multiple template files so that we can pass a parameter to a template file to write the content repeatedly. Thus, the files are generated from another template each time with a new filename.

Let's create a template file, name it FileManager.tt, and add the following code to it:

<#@ template debug="false" hostspecific="true" language="C#" #>
<#@ import namespace="System.IO" #>
<#@ output extension=".txt" #>
<#+
void CreateFile(string fileName)
{
   string templateDirectory = Path.GetDirectoryName(Host.TemplateFile);
   string outputFilePath = Path.Combine(templateDirectory, fileName);
   File.WriteAllText(outputFilePath, this.GenerationEnvironment.ToString()); 
   this.GenerationEnvironment.Clear();
}
#>

The preceding code looks exactly the same as before. We just created a file with the helper method. The CreateFile function takes a filename as the input, writes the GenerationEnvironment property buffer to the file, and clears the content after writing it.

Now to include the file in the project, we need to use the EnvDTE objects for the host project. Let's add the EnvDTE assembly and other Visual Studio Interop assemblies, as shown in the following code:

<#@ assembly name="System.Xml" #>
<#@ assembly name="EnvDTE" #>
<#@ assembly name="Microsoft.VisualStudio.OLE.Interop" #>
<#@ assembly name="Microsoft.VisualStudio.Shell" #>
<#@ assembly name="Microsoft.VisualStudio.Shell.Interop" #>
<#@ assembly name="Microsoft.VisualStudio.Shell.Interop.8.0" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ import namespace="System.Diagnostics" #>
<#@ import namespace="System.IO" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Xml" #>
<#@ import namespace="Microsoft.VisualStudio.Shell" #>
<#@ import namespace="Microsoft.VisualStudio.Shell.Interop" #>
<#@ import namespace="Microsoft.VisualStudio.TextTempating" #>

The following assemblies and imports are added to FileManager.tt. Then, we add two lines at the end of the CreateFile method, as shown in the following code:

void CreateFile(string fileName)
{
   string templateDirectory = Path.GetDirectoryName(Host.TemplateFile);
   string outputFilePath = Path.Combine(templateDirectory, fileName);
   File.WriteAllText(outputFilePath, this.GenerationEnvironment.ToString()); 
   this.GenerationEnvironment.Clear();
   EnvDTE.ProjectItem templateProjectItem = __getTemplateProjectItem();
    templateProjectItem.ProjectItems.AddFromFile(outputFilePath);
}

Here, we create the ProjectItem object for the currently created file and write the following file inside the project:

IServiceProvider hostServiceProvider = (IServiceProvider)Host;
EnvDTE.DTE dte = (EnvDTE.DTE)hostServiceProvider.GetService(typeof(EnvDTE.DTE));

The hostService method is used to get the ItempContext DTE service and add the file to the project. We have used the article from http://www.codeproject.com/Articles/16515/Creating-a-Custom-Tool-to-Generate-Multiple-Files for reference.

The __getTemplateProjectItem() method is a method that creates the DTE ProjectItem object for a particular project and returns the object reference. Once the ProjectItem object is created, we can use a AddFromFile method to add the item to the project.

Now to test the file, let's add a new template and include the preceding file in the project:

<#@ template debug="false" hostspecific="true" language="C#" #>
<#@ output extension=".txt" #>
<#@ include file="FileManager.tt" #>

<#
   Write("File1");
   CreateFile("1.txt"); 
   Write("File2");
   CreateFile("2.txt");
#>

The preceding code creates two files and adds them to the project. This can be verified from the following screenshot:

In the preceding screenshot, you can see the files that are already added to the Solution Explorer pane and even listed inside the template file.

As you are already habituated with T4 templates, let me show you another example to demonstrate the power of the templating code generation. Let's take a look at the following code:

<#
   var logVariants = new []
       {
           new { Variant = "Bright"    , Color = "White"   },
           new { Variant = "Normal"    , Color = "Gray"    },
           new { Variant = "Url"       , Color = "Cyan"    },
       };
#>
   using System;

    static partial class MyLogClass
    {
<#
   foreach (var logVariant in logVariants)
   {
#>
       static void Write<#=logVariant.Variant#>Line (string message)
       {
           var color = Console.ForegroundColor;
           Console.ForegroundColor = ConsoleColor.<#=logVariant.Color#>;
           try
           {
               Console.WriteLine (message ?? "");
           }
           finally
           {
               Console.ForegroundColor = color;
           }
       }

<#
   }
#>
       
}

You can see that the template generates a Variant method directly inside the code. The variants are created as an array while the methods are created on the fly such that each method will have a separate color to write on the console.

The important thing to understand here is how the code is laid out. You can see that rather than using the template methods Write or WriteLine, we can directly write content to the file outside the <# and #> tags such that the data is written directly to the file.