在C#中动态编译T4模板代码

转: http://www.wxzzz.com/1438.html
资料: https://cnsmartcodegenerator.codeplex.com/SourceControl/latest
 

什么是T4模板？

T4，即4个T开头的英文字母组合：Text Template Transformation Toolkit。T4文本模板将按照预期定义的一些代码进行动态生成一些所需的字符串内容。

如何动态编译T4模板？

通常我们在VS中进行*.tt （T4模板的编写），那么如何将t4模板代码动态的在我们自己的程序中进行编译生成呢？实际上微软已经提供了相应的接口进行。实现在自己的程序中进行编译T4模板需要实现一个自定义的宿主，你必须创建继承自 ITextTemplatingEngineHost 的类。接下来我们将一步一步完成我们自己的编译方式，（参考文章 http://msdn.microsoft.com/zh-cn/library/bb126579.aspx ）

1 首先你必须要有的：Microsoft.VisualStudio.TextTemplating （点击下载并解压，获得 Microsoft.VisualStudio.TextTemplating.dll 文件）

2.在 Visual Studio 中，新建一个名为 CustomHost 的 C# 控制台应用程序。

3. 添加对下列程序集的引用

  • Microsoft.VisualStudio.TextTemplating.*.0
  • Microsoft.VisualStudio.TextTemplating.Interfaces.10.0 和更高版本

4. 用下面的代码替换 Program.cs 或 Module1.vb 文件中的代码：

  1. using System;
  2. using System.IO;
  3. using System.CodeDom.Compiler;
  4. using System.Collections.Generic;
  5. using System.Text;
  6. using Microsoft.VisualStudio.TextTemplating;
  7.  
  8. namespace CustomHost
  9. {
  10.     //The text template transformation engine is responsible for running 
  11.     //the transformation process.
  12.     //The host is responsible for all input and output, locating files, 
  13.     //and anything else related to the external environment.
  14.     //-------------------------------------------------------------------------
  15.     class CustomCmdLineHost : ITextTemplatingEngineHost
  16.     {
  17.         //the path and file name of the text template that is being processed
  18.         //---------------------------------------------------------------------
  19.         internal string TemplateFileValue;
  20.         public string TemplateFile
  21.         {
  22.             get { return TemplateFileValue; }
  23.         }
  24.         //This will be the extension of the generated text output file.
  25.         //The host can provide a default by setting the value of the field here.
  26.         //The engine can change this value based on the optional output directive
  27.         //if the user specifies it in the text template.
  28.         //---------------------------------------------------------------------
  29.         private string fileExtensionValue = ".txt";
  30.         public string FileExtension
  31.         {
  32.             get { return fileExtensionValue; }
  33.         }
  34.         //This will be the encoding of the generated text output file.
  35.         //The host can provide a default by setting the value of the field here.
  36.         //The engine can change this value based on the optional output directive
  37.         //if the user specifies it in the text template.
  38.         //---------------------------------------------------------------------
  39.         private Encoding fileEncodingValue = Encoding.UTF8;
  40.         public Encoding FileEncoding
  41.         {
  42.             get { return fileEncodingValue; }
  43.         }
  44.         //These are the errors that occur when the engine processes a template.
  45.         //The engine passes the errors to the host when it is done processing,
  46.         //and the host can decide how to display them. For example, the host 
  47.         //can display the errors in the UI or write them to a file.
  48.         //---------------------------------------------------------------------
  49.         private CompilerErrorCollection errorsValue;
  50.         public CompilerErrorCollection Errors
  51.         {
  52.             get { return errorsValue; }
  53.         }
  54.         //The host can provide standard assembly references.
  55.         //The engine will use these references when compiling and
  56.         //executing the generated transformation class.
  57.         //--------------------------------------------------------------
  58.         public IList<string> StandardAssemblyReferences
  59.         {
  60.             get
  61.             {
  62.                 return new string[]
  63.                 {
  64.                     //If this host searches standard paths and the GAC,
  65.                     //we can specify the assembly name like this.
  66.                     //---------------------------------------------------------
  67.                     //"System"
  68.  
  69.                     //Because this host only resolves assemblies from the 
  70.                     //fully qualified path and name of the assembly,
  71.                     //this is a quick way to get the code to give us the
  72.                     //fully qualified path and name of the System assembly.
  73.                     //---------------------------------------------------------
  74.                     typeof(System.Uri).Assembly.Location
  75.                 };
  76.             }
  77.         }
  78.         //The host can provide standard imports or using statements.
  79.         //The engine will add these statements to the generated 
  80.         //transformation class.
  81.         //--------------------------------------------------------------
  82.         public IList<string> StandardImports
  83.         {
  84.             get
  85.             {
  86.                 return new string[]
  87.                 {
  88.                     "System"
  89.                 };
  90.             }
  91.         }
  92.         //The engine calls this method based on the optional include directive
  93.         //if the user has specified it in the text template.
  94.         //This method can be called 0, 1, or more times.
  95.         //---------------------------------------------------------------------
  96.         //The included text is returned in the context parameter.
  97.         //If the host searches the registry for the location of include files,
  98.         //or if the host searches multiple locations by default, the host can
  99.         //return the final path of the include file in the location parameter.
  100.         //---------------------------------------------------------------------
  101.         public bool LoadIncludeText(string requestFileName, out string content, out string location)
  102.         {
  103.             content = System.String.Empty;
  104.             location = System.String.Empty;
  105.        
  106.             //If the argument is the fully qualified path of an existing file,
  107.             //then we are done.
  108.             //----------------------------------------------------------------
  109.             if (File.Exists(requestFileName))
  110.             {
  111.                 content = File.ReadAllText(requestFileName);
  112.                 return true;
  113.             }
  114.             //This can be customized to search specific paths for the file.
  115.             //This can be customized to accept paths to search as command line
  116.             //arguments.
  117.             //----------------------------------------------------------------
  118.             else
  119.             {
  120.                 return false;
  121.             }
  122.         }
  123.         //Called by the Engine to enquire about 
  124.         //the processing options you require. 
  125.         //If you recognize that option, return an 
  126.         //appropriate value. 
  127.         //Otherwise, pass back NULL.
  128.         //--------------------------------------------------------------------
  129.         public object GetHostOption(string optionName)
  130.         {
  131.         object returnObject;
  132.         switch (optionName)
  133.         {
  134.         case "CacheAssemblies":
  135.                     returnObject = true;
  136.      break;
  137.         default:
  138.         returnObject = null;
  139.         break;
  140.         }
  141.         return returnObject;
  142.         }
  143.         //The engine calls this method to resolve assembly references used in
  144.         //the generated transformation class project and for the optional 
  145.         //assembly directive if the user has specified it in the text template.
  146.         //This method can be called 0, 1, or more times.
  147.         //---------------------------------------------------------------------
  148.         public string ResolveAssemblyReference(string assemblyReference)
  149.         {
  150.             //If the argument is the fully qualified path of an existing file,
  151.             //then we are done. (This does not do any work.)
  152.             //----------------------------------------------------------------
  153.             if (File.Exists(assemblyReference))
  154.             {
  155.                 return assemblyReference;
  156.             }
  157.             //Maybe the assembly is in the same folder as the text template that 
  158.             //called the directive.
  159.             //----------------------------------------------------------------
  160.             string candidate = Path.Combine(Path.GetDirectoryName(this.TemplateFile), assemblyReference);
  161.             if (File.Exists(candidate))
  162.             {
  163.                 return candidate;
  164.             }
  165.             //This can be customized to search specific paths for the file
  166.             //or to search the GAC.
  167.             //----------------------------------------------------------------
  168.             //This can be customized to accept paths to search as command line
  169.             //arguments.
  170.             //----------------------------------------------------------------
  171.             //If we cannot do better, return the original file name.
  172.             return "";
  173.         }
  174.         //The engine calls this method based on the directives the user has 
  175.         //specified in the text template.
  176.         //This method can be called 0, 1, or more times.
  177.         //---------------------------------------------------------------------
  178.         public Type ResolveDirectiveProcessor(string processorName)
  179.         {
  180.             //This host will not resolve any specific processors.
  181.             //Check the processor name, and if it is the name of a processor the 
  182.             //host wants to support, return the type of the processor.
  183.             //---------------------------------------------------------------------
  184.             if (string.Compare(processorName, "XYZ", StringComparison.OrdinalIgnoreCase) == 0)
  185.             {
  186.                 //return typeof();
  187.             }
  188.             //This can be customized to search specific paths for the file
  189.             //or to search the GAC
  190.             //If the directive processor cannot be found, throw an error.
  191.             throw new Exception("Directive Processor not found");
  192.         }
  193.         //A directive processor can call this method if a file name does not 
  194.         //have a path.
  195.         //The host can attempt to provide path information by searching 
  196.         //specific paths for the file and returning the file and path if found.
  197.         //This method can be called 0, 1, or more times.
  198.         //---------------------------------------------------------------------
  199.         public string ResolvePath(string fileName)
  200.         {
  201.             if (fileName == null)
  202.             {
  203.                 throw new ArgumentNullException("the file name cannot be null");
  204.             }
  205.             //If the argument is the fully qualified path of an existing file,
  206.             //then we are done
  207.             //----------------------------------------------------------------
  208.             if (File.Exists(fileName))
  209.             {
  210.                 return fileName;
  211.             }
  212.             //Maybe the file is in the same folder as the text template that 
  213.             //called the directive.
  214.             //----------------------------------------------------------------
  215.             string candidate = Path.Combine(Path.GetDirectoryName(this.TemplateFile), fileName);
  216.             if (File.Exists(candidate))
  217.             {
  218.                 return candidate;
  219.             }
  220.             //Look more places.
  221.             //----------------------------------------------------------------
  222.             //More code can go here...
  223.             //If we cannot do better, return the original file name.
  224.             return fileName;
  225.         }
  226.         //If a call to a directive in a text template does not provide a value
  227.         //for a required parameter, the directive processor can try to get it
  228.         //from the host by calling this method.
  229.         //This method can be called 0, 1, or more times.
  230.         //---------------------------------------------------------------------
  231.         public string ResolveParameterValue(string directiveId, string processorName, string parameterName)
  232.         {
  233.             if (directiveId == null)
  234.             {
  235.                 throw new ArgumentNullException("the directiveId cannot be null");
  236.             }
  237.             if (processorName == null)
  238.             {
  239.                 throw new ArgumentNullException("the processorName cannot be null");
  240.             }
  241.             if (parameterName == null)
  242.             {
  243.                 throw new ArgumentNullException("the parameterName cannot be null");
  244.             }
  245.             //Code to provide "hard-coded" parameter values goes here.
  246.             //This code depends on the directive processors this host will interact with.
  247.             //If we cannot do better, return the empty string.
  248.             return String.Empty;
  249.         }
  250.         //The engine calls this method to change the extension of the 
  251.         //generated text output file based on the optional output directive 
  252.         //if the user specifies it in the text template.
  253.         //---------------------------------------------------------------------
  254.         public void SetFileExtension(string extension)
  255.         {
  256.             //The parameter extension has a '.' in front of it already.
  257.             //--------------------------------------------------------
  258.             fileExtensionValue = extension;
  259.         }
  260.         //The engine calls this method to change the encoding of the 
  261.         //generated text output file based on the optional output directive 
  262.         //if the user specifies it in the text template.
  263.         //----------------------------------------------------------------------
  264.         public void SetOutputEncoding(System.Text.Encoding encoding, bool fromOutputDirective)
  265.         {
  266.             fileEncodingValue = encoding;
  267.         }
  268.         //The engine calls this method when it is done processing a text
  269.         //template to pass any errors that occurred to the host.
  270.         //The host can decide how to display them.
  271.         //---------------------------------------------------------------------
  272.         public void LogErrors(CompilerErrorCollection errors)
  273.         {
  274.             errorsValue = errors;
  275.         }
  276.         //This is the application domain that is used to compile and run
  277.         //the generated transformation class to create the generated text output.
  278.         //----------------------------------------------------------------------
  279.         public AppDomain ProvideTemplatingAppDomain(string content)
  280.         {
  281.             //This host will provide a new application domain each time the 
  282.             //engine processes a text template.
  283.             //-------------------------------------------------------------
  284.             return AppDomain.CreateDomain("Generation App Domain");
  285.             //This could be changed to return the current appdomain, but new 
  286.             //assemblies are loaded into this AppDomain on a regular basis.
  287.             //If the AppDomain lasts too long, it will grow indefintely, 
  288.             //which might be regarded as a leak.
  289.             //This could be customized to cache the application domain for 
  290.             //a certain number of text template generations (for example, 10).
  291.             //This could be customized based on the contents of the text 
  292.             //template, which are provided as a parameter for that purpose.
  293.         }
  294.     }
  295.     //This will accept the path of a text template as an argument.
  296.     //It will create an instance of the custom host and an instance of the
  297.     //text templating transformation engine, and will transform the
  298.     //template to create the generated text output file.
  299.     //-------------------------------------------------------------------------
  300.     class Program
  301.     {
  302.         static void Main(string[] args)
  303.         {
  304.             try
  305.             {
  306.                 ProcessTemplate(args);
  307.             }
  308.             catch (Exception ex)
  309.             {
  310.                 Console.WriteLine(ex.Message);
  311.             }
  312.         }
  313.         static void ProcessTemplate(string[] args)
  314.         {
  315.             string templateFileName = null;
  316.             if (args.Length == 0)
  317.             {
  318.                 throw new System.Exception("you must provide a text template file path");
  319.             }
  320.             templateFileName = args[0];
  321.             if (templateFileName == null)
  322.             {
  323.                 throw new ArgumentNullException("the file name cannot be null");
  324.             }
  325.             if (!File.Exists(templateFileName))
  326.             {
  327.                 throw new FileNotFoundException("the file cannot be found");
  328.             }
  329.             CustomCmdLineHost host = new CustomCmdLineHost();
  330.             Engine engine = new Engine();
  331.             host.TemplateFileValue = templateFileName;
  332.             //Read the text template.
  333.             string input = File.ReadAllText(templateFileName);
  334.             //Transform the text template.
  335.             string output = engine.ProcessTemplate(input, host);
  336.             string outputFileName = Path.GetFileNameWithoutExtension(templateFileName);
  337.             outputFileName = Path.Combine(Path.GetDirectoryName(templateFileName), outputFileName);
  338.             outputFileName = outputFileName + "1" + host.FileExtension;
  339.             File.WriteAllText(outputFileName, output, host.FileEncoding);
  340.  
  341.             foreach (CompilerError error in host.Errors)
  342.             {
  343.                 Console.WriteLine(error.ToString());
  344.             }
  345.         }
  346.     }
  347. }

5. 仅对于 Visual Basic，打开“项目”菜单，单击“CustomHost 属性”。 在“启动对象”列表中单击“CustomHost.Program”。

6. 在“文件”菜单上，单击“全部保存”。

7. 在“生成”菜单上，单击“生成解决方案”。

进行编译并测试

若要测试自定义宿主，您需要编写一个文本模板，然后运行自定义宿主，将文本模板的名称传递给它并验证模板转换。

创建文本模板测试自定义宿主

1. 在C盘根目录中创建一个文本文件，将其命名为 TestTemplate.tt 。

可以使用任何文本编辑器（例如记事本）来创建文件。

2. 将以下内容添加到文件中：

  1.  Text Template Host Test
  2.  
  3. <#@ template debug="true" #>
  4.  
  5. <# //Uncomment this line to test that the host allows the engine to set the extension. #>
  6. <# //@ output extension=".htm" #>
  7.  
  8. <# //Uncomment this line if you want to debug the generated transformation class. #>
  9. <# //System.Diagnostics.Debugger.Break(); #>
  10.  
  11. <# for (int i=0; i<3; i++)
  12.  {
  13.  WriteLine("This is a test");
  14.  } 
  15. #>

3. 保存并关闭文件。

完成/使用

进行使用测试吧，我们需要在cmd（命令提示符窗口）程序中进行测试。

1. 打开 cmd 窗口

2. 在窗口中键入   你的程序编译的文件路径CustomHost.exe c:TestTemplate.tt （中间包含一个空格），然后按下Enter （回车）键。

此时在C盘根目录中就已经生成了 TestTemplate1.txt，内容为：

Text Template Host Test




This is a test
This is a test
This is a test
 
 
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/chencidi/p/6426715.html