zoukankan html css js c++ java

【转】- 使用T4模板批量生成代码

前言

之前在 “使用T4模板生成代码 - 初探” 文章简单的使用了T4模板的生成功能，但对于一个模板生成多个实例文件，如何实现这个方式呢？无意发现一个解决方案 “MultipleOutputHelper.ttinclude” ，它让基于T4模板批量生成文件实例变得简单起来了。

什么是MultipleOutputHelper.ttinclude

Damien Guard是一个在加利福尼亚州圣何塞的开发人员，他构建出处理使用T4模板输出多文件的解决方案“MultipleOutputHelper.ttinclude”

使用

1. 初始化

获取MultipleOutputHelper.ttinclude文件模板

注意： 文件可以上github.com 托管上面获取（ https://github.com/damieng/DamienGKit/tree/master/T4/MultipleOutputHelper）

在T4模板中使用include指令导入MultipleOutputHelper.ttinclude文件或者将MultipleOutputHelper.ttinclude的代码复制在T4模板内。

然后初始化Manager对象,代码如下：

注意： 这里的Manager.ttinclude 就是MultipleOutputHelper.ttinclude文件模板

2. 文件块

使用代码标识区分生成的代码块的范围

该代码声明了一个Employee.generated.cs文件，文件代码内容为：

public class Employee { ... }

3. 页眉和页脚

很多模板需要共享一个共同的页眉和页脚时，可以使用import语句进行打开和关闭。简单的使用StartHeader和StartFooter的代码方法进行分割。

4. 编译执行

使用Process方法，进行文件分割。

场景应用

基于之前的“使用T4模板生成代码 - 初探” 文章的场景，进行基于NHibernate Mapper 来获取Domain对象，然后进行批量生成多个代码文件。

1. 自定义T4模板，文件名为“EntityRepositoryTemplate.tt”，代码如下：

<#@ template  language="C#"    debug="true" hostspecific="True"#> 
//  导入MultipleOutputHelper.ttinclude文件
<#@include file="$(SolutionDir)appT4MultipleOutputHelper.ttinclude"#> 
// 导入相关的DLL
<#@ Assembly Name="$(SolutionDir)libSharpArch.2.0.2NHibernate.dll" #>
<#@ Assembly Name="$(SolutionDir)libSharpArch.2.0.2SharpArch.NHibernate.dll" #>
<#@ Assembly Name="$(SolutionDir)libSharpArch.2.0.2SharpArch.Domain.dll" #>
<#@ Assembly Name="$(SolutionDir)libSharpArch.2.0.2FluentNHibernate.dll" #>
<#@ Assembly Name="$(SolutionDir)appCotide.Datain$(ConfigurationName)Cotide.Infrastructure.dll" #>
<#@ Assembly Name="$(SolutionDir)appCotide.Corein$(ConfigurationName)Cotide.Domain.dll" #>
<#@ Assembly Name="$(SolutionDir)appCotide.Frameworkin$(ConfigurationName)Cotide.Framework.dll" #>
<#@ import namespace="System.IO"#>
<#@ import namespace="System"#>
<#@ import namespace="System.Configuration"#>   
 <#  
    // 初始化
    SharpArch.NHibernate.NHibernateSession.CloseAllSessions();
    SharpArch.NHibernate.NHibernateSession.Reset();
    string projectPath = @"C:资料Person项目Codeplex电子商务app";
    string nhibernatePath = projectPath + @"Cotide.WebNHibernate.config";
    string[] mappingAssemblies = new[] { @"C:资料Person项目Codeplex电子商务appCotide.DatainReleaseCotide.Infrastructure.dll" };
    // 加载配置
    NHibernate.Cfg.Configuration configuration = SharpArch.NHibernate.NHibernateSession.Init(
    new SharpArch.NHibernate.SimpleSessionStorage(), mappingAssemblies,
    new Cotide.Infrastructure.NHibernateMaps.AutoPersistenceModelGenerator().Generate(),
    nhibernatePath);
    // 获取所有类映射
    var allClassMetadata = SharpArch.NHibernate.NHibernateSession.GetDefaultSessionFactory().GetAllClassMetadata();
    var manager = Manager.Create(Host, GenerationEnvironment);  
    foreach (var entry in allClassMetadata)
    {
       var entityName = entry.Value.EntityName.Split('.'); 
       var className = entityName[entityName.Length - 1];
        // 定义输出文件
        manager.StartNewFile("I"+className+"Repository.cs");
       #>//-------------------------------------------------------------------
//版权所有：版权所有(C) 2012，Microsoft(China) Co.,LTD
//系统名称： 
//文件名称：I<#=className#>Repository.cs
//模块名称：
//模块编号：
//作　　者：xcli
//创建时间：2013/4/6 12:49:50 
//功能说明：
//-----------------------------------------------------------------
//修改记录： 
//修改人：   
//修改时间： 
//修改内容： 
//-----------------------------------------------------------------  
using System;
using System.Collections.Generic;
using System.Linq; 
using System.Text;
using Cotide.Domain.Contracts.Repositories.Extension; 
namespace Cotide.Domain.Contracts.Repositories 
{ 
        public interface I<#=className#>Repository : IDbProxyRepository<<#=className#>>
        {
 
        } 
}
   <# 
       // 结束输出文件
       manager.EndBlock();
    } 
       // 执行编译
       manager.Process(true);  
    #> 

输出文件效果：

让程序自动执行基于T4文件的编译工作

在MSDN-”演练：创建自定义文本模板宿主“ 文章里面看到一段代码，进行了T4文件的编译工作,代码如下：

using System;
using System.IO;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.Text;
using Microsoft.VisualStudio.TextTemplating;
 
namespace CustomHost
{
    //The text template transformation engine is responsible for running 
    //the transformation process.
    //The host is responsible for all input and output, locating files, 
    //and anything else related to the external environment.
    //-------------------------------------------------------------------------
    class CustomCmdLineHost : ITextTemplatingEngineHost
    {
        //the path and file name of the text template that is being processed
        //---------------------------------------------------------------------
        internal string TemplateFileValue;
        public string TemplateFile
        {
            get { return TemplateFileValue; }
        }
        //This will be the extension of the generated text output file.
        //The host can provide a default by setting the value of the field here.
        //The engine can change this value based on the optional output directive
        //if the user specifies it in the text template.
        //---------------------------------------------------------------------
        private string fileExtensionValue = ".txt";
        public string FileExtension
        {
            get { return fileExtensionValue; }
        }
        //This will be the encoding of the generated text output file.
        //The host can provide a default by setting the value of the field here.
        //The engine can change this value based on the optional output directive
        //if the user specifies it in the text template.
        //---------------------------------------------------------------------
        private Encoding fileEncodingValue = Encoding.UTF8;
        public Encoding FileEncoding
        {
            get { return fileEncodingValue; }
        }
        //These are the errors that occur when the engine processes a template.
        //The engine passes the errors to the host when it is done processing,
        //and the host can decide how to display them. For example, the host 
        //can display the errors in the UI or write them to a file.
        //---------------------------------------------------------------------
        private CompilerErrorCollection errorsValue;
        public CompilerErrorCollection Errors
        {
            get { return errorsValue; }
        }
        //The host can provide standard assembly references.
        //The engine will use these references when compiling and
        //executing the generated transformation class.
        //--------------------------------------------------------------
        public IList<string> StandardAssemblyReferences
        {
            get
            {
                return new string[]
                {
                    //If this host searches standard paths and the GAC,
                    //we can specify the assembly name like this.
                    //---------------------------------------------------------
                    //"System"
 
                    //Because this host only resolves assemblies from the 
                    //fully qualified path and name of the assembly,
                    //this is a quick way to get the code to give us the
                    //fully qualified path and name of the System assembly.
                    //---------------------------------------------------------
                    typeof(System.Uri).Assembly.Location
                };
            }
        }
        //The host can provide standard imports or using statements.
        //The engine will add these statements to the generated 
        //transformation class.
        //--------------------------------------------------------------
        public IList<string> StandardImports
        {
            get
            {
                return new string[]
                {
                    "System"
                };
            }
        }
        //The engine calls this method based on the optional include directive
        //if the user has specified it in the text template.
        //This method can be called 0, 1, or more times.
        //---------------------------------------------------------------------
        //The included text is returned in the context parameter.
        //If the host searches the registry for the location of include files,
        //or if the host searches multiple locations by default, the host can
        //return the final path of the include file in the location parameter.
        //---------------------------------------------------------------------
        public bool LoadIncludeText(string requestFileName, out string content, out string location)
        {
            content = System.String.Empty;
            location = System.String.Empty;
        
            //If the argument is the fully qualified path of an existing file,
            //then we are done.
            //----------------------------------------------------------------
            if (File.Exists(requestFileName))
            {
                content = File.ReadAllText(requestFileName);
                return true;
            }
            //This can be customized to search specific paths for the file.
            //This can be customized to accept paths to search as command line
            //arguments.
            //----------------------------------------------------------------
            else
            {
                return false;
            }
        }
        //Called by the Engine to enquire about 
        //the processing options you require. 
        //If you recognize that option, return an 
        //appropriate value. 
        //Otherwise, pass back NULL.
        //--------------------------------------------------------------------
        public object GetHostOption(string optionName)
        {
        object returnObject;
        switch (optionName)
        {
        case "CacheAssemblies":
                    returnObject = true;
     break;
        default:
        returnObject = null;
        break;
        }
        return returnObject;
        }
        //The engine calls this method to resolve assembly references used in
        //the generated transformation class project and for the optional 
        //assembly directive if the user has specified it in the text template.
        //This method can be called 0, 1, or more times.
        //---------------------------------------------------------------------
        public string ResolveAssemblyReference(string assemblyReference)
        {
            //If the argument is the fully qualified path of an existing file,
            //then we are done. (This does not do any work.)
            //----------------------------------------------------------------
            if (File.Exists(assemblyReference))
            {
                return assemblyReference;
            }
            //Maybe the assembly is in the same folder as the text template that 
            //called the directive.
            //----------------------------------------------------------------
            string candidate = Path.Combine(Path.GetDirectoryName(this.TemplateFile), assemblyReference);
            if (File.Exists(candidate))
            {
                return candidate;
            }
            //This can be customized to search specific paths for the file
            //or to search the GAC.
            //----------------------------------------------------------------
            //This can be customized to accept paths to search as command line
            //arguments.
            //----------------------------------------------------------------
            //If we cannot do better, return the original file name.
            return "";
        }
        //The engine calls this method based on the directives the user has 
        //specified in the text template.
        //This method can be called 0, 1, or more times.
        //---------------------------------------------------------------------
        public Type ResolveDirectiveProcessor(string processorName)
        {
            //This host will not resolve any specific processors.
            //Check the processor name, and if it is the name of a processor the 
            //host wants to support, return the type of the processor.
            //---------------------------------------------------------------------
            if (string.Compare(processorName, "XYZ", StringComparison.OrdinalIgnoreCase) == 0)
            {
                //return typeof();
            }
            //This can be customized to search specific paths for the file
            //or to search the GAC
            //If the directive processor cannot be found, throw an error.
            throw new Exception("Directive Processor not found");
        }
        //A directive processor can call this method if a file name does not 
        //have a path.
        //The host can attempt to provide path information by searching 
        //specific paths for the file and returning the file and path if found.
        //This method can be called 0, 1, or more times.
        //---------------------------------------------------------------------
        public string ResolvePath(string fileName)
        {
            if (fileName == null)
            {
                throw new ArgumentNullException("the file name cannot be null");
            }
            //If the argument is the fully qualified path of an existing file,
            //then we are done
            //----------------------------------------------------------------
            if (File.Exists(fileName))
            {
                return fileName;
            }
            //Maybe the file is in the same folder as the text template that 
            //called the directive.
            //----------------------------------------------------------------
            string candidate = Path.Combine(Path.GetDirectoryName(this.TemplateFile), fileName);
            if (File.Exists(candidate))
            {
                return candidate;
            }
            //Look more places.
            //----------------------------------------------------------------
            //More code can go here...
            //If we cannot do better, return the original file name.
            return fileName;
        }
        //If a call to a directive in a text template does not provide a value
        //for a required parameter, the directive processor can try to get it
        //from the host by calling this method.
        //This method can be called 0, 1, or more times.
        //---------------------------------------------------------------------
        public string ResolveParameterValue(string directiveId, string processorName, string parameterName)
        {
            if (directiveId == null)
            {
                throw new ArgumentNullException("the directiveId cannot be null");
            }
            if (processorName == null)
            {
                throw new ArgumentNullException("the processorName cannot be null");
            }
            if (parameterName == null)
            {
                throw new ArgumentNullException("the parameterName cannot be null");
            }
            //Code to provide "hard-coded" parameter values goes here.
            //This code depends on the directive processors this host will interact with.
            //If we cannot do better, return the empty string.
            return String.Empty;
        }
        //The engine calls this method to change the extension of the 
        //generated text output file based on the optional output directive 
        //if the user specifies it in the text template.
        //---------------------------------------------------------------------
        public void SetFileExtension(string extension)
        {
            //The parameter extension has a '.' in front of it already.
            //--------------------------------------------------------
            fileExtensionValue = extension;
        }
        //The engine calls this method to change the encoding of the 
        //generated text output file based on the optional output directive 
        //if the user specifies it in the text template.
        //----------------------------------------------------------------------
        public void SetOutputEncoding(System.Text.Encoding encoding, bool fromOutputDirective)
        {
            fileEncodingValue = encoding;
        }
        //The engine calls this method when it is done processing a text
        //template to pass any errors that occurred to the host.
        //The host can decide how to display them.
        //---------------------------------------------------------------------
        public void LogErrors(CompilerErrorCollection errors)
        {
            errorsValue = errors;
        }
        //This is the application domain that is used to compile and run
        //the generated transformation class to create the generated text output.
        //----------------------------------------------------------------------
        public AppDomain ProvideTemplatingAppDomain(string content)
        {
            //This host will provide a new application domain each time the 
            //engine processes a text template.
            //-------------------------------------------------------------
            return AppDomain.CreateDomain("Generation App Domain");
            //This could be changed to return the current appdomain, but new 
            //assemblies are loaded into this AppDomain on a regular basis.
            //If the AppDomain lasts too long, it will grow indefintely, 
            //which might be regarded as a leak.
            //This could be customized to cache the application domain for 
            //a certain number of text template generations (for example, 10).
            //This could be customized based on the contents of the text 
            //template, which are provided as a parameter for that purpose.
        }
    }
    //This will accept the path of a text template as an argument.
    //It will create an instance of the custom host and an instance of the
    //text templating transformation engine, and will transform the
    //template to create the generated text output file.
    //-------------------------------------------------------------------------
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                ProcessTemplate(args);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
        static void ProcessTemplate(string[] args)
        {
            string templateFileName = null;
            if (args.Length == 0)
            {
                throw new System.Exception("you must provide a text template file path");
            }
            templateFileName = args[0];
            if (templateFileName == null)
            {
                throw new ArgumentNullException("the file name cannot be null");
            }
            if (!File.Exists(templateFileName))
            {
                throw new FileNotFoundException("the file cannot be found");
            }
            CustomCmdLineHost host = new CustomCmdLineHost();
            Engine engine = new Engine();
            host.TemplateFileValue = templateFileName;
            //Read the text template.
            string input = File.ReadAllText(templateFileName);
            //Transform the text template.
            string output = engine.ProcessTemplate(input, host);
            string outputFileName = Path.GetFileNameWithoutExtension(templateFileName);
            outputFileName = Path.Combine(Path.GetDirectoryName(templateFileName), outputFileName);
            outputFileName = outputFileName + "1" + host.FileExtension;
            File.WriteAllText(outputFileName, output, host.FileEncoding);
 
            foreach (CompilerError error in host.Errors)
            {
                Console.WriteLine(error.ToString());
            }
        }
    }
}

联想：基于这个代码实例，可以做一个基于T4模板来批量输出代码的小工具,待续.....

参考资料

MultipleOutputHelper.ttinclude 文件作者（Damien Guard）- 博客（ http://damieng.com ）
Damien Guard （Github）（ https://github.com/damieng ）
创建自定义文本模板宿主( ＭＳＤＮ) ( http://msdn.microsoft.com/zh-cn/library/vstudio/bb126579.aspx )
使用T4模板生成代码 - 初探（ http://www.cotide.com/xcli/Blog/Article/44 ）

转自 http://www.cnblogs.com/K_tommy/archive/2013/04/06/T4.html

查看全文

相关阅读:
Linux账户密码安全策略设置 /etc/login.defs:
GPS网络时间服务器安装注意事项
 ntp时间校准服务器的调试方法
 北斗网络时钟服务器的特点
 sntp时间服务器的介绍
 网络校时服务器
 综合时间码分配器介绍
 子母钟系统介绍
 智能计数器简介
 怎样选择通用计数器？

原文地址：https://www.cnblogs.com/slow/p/3611216.html