DIY RazorEngine 的程序集生成方式

最近遇到一个项目,要使用RazorEngine做模板引擎,然后完成简易的CMS功能,以减轻重复的CDRU操作,同时复用管理后台。没错,使用的正是GIT HUB上的开源项目:https://github.com/Antaris/RazorEngine 。模板编译过程非常耗时,所以Razor提供了Compile和Parse的带key参数的重载,以实现从缓存中加载编译后的模板的功能。不过这里还是有一个问题,对于web项目而言,应用程序池会周期性的回收(即使设置了不自动回收,不知为何)。所以,仍然会存在重新编译而导致页面长时间挂起的问题。或许可以提供一个进度条,告诉客户这是一个高大上的东西,需要热身....不过应该有更好的办法,就是从RazorEngine本身着手。

RazorEngine接收到模板内容的时候,会调用编辑器将其编译成一个程序集,加载到内存中,同时返回编译好的对应的模板的类型对象(Type对象)。然后调用对象的构造函数,生成对象实例,最后“执行”模板。BUT!为什么是加载到内存呢,如果是将程序集保存在磁盘上,那么下次再进行读取的话,这个性能绝对不是同一个档次的。所以,考虑之后,决定用以下的思路解决问题:

获取到模板之后(字符串),会计算其MD5值,并作为生成的模板类型的Class(有坑),同时将其作为程序集的名称。每当客户机代码请求编译模板的时候,就去指定的目录查找是否有这么一个程序集,如果有,直接加载这个程序集,并返回类型信息(因为程序集中只有一个类型,所以非常方便)。RazorEngine本身采用了可扩展的设计。扩展口就在Razor.SetTemplateService()。只需要实现CompilerServiceBase抽象类,就能自定义模板引擎的逻辑。只是...代码编译部分处于调用的较底层,如果全部采用全新的实现的话...工作量不少,而且容易存在BUG。SO...原样应用RazorEngine.dll并进行扩展这么完美的事情暂时还办不到。我采用的做法是,修改RazorEngine的源码,但是不修改已经定义的类型,只在相应的名称空间下面提供新的类型来满足自己的需求(因为其中不少需要的类型是internal的)。

参考TemplateService的源码,实现了一个ReloadableTemplateService,重新实现了CreateTemplateType方法:

[Pure]
public virtual Type CreateTemplateType(string razorTemplate, Type modelType)
{
//重要:类名不能以数字开头
var key = GetTemplateMd5(razorTemplate);
string className = "C" + key;
var assemblyPath = AssemblyDirecotry.TrimEnd(new[] { '/', '\\' }) + "\\" + key + ".dll"; if (File.Exists(assemblyPath))
{
try
{
//var assembly = Assembly.Load(File.ReadAllBytes(assemblyPath));
var assembly = Assembly.LoadFile(assemblyPath);
return assembly.GetTypes()[];
}
catch (Exception ex)
{
Debug.WriteLine("an error ocured and assembly has been deleted");
File.Delete(assemblyPath);
}
} var context = new TypeContext
{
ModelType = (modelType == null) ? typeof(object) : modelType,
TemplateContent = razorTemplate,
TemplateType = (_config.BaseTemplateType) ?? typeof(TemplateBase<>),
}; foreach (string ns in _config.Namespaces)
context.Namespaces.Add(ns); //csharp only
var service = new CSharpFileDirectCompilerService(); service.Debug = _config.Debug;
service.CodeInspectors = _config.CodeInspectors ?? Enumerable.Empty<ICodeInspector>(); var result = service.CompileType(context, className, assemblyPath);
_assemblies.Add(result.Item2); return result.Item1;
}

需要注意是,C#的类型名称不能以数字开头...这个问题我查了一下午,主要是压根没有想到这一点。生成程序集的方法,被放置在CSharpFileDirectCompilerService中,由于这个类型的局限性很强(我只是想快速解决问题),所以没有实现基类要求的方法(我把它废了,虽然这样很傻逼):

[Pure]
private Tuple<CompilerResults, string> Compile(TypeContext context, string className, string assemblyPath)
{
if (_disposed)
throw new ObjectDisposedException(GetType().Name); var compileUnit = GetCodeCompileUnit(className, context.TemplateContent, context.Namespaces,
context.TemplateType, context.ModelType); var @params = new CompilerParameters
{
GenerateInMemory = false,
OutputAssembly = assemblyPath,
GenerateExecutable = false,
IncludeDebugInformation = false,
CompilerOptions = "/target:library /optimize /define:RAZORENGINE"
}; var assemblies = CompilerServicesUtility
.GetLoadedAssemblies()
.Where(a => !a.IsDynamic && File.Exists(a.Location))
.GroupBy(a => a.GetName().Name)
.Select(grp => grp.First(y => y.GetName().Version == grp.Max(x => x.GetName().Version)))
// only select distinct assemblies based on FullName to avoid loading duplicate assemblies
.Select(a => a.Location); var includeAssemblies = (IncludeAssemblies() ?? Enumerable.Empty<string>());
assemblies = assemblies.Concat(includeAssemblies)
.Where(a => !string.IsNullOrWhiteSpace(a))
.Distinct(StringComparer.InvariantCultureIgnoreCase); @params.ReferencedAssemblies.AddRange(assemblies.ToArray()); string sourceCode = null;
if (Debug)
{
var builder = new StringBuilder();
using (var writer = new StringWriter(builder, CultureInfo.InvariantCulture))
{
_codeDomProvider.GenerateCodeFromCompileUnit(compileUnit, writer, new CodeGeneratorOptions());
sourceCode = builder.ToString();
}
} return Tuple.Create(_codeDomProvider.CompileAssemblyFromDom(@params, compileUnit), sourceCode);
} /// <summary>
/// Compiles the type defined in the specified type context.
/// </summary>
/// <param name="context">The type context which defines the type to compile.</param>
/// <returns>The compiled type.</returns>
[Pure, SecurityCritical,Obsolete("该方法无法兼容其父类,功能已经在其重载中提供")]
public override Tuple<Type, Assembly> CompileType(TypeContext context)
{
throw new NotImplementedException("该方法无法兼容其父类,功能已经在其重载中提供");
} /// <summary>
///
/// </summary>
/// <param name="context"></param>
/// <param name="className"></param>
/// <param name="assemblyDirectory"></param>
/// <returns></returns>
/// <exception cref="NullReferenceException"></exception>
/// <exception cref="TemplateCompilationException"></exception>
public Tuple<Type, Assembly> CompileType(TypeContext context, string className, string assemblyDirectory)
{
if (context == null)
throw new NullReferenceException("context");
var result = Compile(context, className, assemblyDirectory);
var compileResult = result.Item1; if (compileResult.Errors != null && compileResult.Errors.HasErrors)
throw new TemplateCompilationException(compileResult.Errors, result.Item2, context.TemplateContent); return Tuple.Create(
compileResult.CompiledAssembly.GetType("CompiledRazorTemplates.Dynamic." + className),
compileResult.CompiledAssembly);
}

然后就成了,调用方式是:

            Razor.SetTemplateService(new ReloadableTemplateService()
{
AssemblyDirecotry = "d:\\temple"
});

稍微测了下性能,这里定性描述下:编译模板的时候,耗时会根据模板的大小和复杂度,一两秒或者更多。而加载一个程序集的话,尤其是像这种一个类型的小程序集,总是毫秒级的。
真是个愉快的周末。

上一篇:Nginx 的线程池与性能剖析【转载】


下一篇:Windows Phone开发手记-WinRT下启动器替代方案