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()[0];

                }

                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"

            });

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