Powerful T4 text template

I hope you can at least realize that even if there is an automatic code generator, changes in database structure and other factors will bring us a lot of trouble. The benefits of putting the. tt file directly into the project need not be mentioned. There are special business requirements, which are implemented with the partial class in. to avoid overwriting the handwritten code when the template file automatically updates the code. ( Beijing website production )

What's the use of T4 text template? When will it be used?

Take a look at the following example and you will understand:

Create a new console application, delete all the files in it, create a new Program.tt file, and enter the following:

 < #@ template  language ="C#" debug ="true"# >  
 < #@ output  extension =".cs" encoding ="utf-8"# >  
 < #  
 stringClassName  =  "Program" ;   
 # > stringClassName  =  "Program" ;   
 # >  
 namespaceHelloAngel  
 {  
 usingSystem;   
 class < #=ClassName　# >  
 {  
 staticvoidMain(string[] args)  
 　{  
 Console. WriteLine("Hello Angel");   
 }  
 }  
 } 

After saving, we will see this style in Solution Explorer:

The Program.cs file is generated by our Program.tt file, and its contents are as follows:

 namespaceHelloAngel  
 {  
 usingSystem;   
 classProgram  
 {  
 staticvoidMain( string [] args)  
 {  
 Console. WriteLine( "Hello Angel" );   
 }  
 }  
 } 

Look at the following two commands:

 < #@ template  language ="C#" debug ="true"# >  
 < #@ output  extension =".cs" encoding ="utf-8"# >  

The language in the<# @ template #>instruction specifies the language used by our template to run, which can be VB or C #. Debug declares whether to use debugging. If debugging is not available, it can be set to false

The extension in the<# @ output #>directive specifies the extension of the output file, and encoding specifies the encoding scheme of the output file.

That is to say, we can use C # language to write the logic in this template file. The template will output a file with the same name as the template file, the extension is. cs, and the code is utf-8.

Now let's take a look at the syntax of the instructions:

The syntax of the directive is as follows:

 < #@ DirectiveName [ AttributeName  =  "AttributeValue" ] ...  # >  

All attribute values must be enclosed in double quotation marks. If the value itself contains quotation marks, they must be escaped with characters.

A directive is usually the first element in a template file or included file. They should not be placed in code blocks<#... #> Should not be placed in the class function block<#+... #> After.

T4 template instruction

<#@ template [language="VB"] [hostspecific="true"] [debug="true"] [inherits="templateBaseClass"] [culture="code"] [compilerOptions="options"] #>

T4 parameter command

<#@ parameter type="Full.TypeName"name="ParameterName"#>

T4 output command

<#@ output extension=".fileNameExtension"[encoding="encoding"] #>

T4 Assembly Instruction

<#@ assembly name="[assembly strong name|assembly file name]"#>

T4 import instruction

<#@ import namespace="namespace"#>

T4 contains instructions

<#@ include file="filePath"#>

After reading the above instructions, try to write a template file to generate some classes for practice:

 < #@ template  language ="C#" debug ="true"# >  
 < #@ output  extension =".cs" encoding ="utf-8"# >  
 < #@ import  namespace = "System.Collections.Generic" # >  
 < #  
 List < List < string > classNames  =  
 new List < string > ()  
 {  
 "Hello",  
 "Test"  
 };   
 List < string > callMethods  =  new  List < string > ();   
 　# >  
 namespace HelloAngel  
 　{  
 using System;   
 < #  
 foreach (string className in classNames)  
 {  
 callMethods. Add(string.Format("{0}.Show();", className));   
 # > foreach (string className in classNames)  
 {  
 callMethods. Add(string.Format("{0}.Show();", className));   
 # >  
 class  < #=className # >  
 {  
 ///  < summary >  
 ///  < #=className # > Notes for
 ///  </ summary >  
 public static void Show()  
 {  
 Console. WriteLine("ClassName: < #=className # > ");  
 }  
 }  
 < #  
 # > }  
 # >  
 class Program  
 {  
 ///  < summary >  
 ///Comments for the entry method
 ///  </ summary >  
 static void Main(string[] args)  
 {  
 < #  
 foreach (string callMethod in callMethods)  
 {  
 # > foreach (string callMethod in callMethods)  
 {  
 # >  
 //  < #=callMethod # > Call
 < #=callMethod # >  
 　 < #  
 }  
 # > }  
 # >  
 }  
 }  
 } 

Our general projects are divided into three simple layers. With some experience above, you should think. If only three class. tt files were written, it would be exciting to automatically maintain the entire three layers for us! Indeed, I did a project to share with you:

Look at the whole project now:

There are more than three projects here. I added a UnitTest project and an Adapters project. It's not hard to see the project name. The UnitTest project is a test project. The Adapters project is an entity adapter project. Leave them alone.

With just such a few things, the erection of the third floor has been completed, but it is still in Paramter mode. There is no support for stored procedures. If no one accompanies me, I will add support for stored procedures.

When the project was built, it was built on. net4. Here I changed it to. net2.0. However, I only install visual studio 2010. If you use Visual Studio 2008, please correct the version number in the project file by yourself. There are many methods on the Internet. I won't talk too much.

label: Beijing website production High end website construction