【轉】基於ASP.NET MVC3 Razor的模塊化/插件式架構實現——Mainz

　　本文主要探討了一種基於ASP.NET MVC3 Razor的模塊化（Plugin）/插件（plugin）式架構的實現方法。本文借鑒了《Compile your asp.net mvc Razor views into a seperate dll》作者提供的方法。敬請注意。其實ASP.NET MVC的模塊化（Plugin）/插件（plugin）式架構討論的很多，但基於Razor視圖引擎的很少（如：MVC2插件架構例子都是基於WebForm的，MVCContrib Portable Areas也是，還有這個Plugin架構）。要么就是非常復雜非常重量級的框架，例如Orchard CMS的模塊化做的很好，可惜太重量級了，也沒獨立的模塊可以剝離出來。所以我們追尋的是簡單的基於ASP.NET MVC3 Razor的模塊化（Plugin）/插件（plugin）式架構的實現方法。本文最后實現的項目結構如下圖：（插件都放到~/Plugin目錄下，按功能划分模塊，每個模塊都有M,V,C）

　　

　　其中，業務模塊（class library project）包含其所有的視圖、控制器等，模型可以放在里面也可以單獨放一個project。主web項目沒有引用業務模塊，業務模塊會編譯到主web項目的~/plugin目錄下面（注意：不是bin目錄），然后當web應用啟動的時候自動加載plugin目錄下面的模塊。最后運行起來的效果如下圖：

　　

其中紅色的區域都是plugin進去的，那個tab的標題plugin到母版頁的主菜單，tab內容也來自plugin。下面說說如何實現這樣的ASP.NET MVC插件式plugin架構（模塊化架構）。

實現的難點在動態加載UI視圖（*.cshtml, _layout.cshtml, _viewStart.cshtml)

　　廢話少說，直入要害。基於ASP.NET MVC3 Razor的編譯發生在兩個層面：

• 控制器（Controller）, 模型（Models），和其它所有的C#代碼等有msbuild（或者VisualStudio）編譯到bin目錄下的程序集（assembly）
• 視圖（*.aspx, *.cshtml）由ASP.NET在運行時動態編譯。當一個Razor視圖（*.cshtml）顯示前，Razor視圖引擎調用BuildManager把視圖(*.cshtml)編譯到動態程序集assembly，然后使用Activator.CreateInstance來實例化新編譯出來的對象，最后顯示出來。如果視圖(*.cshtml)用到@model綁定model，那么還會自動加載bin或者GAC里面的Model。

　　所以如果我們要動態加載插件（plugin），用反射bin目錄下的程序集（assembly）的方法很容易搞定上面的第一部分（C#代碼的部分），但UI視圖的部分（上面第二部分）（特別是*.cshtml, 母版_layout.cshtml, 基視圖_viewStart.cshtml）就比較難搞定。而且每次報錯都是一樣的，那就是Controller找不到相應的視圖View，基本不知所雲而且根本不是要點：view …. or its master was not found or no view engine supports the searched locations. The following locations were searched: …，因此要搞定UI視圖的部分（上面第二部分）（特別是*.cshtml, 母版_layout.cshtml, 基視圖_viewStart.cshtml），就需要自己動手了，基本原理是：

• 重載RazorBuildProvider，用來動態編譯視圖
• 實現一個自定義VirtualPathProvider，從虛擬路徑自定義判斷讀取資源（從插件中加載資源），如果要使用編譯的視圖就返回編譯的VirtualFile
• 實現一個容器Dictionary保存已編譯的視圖和虛擬路徑，例如path <~/views/team/index.cshtml> type <Area.Module2.Views.Team._Page_Views_Team_Index_cshtml>，或者path <~/views/_viewstart.cshtml> type <Area.Module1.Views._Page_Views__ViewStart_cshtml>

代碼：自定義VirtualPathProvider，從虛擬路徑自定義判斷讀取資源（從插件中加載資源），如果要使用編譯的視圖就返回編譯的VirtualFile

  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Reflection;
  using System.Web.Caching;
  using System.Web.Hosting;
  using System.Web.WebPages;
   
  namespace Common.Framework
  {
      public class CompiledVirtualPathProvider: VirtualPathProvider
      {
          /// <summary>
          /// Gets a value that indicates whether a file exists in the virtual file system.
          /// </summary>
          /// <returns>
          /// true if the file exists in the virtual file system; otherwise, false.
          /// </returns>
          /// <param name="virtualPath">The path to the virtual file.</param>
          public override bool FileExists(string virtualPath)
          {
              return
                  GetCompiledType(virtualPath) != null 
                  || Previous.FileExists(virtualPath);
          }
   
          public Type GetCompiledType(string virtualPath)
          {
              return ApplicationPartRegistry.Instance.GetCompiledType(virtualPath);
          }
   
          /// <summary>
          /// Gets a virtual file from the virtual file system.
          /// </summary>
          /// <returns>
          /// A descendent of the <see cref="T:System.Web.Hosting.VirtualFile"/> class that represents a file in the virtual file system.
          /// </returns>
          /// <param name="virtualPath">The path to the virtual file.</param>
          public override VirtualFile GetFile(string virtualPath)
          {
              if (Previous.FileExists(virtualPath))
              {
                  return Previous.GetFile(virtualPath);
              }
              var compiledType = GetCompiledType(virtualPath);
              if (compiledType != null)
              {
                  return new CompiledVirtualFile(virtualPath, compiledType);
              }
              return null;
          }
   
          public override System.Web.Caching.CacheDependency GetCacheDependency(string virtualPath, System.Collections.IEnumerable virtualPathDependencies, DateTime utcStart)
          {
              if (virtualPathDependencies == null)
                  return Previous.GetCacheDependency(virtualPath, virtualPathDependencies, utcStart);
   
              return Previous.GetCacheDependency(virtualPath, 
                      from vp in virtualPathDependencies.Cast<string>()
                      where GetCompiledType(vp) == null
                      select vp
                    , utcStart);
          }
   
      }
  }

 　　代碼：容器Dictionary保存已編譯的視圖和虛擬路徑，例如path <~/views/team/index.cshtml> type <Area.Module2.Views.Team._Page_Views_Team_Index_cshtml>，路徑注冊以后，會從容器庫全局搜索所有注冊過的視圖，也就是說即使你視圖引用的_layout.cshtml和_viewStart.cshtml在其他的Class library project照樣可以找到。

 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
 using System.Reflection;
 using System.Web;
 using System.Web.WebPages;
  
 namespace Common.Framework
 {
     public class DictionaryBasedApplicationPartRegistry : IApplicationPartRegistry
     {
         private static readonly Type webPageType = typeof(WebPageRenderingBase); 
         private readonly Dictionary<string, Type> registeredPaths = new Dictionary<string, Type>();
  
         /// <summary>
         /// 
         /// </summary>
         /// <param name="virtualPath"></param>
         /// <returns></returns>
         public virtual Type GetCompiledType(string virtualPath)
         {
             if (virtualPath == null) throw new ArgumentNullException("virtualPath");
  
             //Debug.WriteLine(String.Format("---GetCompiledType : virtualPath <{0}>", virtualPath));
  
             if (virtualPath.StartsWith("/"))
                 virtualPath = VirtualPathUtility.ToAppRelative(virtualPath);
             if (!virtualPath.StartsWith("~"))
                 virtualPath = !virtualPath.StartsWith("/") ? "~/" + virtualPath : "~" + virtualPath;
             virtualPath = virtualPath.ToLower();
             return registeredPaths.ContainsKey(virtualPath)
                        ? registeredPaths[virtualPath]
                        : null;
         }
  
         public void Register(Assembly applicationPart)
         {
             ((IApplicationPartRegistry)this).Register(applicationPart, null);
         }
  
         public virtual void Register(Assembly applicationPart, string rootVirtualPath)
         {
             //Debug.WriteLine(String.Format("---Register assembly <{0}>, path <{1}>", applicationPart.FullName, rootVirtualPath));
  
             foreach (var type in applicationPart.GetTypes().Where(type => type.IsSubclassOf(webPageType)))
             {
                 //Debug.WriteLine(String.Format("-----Register type <{0}>, path <{1}>", type.FullName, rootVirtualPath));
  
                 ((IApplicationPartRegistry)this).RegisterWebPage(type, rootVirtualPath);
             }
         }
  
         public void RegisterWebPage(Type type)
         {
             ((IApplicationPartRegistry)this).RegisterWebPage(type, string.Empty);
         }
  
         public virtual void RegisterWebPage(Type type, string rootVirtualPath)
         {
             var attribute = type.GetCustomAttributes(typeof(PageVirtualPathAttribute), false).Cast<PageVirtualPathAttribute>().SingleOrDefault<PageVirtualPathAttribute>();
             if (attribute != null)
             {
                 var rootRelativeVirtualPath = GetRootRelativeVirtualPath(rootVirtualPath ?? "", attribute.VirtualPath);
  
                 //Debug.WriteLine(String.Format("---Register path/type : path <{0}> type <{1}>", rootRelativeVirtualPath.ToLower(),
                 //                              type.FullName));
                 registeredPaths[rootRelativeVirtualPath.ToLower()] = type;
             }
         }
  
         static string GetRootRelativeVirtualPath(string rootVirtualPath, string pageVirtualPath)
         {
             string relativePath = pageVirtualPath;
             if (relativePath.StartsWith("~/", StringComparison.Ordinal))
             {
                 relativePath = relativePath.Substring(2);
             }
             if (!rootVirtualPath.EndsWith("/", StringComparison.OrdinalIgnoreCase))
             {
                 rootVirtualPath = rootVirtualPath + "/";
             }
             relativePath = VirtualPathUtility.Combine(rootVirtualPath, relativePath);
             if (!relativePath.StartsWith("~"))
             {
                 return !relativePath.StartsWith("/") ? "~/" + relativePath : "~" + relativePath;
             }
             return relativePath;
         }
     }
 }

　　下面的代碼很關鍵，用PreApplicationStartMethod關鍵字(.NET 4.0開始支持）使得代碼在Application_Start之前執行。

　　有關[assembly: PreApplicationStartMethod(typeof(SomeClassLib.Initializer), "Initialize")]詳細信息請參考這個頁面和這個頁面。

 using System.Web;
 using System.Web.Compilation;
 using System.Web.Hosting;
 using Common.Framework;
 using Common.PrecompiledViews;
  
 [assembly: PreApplicationStartMethod(typeof(PreApplicationStartCode), "Start")]
  
 namespace Common.Framework
 {
     public static class PreApplicationStartCode
     {
         private static bool _startWasCalled;
  
         public static void Start()
         {
             if (_startWasCalled)
             {
                 return;
             }
             _startWasCalled = true;
  
             //Register virtual paths
             HostingEnvironment.RegisterVirtualPathProvider(new CompiledVirtualPathProvider());
  
             //Load Plugin Folder, 
             PluginLoader.Initialize();
         }
     }
 }

　　代碼：PluginLoader，加載plugin目錄里面的東東（assembly和module配置文件）

 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Reflection;
 using System.Text;
 using System.Threading;
 using System.Web;
 using System.Web.Compilation;
 using System.Web.Hosting;
 using Common.Framework;
 using Common.PrecompiledViews;
  
 //[assembly: PreApplicationStartMethod(typeof(PluginLoader), "Initialize")]
  
 namespace Common.PrecompiledViews
 {
     public class PluginLoader
     {
         public static void Initialize(string folder = "~/Plugin")
         {
             LoadAssemblies(folder);
             LoadConfig(folder);
         }
  
         private static void LoadConfig(string folder, string defaultConfigName="*.config")
         {
             var directory = new DirectoryInfo(HostingEnvironment.MapPath(folder));
             var configFiles = directory.GetFiles(defaultConfigName, SearchOption.AllDirectories).ToList();
             if (configFiles.Count == 0) return;
  
             foreach (var configFile in configFiles.OrderBy(s => s.Name))
             {
                 ModuleConfigContainer.Register(new ModuleConfiguration(configFile.FullName));
             }
         }
  
         private static void LoadAssemblies(string folder)
         {
             var directory = new DirectoryInfo(HostingEnvironment.MapPath(folder));
             var binFiles = directory.GetFiles("*.dll", SearchOption.AllDirectories).ToList();
             if (binFiles.Count == 0) return;
  
             foreach (var plug in binFiles)
             {
                 //running in full trust
                 //************
                 //if (GetCurrentTrustLevel() != AspNetHostingPermissionLevel.Unrestricted)
                 //set in web.config, probing to plugin\temp and copy all to that folder
                 //************************
                 var shadowCopyPlugFolder = new DirectoryInfo(AppDomain.CurrentDomain.DynamicDirectory);
                 var shadowCopiedPlug = new FileInfo(Path.Combine(shadowCopyPlugFolder.FullName, plug.Name));
                 File.Copy(plug.FullName, shadowCopiedPlug.FullName, true); //TODO: Exception handling here...
                 var shadowCopiedAssembly = Assembly.Load(AssemblyName.GetAssemblyName(shadowCopiedPlug.FullName));
  
                 //add the reference to the build manager
                 BuildManager.AddReferencedAssembly(shadowCopiedAssembly);
             }
         }
  
         //private static AspNetHostingPermissionLevel GetCurrentTrustLevel()
         //{
         //    foreach (AspNetHostingPermissionLevel trustLevel in
         //        new AspNetHostingPermissionLevel[]
         //            {
         //                AspNetHostingPermissionLevel.Unrestricted,
         //                AspNetHostingPermissionLevel.High,
         //                AspNetHostingPermissionLevel.Medium,
         //                AspNetHostingPermissionLevel.Low,
         //                AspNetHostingPermissionLevel.Minimal
         //            })
         //    {
         //        try
         //        {
         //            new AspNetHostingPermission(trustLevel).Demand();
         //        }
         //        catch (System.Security.SecurityException)
         //        {
         //            continue;
         //        }
  
         //        return trustLevel;
         //    }
  
         //    return AspNetHostingPermissionLevel.None;
         //}
  
     }
 }

　　此外，使用SingleFileGenerator的優點是性能提升，缺點是修改了視圖就要重新編譯。

如何讓ASP.NET加載BIN目錄之外的路徑的Assembly

　　我們把各個模塊編譯出來的assembly和各個模塊的配置文件自動放到一個bin平級的plugin目錄，然后web應用啟動的時候自動掃描這個plugin目錄並加載各個模塊plugin，這個怎么做到的？大家也許知道，ASP.NET只允許讀取Bin目錄下的assbmely，不可以讀取其他路徑，包括Bin\abc等，即使在web.config這樣配置probing也不行：（不信你可以試一下）

  <configuration> Element
    <runtime> Element
      <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
        <probing privatePath="bin;bin\abc;plugin;"/>
      </assemblyBinding>
     </runtime>
  </configuration>

　　這個和TrustLevel有關，在Full Trust的情況下，可以這樣讀取非Bin目錄下的assembly：

　　首先在和Bib平級的地方建一個目錄Plugin，然后在模塊class library project的屬性里面加一個postBuildEvent，就是說在編譯完成以后把模塊的assbmely自動拷貝到主web項目的plugin目錄：

copy /Y "$(TargetDir)$(ProjectName).dll" "$(SolutionDir)ModularWebApplication\Plugin\"
copy /Y "$(TargetDir)$(ProjectName).config" "$(SolutionDir)ModularWebApplication\Plugin\"

　　然后用下面的代碼加載Plugin目錄下的assembly：（只看LoadAssembly那一段）

        private static void LoadAssemblies(string folder)
         {
             var directory = new DirectoryInfo(HostingEnvironment.MapPath(folder));
             var binFiles = directory.GetFiles("*.dll", SearchOption.AllDirectories).ToList();
             if (binFiles.Count == 0) return;
  
             foreach (var plug in binFiles)
             {
                 //running in full trust
                 //************
                 //if (GetCurrentTrustLevel() != AspNetHostingPermissionLevel.Unrestricted)
                 //set in web.config, probing to plugin\temp and copy all to that folder
                 //************************
                 var shadowCopyPlugFolder = new DirectoryInfo(AppDomain.CurrentDomain.DynamicDirectory);
                 var shadowCopiedPlug = new FileInfo(Path.Combine(shadowCopyPlugFolder.FullName, plug.Name));
                 File.Copy(plug.FullName, shadowCopiedPlug.FullName, true); //TODO: Exception handling here...
                 var shadowCopiedAssembly = Assembly.Load(AssemblyName.GetAssemblyName(shadowCopiedPlug.FullName));
  
                 //add the reference to the build manager
                 BuildManager.AddReferencedAssembly(shadowCopiedAssembly);
             }
         }

 

　　如果不是Full Trust，例如Medium Trust的情況下參考這個帖子《Developing-a-plugin-framework-in-ASPNET-with-medium-trust》。

如何在_layout.cshtml的主菜單注入plugin的菜單

　　在母版頁_layout.cshtml有個主菜單，一般是這樣寫的：

<ul>
  <li>@Html.ActionLink("Home", "Index", "Home")</li>
  <li>@Html.ActionLink("About", "About", "Home")</li>
  <li>@Html.ActionLink("Team", "Index", "Team")</li>
</ul>

 

　　現在我們如何實現從模塊插入plugin到這個主菜單呢？這個有點難。因為大家知道，_layout.cshml母版沒有controller。怎么實現呢？方法是用controller基類，讓所有controller繼承自這個基類。然后在基類里面，讀取plugin目錄里面的配置文件，獲取所有模塊需要插入的主菜單項，然后放入viewBag，這樣在_Layout.cshtml就可以獲取viewBag，類似這樣：

 <ul>
    @foreach (MainMenuItemModel entry in ViewBag.MainMenuItems)
     {
         <li>@Html.ActionLink(entry.Text, 
                entry.ActionName, 
                 entry.ControllerName)</li>
     }
 </ul>

　　代碼：基類Controller，讀取plugin目錄里面的配置文件，獲取所有模塊需要插入的主菜單項，然后放入viewBag

using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Net.Mime;
using System.Text;
using System.Web.Mvc;
 
namespace Common.Framework
{
    public class BaseController : Controller
    {
        protected override void Initialize(System.Web.Routing.RequestContext requestContext)
        {
            base.Initialize(requestContext);
 
            // retireve data from plugins
            IEnumerable<ModuleConfiguration> ret = ModuleConfigContainer.GetConfig();
 
            var data = (from c in ret
                        from menu in c.MainMenuItems
                        select new MainMenuItemModel
                                   {
                                       Id = menu.Id, ActionName = menu.ActionName, ControllerName = menu.ControllerName, Text = menu.Text
                                   }).ToList();
            
            ViewBag.MainMenuItems = data.AsEnumerable();
        }
 
    }
}

　　代碼：ModuleConfigContainer，用到單例模式，只讀取一次

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
  
 namespace Common.Framework
 {
     public static class ModuleConfigContainer
     {
         static ModuleConfigContainer()
         {
             Instance = new ModuleConfigDictionary();
         }
  
         internal static IModuleConfigDictionary Instance { get; set; }
  
         public static void Register(ModuleConfiguration item)
         {
             Instance.Register(item);
         }
  
         public static IEnumerable<ModuleConfiguration> GetConfig()
         {
             return Instance.GetConfigs();
         }
     }
 }

　　代碼：ModuleConfigDictionary

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
  
 namespace Common.Framework
 {
     public class ModuleConfigDictionary : IModuleConfigDictionary
     {
         private readonly Dictionary<string, ModuleConfiguration>  _configurations = new Dictionary<string, ModuleConfiguration>();
  
         public IEnumerable<ModuleConfiguration> GetConfigs()
         {
             return _configurations.Values.AsEnumerable();
         }
  
         public void Register(ModuleConfiguration item)
         {
             if(_configurations.ContainsKey(item.ModuleName))
             {
                 _configurations[item.ModuleName] = item;
             }
             else
             {
                 _configurations.Add(item.ModuleName, item);
             }
         }
     }
 }

　　代碼：ModuleConfiguration，讀取模塊的配置文件

 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Text;
 using System.Xml;
 using System.Xml.Linq;
  
 namespace Common.Framework
 {
     public class ModuleConfiguration
     {
         public ModuleConfiguration(string filePath)
         {
             try
             {
                 var doc = XDocument.Load(filePath);
                 var root = XElement.Parse(doc.ToString());
  
                 if (!root.HasElements) return;
  
                 var module = from e in root.Descendants("module")
                              //where e.Attribute("name").Value == "xxxx"
                              select e;
  
                 if (!module.Any()) return;
  
                 ModuleName = module.FirstOrDefault().Attribute("name").Value;
  
                 var menus = from e in module.FirstOrDefault().Descendants("menu")
                             select e;
  
                 if (!menus.Any()) return;
  
                 var menuitems = menus.Select(xElement => new MainMenuItemModel
                                                              {
                                                                  Id = xElement.Attribute("id").Value,
                                                                  Text = xElement.Attribute("text").Value,
                                                                  ActionName = xElement.Attribute("action").Value,
                                                                  ControllerName = xElement.Attribute("controller").Value
                                                              }).ToList();
  
                 MainMenuItems = menuitems;
             }
             catch
             {
                 //TODO: logging
             }
         }
         public string ModuleName { get; set; }
         public IEnumerable<MainMenuItemModel> MainMenuItems { get; set; }
     }
 }

　　每個模塊的配置文件為{projectName}.config，格式如下：

  <?xml version="1.0" encoding="utf-8" ?>
  <configuration>
    <module name="Module2">
      <mainmenu>
        <menu id="modul2" text="Team" action="Index" controller="Team"/>
      </mainmenu>
    </module>
  </configuration>

　　為了簡單起見，只保留了注入主菜單的部分，為了讓讀者簡單易懂。明白了以后你自己可以任意擴展…

　　代碼：IModuleConfigDictionary，接口

　　

　　模塊配置文件{projectName}.config的位置：

　　

　　為什么每個模塊的Class library project都需要一個web.config呢？因為如果沒有這個，那就沒有Razor智能提示，大家可以參考這篇文章《How to get Razor intellisense for @model in a class library project》。

 

閑話幾句插件式架構（Plugin Architecture）或者模塊化（Modular）架構

　　插件式架構（Plugin Architecture）或者模塊化（Modular）架構是大型應用必須的架構，關於什么是Plugin，什么是模塊化模式，這種架構的優缺點等我就不說了，自己百谷歌度。關於.NET下面的插件式架構和模塊化開發實現方法，基本上用AppDomain實現，當檢測到一個新的插件Plugin時，實例化一個新的AppDomain並加載Assembly反射類等，由於AppDomain很好的隔離各個Plugin，所以跨域通信要用MarshalByRefObject類，具體做法可以參考這篇文章《基於AppDomain的"插件式"開發》。另外，有很多框架提供了模塊化/插件開發的框架，例如Prism、MEF(Managed Extensibility Framework，.NET 4.0 內置)等。

客戶端插件架構

　　還有一種插件架構是客戶端插件架構（Javascript 模塊化），如jQuery UI Widget Factory，Silk Project就是很好的例子。

轉帖說明

　　本文是轉自 Mainz  的文章，原文鏈接：http://www.cnblogs.com/Mainz/archive/2012/03/06/2382653.html

　　這是一篇難得的好文章，但原文作者排版對代碼進行了 max-height:200px 的處理，可能是為了排版美觀吧，但這樣處理之后閱讀代碼老要受滾動條的影響，太不痛快，於是轉帖於此，主要是為自己閱讀的方便。