基于ASP.NET MVC3 Razor的模块化/插件式架构实现

我们把各个模块编译出来的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那一段）

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;
        //}

    }
}

如果不是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就是很好的例子。

本文源码下载

源码下载请点击此处。运行源码之前务必阅读此文和本文。注意：本文抛砖引玉，力求简单，易懂，并非完整的架构实现，更多丰富的功能实现一切皆有可能，只要在理解的基础上。

 

分类: C#

标签: 架构, ASP.NET