最近遇到一个项目，要使用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"
});
稍微测了下性能，这里定性描述下：编译模板的时候，耗时会根据模板的大小和复杂度，一两秒或者更多。而加载一个程序集的话，尤其是像这种一个类型的小程序集，总是毫秒级的。
真是个愉快的周末。