Razor模板引擎是现在比较流行的模板解析器，由于其语法简洁方便，深受码农的喜爱。最近由于项目需要编写一个自己的解析器，用来实现代码的自动生成，自动生成代码范畴不限数据库实体生成，也可能会追加winform表单的生成，这样T4模板就不能很好胜任了（也许可以胜任，但是T4模板多数用来数据库实体生成，其他类型的生成需要编辑T4模板，但是T4模板编辑很麻烦）。
首先来看下效果，在图片的右侧解决方案管理器中有 Entity.rct文件，其下有Entity.rc.cs文件。其中Entity.rc.cs就是由自定义工具 RazorTemplateTool生成的。
实现RazorTemplateTool自定义工具需要实现如下几步。
第一步：新建项目 -》 选择扩展项 -》 vsix project
编辑 source.extension.vsixmanifest 文件，或者覆盖该文件内容，VS2012之后格式有所调整，未曾尝试过，所以覆盖此文件内容成功的几率大。
<?xml version="1.0" encoding="utf-8"?>
<Vsix xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" Version="1.0.0" xmlns="http://schemas.microsoft.com/developer/vsx-schema/2010">
<Identifier Id="2FD58EB3-29A2-40A3-BE17-C024CA9A17A2">
<Name>RazorTemplateTool</Name>
<Author>Simon</Author>
<Version>1.0.2</Version>
<Description xml:space="preserve">Generates source code from Razor files (.rct files).</Description>
<Locale>1033</Locale>
<MoreInfoUrl>http://www.cnblogs.com/guozhong111/</MoreInfoUrl>
<Icon>jari-b.ico</Icon>
<PreviewImage>jari-b.ico</PreviewImage>
<License>License.txt</License>
<SupportedProducts>
<VisualStudio Version="11.0">
<Edition>Ultimate</Edition>
<Edition>Premium</Edition>
<Edition>Pro</Edition>
</VisualStudio>
<VisualStudio Version="12.0">
<Edition>Ultimate</Edition>
<Edition>Premium</Edition>
<Edition>Pro</Edition>
</VisualStudio>
<VisualStudio Version="14.0">
<Edition>Ultimate</Edition>
<Edition>Premium</Edition>
<Edition>Pro</Edition>
</VisualStudio>
</SupportedProducts>
<SupportedFrameworkRuntimeEdition MinVersion="4.0" MaxVersion="4.0" />
</Identifier>
<References />
<Content>
<VsPackage>RazorTemplateTool.pkgdef</VsPackage>
</Content>
</Vsix>
添加类BaseCodeGenerator ，该类实现接口IVsSingleFileGenerator
/// <summary>
/// A managed wrapper for VS's concept of an IVsSingleFileGenerator which is
/// a custom tool invoked at design time which can take any file as an input
/// and provide any file as output.
/// </summary>
public abstract class BaseCodeGenerator : IVsSingleFileGenerator
{
private IVsGeneratorProgress codeGeneratorProgress;
private string codeFileNameSpace = String.Empty;
private string codeFilePath = String.Empty;
#region IVsSingleFileGenerator Members
/// <summary>
/// Implements the IVsSingleFileGenerator.DefaultExtension method.
/// Returns the extension of the generated file
/// </summary>
/// <param name="pbstrDefaultExtension">Out parameter, will hold the extension that is to be given to the output file name. The returned extension must include a leading period</param>
/// <returns>S_OK if successful, E_FAIL if not</returns>
int IVsSingleFileGenerator.DefaultExtension(out string pbstrDefaultExtension)
{
try
{
pbstrDefaultExtension = GetDefaultExtension();
return VSConstants.S_OK;
}
catch (Exception e)
{
Trace.WriteLine("获取默认扩展名失败.");
Trace.WriteLine(e.ToString());
pbstrDefaultExtension = string.Empty;
return VSConstants.E_FAIL;
}
}
/// <summary>
/// Implements the IVsSingleFileGenerator.Generate method.
/// Executes the transformation and returns the newly generated output file, whenever a custom tool is loaded, or the input file is saved
/// </summary>
/// <param name="wszInputFilePath">The full path of the input file. May be a null reference (Nothing in Visual Basic) in future releases of Visual Studio, so generators should not rely on this value</param>
/// <param name="bstrInputFileContents">The contents of the input file. This is either a UNICODE BSTR (if the input file is text) or a binary BSTR (if the input file is binary). If the input file is a text file, the project system automatically converts the BSTR to UNICODE</param>
/// <param name="wszDefaultNamespace">This parameter is meaningful only for custom tools that generate code. It represents the namespace into which the generated code will be placed. If the parameter is not a null reference (Nothing in Visual Basic) and not empty, the custom tool can use the following syntax to enclose the generated code</param>
/// <param name="rgbOutputFileContents">[out] Returns an array of bytes to be written to the generated file. You must include UNICODE or UTF-8 signature bytes in the returned byte array, as this is a raw stream. The memory for rgbOutputFileContents must be allocated using the .NET Framework call, System.Runtime.InteropServices.AllocCoTaskMem, or the equivalent Win32 system call, CoTaskMemAlloc. The project system is responsible for freeing this memory</param>
/// <param name="pcbOutput">[out] Returns the count of bytes in the rgbOutputFileContent array</param>
/// <param name="pGenerateProgress">A reference to the IVsGeneratorProgress interface through which the generator can report its progress to the project system</param>
/// <returns>If the method succeeds, it returns S_OK. If it fails, it returns E_FAIL</returns>
int IVsSingleFileGenerator.Generate(string wszInputFilePath, string bstrInputFileContents, string wszDefaultNamespace, IntPtr[] rgbOutputFileContents, out uint pcbOutput, IVsGeneratorProgress pGenerateProgress)
{
if (bstrInputFileContents == null)
{
throw new ArgumentNullException(bstrInputFileContents);
}
codeFilePath = wszInputFilePath;
codeFileNameSpace = wszDefaultNamespace;
codeGeneratorProgress = pGenerateProgress;
byte[] bytes = GenerateCode(bstrInputFileContents);
if (bytes == null)
{
// This signals that GenerateCode() has failed. Tasklist items have been put up in GenerateCode()
rgbOutputFileContents = null;
pcbOutput = 0;
// Return E_FAIL to inform Visual Studio that the generator has failed (so that no file gets generated)
return VSConstants.E_FAIL;
}
else
{
// The contract between IVsSingleFileGenerator implementors and consumers is that
// any output returned from IVsSingleFileGenerator.Generate() is returned through
// memory allocated via CoTaskMemAlloc(). Therefore, we have to convert the
// byte[] array returned from GenerateCode() into an unmanaged blob.
int outputLength = bytes.Length;
rgbOutputFileContents[0] = Marshal.AllocCoTaskMem(outputLength);
Marshal.Copy(bytes, 0, rgbOutputFileContents[0], outputLength);
pcbOutput = (uint)outputLength;
return VSConstants.S_OK;
}
}
#endregion
/// <summary>
/// Namespace for the file
/// </summary>
protected string FileNameSpace
{
get
{
return codeFileNameSpace;
}
}
/// <summary>
/// File-path for the input file
/// </summary>
protected string InputFilePath
{
get
{
return codeFilePath;
}
}
/// <summary>
/// Interface to the VS shell object we use to tell our progress while we are generating
/// </summary>
internal IVsGeneratorProgress CodeGeneratorProgress
{
get
{
return codeGeneratorProgress;
}
}
/// <summary>
/// Gets the default extension for this generator
/// </summary>
/// <returns>String with the default extension for this generator</returns>
protected abstract string GetDefaultExtension();
/// <summary>
/// The method that does the actual work of generating code given the input file
/// </summary>
/// <param name="inputFileContent">File contents as a string</param>
/// <returns>The generated code file as a byte-array</returns>
protected abstract byte[] GenerateCode(string inputFileContent);
/// <summary>
/// Method that will communicate an error via the shell callback mechanism
/// </summary>
/// <param name="level">Level or severity</param>
/// <param name="message">Text displayed to the user</param>
/// <param name="line">Line number of error</param>
/// <param name="column">Column number of error</param>
protected virtual void GeneratorError(uint level, string message, uint line, uint column)
{
IVsGeneratorProgress progress = CodeGeneratorProgress;
if (progress != null)
{
progress.GeneratorError(0, level, message, line, column);
}
}
/// <summary>
/// Method that will communicate a warning via the shell callback mechanism
/// </summary>
/// <param name="level">Level or severity</param>
/// <param name="message">Text displayed to the user</param>
/// <param name="line">Line number of warning</param>
/// <param name="column">Column number of warning</param>
protected virtual void GeneratorWarning(uint level, string message, uint line, uint column)
{
IVsGeneratorProgress progress = CodeGeneratorProgress;
if (progress != null)
{
progress.GeneratorError(1, level, message, line, column);
}
}
}
添加 BaseCodeGeneratorWithSite类
/// <summary>
/// Base code generator with site implementation
/// </summary>
public abstract class BaseCodeGeneratorWithSite : BaseCodeGenerator, VSOLE.IObjectWithSite
{
private object site = null;
private CodeDomProvider codeDomProvider = null;
private ServiceProvider serviceProvider = null;
#region IObjectWithSite Members
/// <summary>
/// GetSite method of IOleObjectWithSite
/// </summary>
/// <param name="riid">interface to get</param>
/// <param name="ppvSite">IntPtr in which to stuff return value</param>
void VSOLE.IObjectWithSite.GetSite(ref Guid riid, out IntPtr ppvSite)
{
if (site == null)
{
throw new COMException("object is not sited", VSConstants.E_FAIL);
}
IntPtr pUnknownPointer = Marshal.GetIUnknownForObject(site);
IntPtr intPointer = IntPtr.Zero;
Marshal.QueryInterface(pUnknownPointer, ref riid, out intPointer);
if (intPointer == IntPtr.Zero)
{
throw new COMException("site does not support requested interface", VSConstants.E_NOINTERFACE);
}
ppvSite = intPointer;
}
/// <summary>
/// SetSite method of IOleObjectWithSite
/// </summary>
/// <param name="pUnkSite">site for this object to use</param>
void VSOLE.IObjectWithSite.SetSite(object pUnkSite)
{
site = pUnkSite;
codeDomProvider = null;
serviceProvider = null;
}
#endregion
/// <summary>
/// Demand-creates a ServiceProvider
/// </summary>
private ServiceProvider SiteServiceProvider
{
get
{
if (serviceProvider == null)
{
serviceProvider = new ServiceProvider(site as VSOLE.IServiceProvider);
Debug.Assert(serviceProvider != null, "Unable to get ServiceProvider from site object.");
}
return serviceProvider;
}
}
/// <summary>
/// Method to get a service by its GUID
/// </summary>
/// <param name="serviceGuid">GUID of service to retrieve</param>
/// <returns>An object that implements the requested service</returns>
protected object GetService(Guid serviceGuid)
{
return SiteServiceProvider.GetService(serviceGuid);
}
/// <summary>
/// Method to get a service by its Type
/// </summary>
/// <param name="serviceType">Type of service to retrieve</param>
/// <returns>An object that implements the requested service</returns>
protected object GetService(Type serviceType)
{
return SiteServiceProvider.GetService(serviceType);
}
/// <summary>
/// Returns a CodeDomProvider object for the language of the project containing
/// the project item the generator was called on
/// </summary>
/// <returns>A CodeDomProvider object</returns>
protected virtual CodeDomProvider GetCodeProvider()
{
if (codeDomProvider == null)
{
//Query for IVSMDCodeDomProvider/SVSMDCodeDomProvider for this project type
IVSMDCodeDomProvider provider = GetService(typeof(SVSMDCodeDomProvider)) as IVSMDCodeDomProvider;
if (provider != null)
{
codeDomProvider = provider.CodeDomProvider as CodeDomProvider;
}
else
{
//In the case where no language specific CodeDom is available, fall back to C#
codeDomProvider = CodeDomProvider.CreateProvider("C#");
}
}
return codeDomProvider;
}
/// <summary>
/// Gets the default extension of the output file from the CodeDomProvider
/// </summary>
/// <returns></returns>
protected override string GetDefaultExtension()
{
CodeDomProvider codeDom = GetCodeProvider();
Debug.Assert(codeDom != null, "CodeDomProvider is NULL.");
string extension = codeDom.FileExtension;
if (extension != null && extension.Length > 0)
{
extension = ".rc." + extension.TrimStart(".".ToCharArray());
}
return extension;
}
/// <summary>
/// Returns the EnvDTE.ProjectItem object that corresponds to the project item the code
/// generator was called on
/// </summary>
/// <returns>The EnvDTE.ProjectItem of the project item the code generator was called on</returns>
protected ProjectItem GetProjectItem()
{
object p = GetService(typeof(ProjectItem));
Debug.Assert(p != null, "Unable to get Project Item.");
return (ProjectItem)p;
}
/// <summary>
/// Returns the EnvDTE.Project object of the project containing the project item the code
/// generator was called on
/// </summary>
/// <returns>
/// The EnvDTE.Project object of the project containing the project item the code generator was called on
/// </returns>
protected Project GetProject()
{
return GetProjectItem().ContainingProject;
}
}
添加工具属性类 CustomToolAttribute
/// <summary>
/// This attribute adds a custom file generator registry entry for specific file
/// type.
/// For Example:
/// [HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\9.0\Generators\
/// {fae04ec1-301f-11d3-bf4b-00c04f79efbc}\MyGenerator]
/// "CLSID"="{AAAA53CC-3D4F-40a2-BD4D-4F3419755476}"
/// "GeneratesDesignTimeSource" = d'1'
///
/// </summary>
[AttributeUsage(AttributeTargets.Class, AllowMultiple = true, Inherited = true)]
public sealed class CustomToolAttribute : RegistrationAttribute
{
private string _contextGuid;
private Type _generatorType;
private Guid _generatorGuid;
private string _generatorName;
private string _generatorRegKeyName;
private bool _generatesDesignTimeSource = false;
private bool _generatesSharedDesignTimeSource = false;
/// <summary>
/// Creates a new CodeGeneratorRegistrationAttribute attribute to register a custom
/// code generator for the provided context.
/// </summary>
/// <param name="generatorType">The type of Code generator. Type that implements IVsSingleFileGenerator</param>
/// <param name="generatorName">The generator name</param>
/// <param name="contextGuid">The context GUID this code generator would appear under.</param>
public CustomToolAttribute(Type generatorType, string generatorName, string contextGuid)
{
if (generatorType == null)
throw new ArgumentNullException("generatorType");
if (generatorName == null)
throw new ArgumentNullException("generatorName");
if (contextGuid == null)
throw new ArgumentNullException("contextGuid");
_contextGuid = contextGuid;
_generatorType = generatorType;
_generatorName = generatorName;
_generatorRegKeyName = generatorType.Name;
_generatorGuid = generatorType.GUID;
}
/// <summary>
/// Get the generator Type
/// </summary>
public Type GeneratorType
{
get { return _generatorType; }
}
/// <summary>
/// Get the Guid representing the project type
/// </summary>
public string ContextGuid
{
get { return _contextGuid; }
}
/// <summary>
/// Get the Guid representing the generator type
/// </summary>
public Guid GeneratorGuid
{
get { return _generatorGuid; }
}
/// <summary>
/// Get or Set the GeneratesDesignTimeSource value
/// </summary>
public bool GeneratesDesignTimeSource
{
get { return _generatesDesignTimeSource; }
set { _generatesDesignTimeSource = value; }
}
/// <summary>
/// Get or Set the GeneratesSharedDesignTimeSource value
/// </summary>
public bool GeneratesSharedDesignTimeSource
{
get { return _generatesSharedDesignTimeSource; }
set { _generatesSharedDesignTimeSource = value; }
}
/// <summary>
/// Gets the Generator name
/// </summary>
public string GeneratorName
{
get { return _generatorName; }
}
/// <summary>
/// Gets the Generator reg key name under
/// </summary>
public string GeneratorRegKeyName
{
get { return _generatorRegKeyName; }
set { _generatorRegKeyName = value; }
}
/// <summary>
/// Property that gets the generator base key name
/// </summary>
private string GeneratorRegKey
{
get { return string.Format(CultureInfo.InvariantCulture, @"Generators\{0}\{1}", ContextGuid, GeneratorRegKeyName); }
}
/// <summary>
/// Called to register this attribute with the given context. The context
/// contains the location where the registration inforomation should be placed.
/// It also contains other information such as the type being registered and path information.
/// </summary>
public override void Register(RegistrationContext context)
{
using (Key childKey = context.CreateKey(GeneratorRegKey))
{
childKey.SetValue(string.Empty, GeneratorName);
childKey.SetValue("CLSID", GeneratorGuid.ToString("B"));
if (GeneratesDesignTimeSource)
childKey.SetValue("GeneratesDesignTimeSource", 1);
if (GeneratesSharedDesignTimeSource)
childKey.SetValue("GeneratesSharedDesignTimeSource", 1);
}
}
/// <summary>
/// Unregister this file extension.
/// </summary>
/// <param name="context"></param>
public override void Unregister(RegistrationContext context)
{
context.RemoveKey(GeneratorRegKey);
}
}
最后添加实现类 RazorTemplateTool
/// <summary>
/// This is the generator class.
/// When setting the 'Custom Tool' property of a C#, VB, or J# project item to "RazorGenerator",
/// the GenerateCode function will get called and will return the contents of the generated file
/// to the project system
/// </summary>
[ComVisible(true)]
[Guid("52B316AA-1997-4c81-9969-83604C09EEB4")]
[CustomTool(typeof(RazorTemplateTool), "C# Razor Generator", "{FAE04EC1-301F-11D3-BF4B-00C04F79EFBC}", GeneratesDesignTimeSource = true)]
[ProvideObject(typeof(RazorTemplateTool))]
public class RazorTemplateTool : BaseCodeGeneratorWithSite
{
/// <summary>
/// Function that builds the contents of the generated file based on the contents of the input file
/// </summary>
/// <param name="inputFileContent">Content of the input file</param>
/// <returns>Generated file as a byte array</returns>
protected override byte[] GenerateCode(string inputFileContent)
{
try
{
Rc.Template.TemplateTool tt = new Rc.Template.TemplateTool();
return ConvertToBytes(tt.ParseTemplateContent(inputFileContent,InputFilePath));
}
catch (InvalidOperationException exception)
{
GeneratorError(0, exception.Message, 0, 0);
return ConvertToBytes(exception.Message);
}
catch (Exception exception)
{
GeneratorError(0, exception.Message, 0, 0);
}
return null;
}
private static byte[] ConvertToBytes(string content)
{
//Get the preamble (byte-order mark) for our encoding
byte[] preamble = Encoding.UTF8.GetPreamble();
int preambleLength = preamble.Length;
byte[] body = Encoding.UTF8.GetBytes(content);
//Prepend the preamble to body (store result in resized preamble array)
Array.Resize<byte>(ref preamble, preambleLength + body.Length);
Array.Copy(body, 0, preamble, preambleLength, body.Length);
//Return the combined byte array
return preamble;
}
}
这样整个功能就实现了，剩下就是打包和安装了。
第二步：安装 插件包
136
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
