此文應該算Razor引擎淺析的續篇，或者說淺析是此文的前傳。

為什么要這么做？

1. Asp.Net MVC 其實也不是太好

2. 我有自己的敏捷Web框架, 仍然想用Razor引擎

3. 動態編譯很有意思，這也是將來的一個趨勢，如果有人有興趣，我倒是很想寫寫這方面的內容.

可是也有這些想法的人并不多，找來找去，這方面的資料和論述極其之少。與其臨淵羨魚，不如退而結網。自己動手，豐衣足食。

如Razor引擎淺析所述，Razor的兩大主要功能，模板文件和動態編譯器。我們能不能單純就要而且只要這倆主要特性? 其它那些智能查找視圖文件等，雖不能說是垃圾，也是束縛手腳的條條框框，我完全可以自己做，失去的是一條繩索，獲得是整個世界。

保持模板功能，特別是設計時智能語法支持，很簡單，創建項目時選擇MVC項目，然后把其它MVC相關的引用刪掉只剩下Razor就好了。

編譯? 你根本就找不到這一段代碼，被淹沒在大量的輔助代碼中。幸好，我這里已經找到了，簡化修改之后，就剩下了了幾行，你就可以直接使用在甚至不必是Web項目中。

首先， 用到的Razor域名空間。

using System.Web.Razor;  
using System.Web.Razor.Generator;  
using System.Web.Razor.Parser; 

第一步，動態編譯：解析視圖文件，生成代碼，是的，生成代碼，先。Razor的語法可以說是私有語法，需要先生成標準代碼，然后才編譯，生成我們熟悉的C#類Type。需要注意的是，我下面代碼用的模板基類是我自己的TeamplateBase，后面會給出簡單實現，當然，好處就是靈活性。你也可以直接用Asp.Net MVC的System.Web.Mvc.WebViewPage, 不過我沒有試過，也許會有其他問題，不能保證。

public static Type Compile<T>(string template_path)  
      {  
          //準備臨時類名，讀取模板文件和Razor代碼生成器  
          var class_name = "c" + Guid.NewGuid().ToString("N");  
          var base_type = typeof(TemplateBase<>).MakeGenericType(typeof(T));  
          var template = File.ReadAllText(template_path);  
   
          var host = new RazorEngineHost(new CSharpRazorCodeLanguage(), () => new HtmlMarkupParser())  
                         {  
   
                             DefaultBaseClass = base_type.FullName,  
                             DefaultClassName = class_name,  
                             DefaultNamespace = "YourNameSpace.dynamic",  
                             GeneratedClassContext =  
                                 new GeneratedClassContext("Execute", "Write", "WriteLiteral", "WriteTo",  
                                                           "WriteLiteralTo",  
                                                           "YourNameSpace.TemplateBase")  
   
                         };  
          host.NamespaceImports.Add("System");  
          host.NamespaceImports.Add("YourNameSpaces");  
             
          //生成代碼  
          CodeCompileUnit code;  
          using (var reader = new StringReader(template)) {  
              var generatedCode = new RazorTemplateEngine(host).GenerateCode(reader);  
              code = generatedCode.GeneratedCode;  
          }  
          //準備編譯參數  
          var @params = new CompilerParameters  
          {  
              IncludeDebugInformation = false,  
              TempFiles = new TempFileCollection(AppDomain.CurrentDomain.DynamicDirectory),  
              CompilerOptions = "/target:library /optimize",  
              GenerateInMemory = false 
          };  
   
          var assemblies = AppDomain.CurrentDomain  
             .GetAssemblies()  
             .Where(a => !a.IsDynamic)  
             .Select(a => a.Location)  
             .ToArray();  
          @params.ReferencedAssemblies.AddRange(assemblies);  
   
          //編譯  
          var provider = new CSharpCodeProvider();  
          var compiled = provider.CompileAssemblyFromDom(@params, code);  
   
          if (compiled.Errors.Count > 0) {  
              var compileErrors = string.Join("\r\n", compiled.Errors.Cast<object>().Select(o => o.ToString()));  
              throw new ApplicationException("Failed to compile Razor:" + compileErrors);  
          }  
   
          //編譯成功后， 返回編譯后的動態Type  
          return compiled.CompiledAssembly.GetType("Skight.Arch.Presentation.Web.Core.ViewEngins.Razor.dynamic." + class_name);  
   
   
      } 

第二步就簡單多了，就和任何靜態類一樣，用反射創建實例，然后復制Model對象執行模板，最后輸出結果是，就自動吧Model類的數據嵌入了。

public static string Render<T>(T model,string template_path)  
      {  
          var type = Compile<T>(template_path);  
          //創建視圖實例  
          var instance = (TemplateBase<T>)Activator.CreateInstance(type);  
   
          //執行模板（把數據嵌入文件）  
          instance.Model = model;  
          instance.Execute();  
          //輸出最終結果  
          var result = instance.Result;  
   
          return result;  
      } 

最后，看看視圖模板類，一個基類和一個泛型基類，后者用于前類型Model

public abstract class TemplateBase  
    {  
        public string Layout { get; set; }  
        public UrlHelper Url { get; set; }  
        public Func<string> RenderBody { get; set; }  
        public string Path { get; internal set; }  
        public string Result { get { return Writer.ToString(); } }  
   
        protected TemplateBase()  
        {  
        }  
   
        public TextWriter Writer  
        {  
            get 
            {  
                if(writer==null)  
                {writer = new StringWriter();  
                }  
                return writer;  
            }  
            set {  
                writer = value;  
            }  
        }  
   
        private TextWriter writer;  
   
        public void Clear() {  
           Writer.Flush();  
        }  
   
        public virtual void Execute() { }  
   
        public void Write(object @object) {  
            if (@object == null) {  
                return;  
            }  
            Writer.Write(@object);  
        }  
   
        public void WriteLiteral(string @string) {  
            if (@string == null) {  
                return;  
            }  
            Writer.Write(@string);  
        }  
   
        public static void WriteLiteralTo(TextWriter writer, string literal) {  
            if (literal == null) {  
                return;  
            }  
            writer.Write(literal);  
        }  
   
        public static void WriteTo(TextWriter writer, object obj) {  
            if (obj == null) {  
                return;  
            }  
            writer.Write(obj);  
        }  
    }  
    public abstract class TemplateBase<T> :TemplateBase  
    {  
        public T Model { get; set; }              
    } 

原文鏈接：http://www.cnblogs.com/Wonner/archive/2012/03/12/2391212.html