基于插件架构的简单的Winform框架（下）

前言

最近事情较多，终于有时间来写完这篇。在上一篇的基础上，本篇文章我们开始着手搭建一个简单的基于插件架构的Winform框架。（其实也就是一个小例子，也是对之前写过的代码的总结）

设计思路

写这个Winform小例子的想法来源主要是：

1.希望Winform程序能够根据配置动态生成菜单；

2.运行时按需加载指定模块，必要时还能在运行时更新指定模块；

3.新的功能模块能够即插即用，可扩展；

4.宿主、插件间的基础信息可共享，可交互。

实现

如上文所述，我们想要使用插件结构，那么解决方案的项目结构可如下图所示：

解决方案分为三个project：

wZhang.Host.csproj——宿主。window应用程序，主窗体为MainForm.cs，且为MDI窗体；输出路径：/publish。

wZhang.PlugInCommon.csproj——公共接口。类库；输出路径：/publish。

wZhang.MyPlugIn.csproj——具体插件。类库；输出路径:/publish/MyPlugIn。

说明：我这里为了方便起见，将所有的dll都输出的指定目录publish下了。

具体步骤如下：

步骤一：从配置文件中读取菜单项

首先，定义菜单结构如下：

<?xml version="1.0" encoding="utf-8" ?>
<Main>
  <MenuItem>
    <ID>010000</ID>
    <MenuName><![CDATA[文件(&F)]]></MenuName>
    <MenuItem>
      <ID>010100</ID>
      <MenuName><![CDATA[新建(&N)]]></MenuName>
      <PlugIn></PlugIn>
      <MenuItem>
        <ID>010101</ID>
        <MenuName><![CDATA[项目(&P)]]></MenuName>
        <PlugIn></PlugIn>
      </MenuItem>
      <MenuItem>
        <ID>010102</ID>
        <MenuName><![CDATA[网站(&W)]]></MenuName>
        <PlugIn></PlugIn>
      </MenuItem>
    </MenuItem>
    <MenuItem>
      <ID>010200</ID>
      <MenuName><![CDATA[打开(&O)]]></MenuName>
      <PlugInPath>./MyPlugIn/wZhang.MyPlugIn.dll</PlugInPath>
      <PlugIn>wZhang.MyPlugIn.MyPlugIn,wZhang.MyPlugIn</PlugIn>
    </MenuItem>
  </MenuItem>
  <MenuItem>
    <ID>020000</ID>
    <MenuName><![CDATA[编辑(&E)]]></MenuName>
    <MenuItem>
      <ID>020100</ID>
      <MenuName><![CDATA[复制(&C)]]></MenuName>
      <PlugIn></PlugIn>
    </MenuItem>
  </MenuItem>
</Main>

说明：为了能够正确的反射出具体的插件，

(1)这里使用PlugIn标签配置插件的FullName和AssemblyName;

(2)使用PlugInPath配置插件路径，大部分情况下dll都是按模块存放的；

(3)Winform快捷键使用“&E”结构实现，所以文档中出现了如“<![CDATA[编辑(&E)]]>”节点

(4)这里稍微约定了一下菜单ID的含义:010000,020000,…,0N0000：标识一级菜单，0N0100,0N0200,…0N0N00：标识二级菜单，0N0N01,0N0N02,…,0N0N0N：标识三级菜单。（如果还有更多级菜单可以继续扩展）。

其次，在PlugInCommon项目中添加类MenuItem和AppMenu两个类，用于反序列化菜单项：

/// <summary>
    /// 主菜单
    /// </summary>
    [XmlRoot("Main", IsNullable = false)]
    public class AppMenu
    {
        [XmlElement("MenuItem",IsNullable=false)]
        public List<MenuItem> MenuItems { get; set; }
    }

    /// <summary>
    /// 菜单项
    /// </summary>
    public class MenuItem
    {
        /// <summary>
        /// 菜单名称
        /// </summary>
        [XmlElement("MenuName", IsNullable = false)]
        public string MenuName { get; set; }

        /// <summary>
        /// 菜单ID
        /// </summary>
        [XmlElement("ID",IsNullable = false)]
        public string MenuId { get; set; }

        /// <summary>
        /// 插件
        /// </summary>
        [XmlElement("PlugIn")]
        public string PlugIn { get; set; }

        /// <summary>
        /// 插件所在路径
        /// </summary>
        [XmlElement("PlugInPath")]
        public string PlugInPath { get; set; }

        /// <summary>
        /// 子菜单
        /// </summary>
        [XmlElement("MenuItem")]
        public List<MenuItem> SubMenus { get; set; }
    }

最后，反序列化菜单项。读出配置文件资源后，使用XmlSerializer类反序列化菜单项：

        /// <summary>
        /// 获取菜单对象
        /// </summary>
        /// <returns></returns>
        private AppMenu GetAppMenu()
        {
            var currentAssembly = Assembly.GetExecutingAssembly();
            string menuPath = currentAssembly.GetName().Name + ".Menu.xml";
            using (Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(menuPath))
            {
                XmlSerializer serializer = new XmlSerializer(typeof(AppMenu));
                AppMenu appMenu = serializer.Deserialize(stream) as AppMenu;
                return appMenu;
            }
        }

代码说明：获取菜单时候由于上面我们将菜单文件的属性设置成了嵌入的资源（这样输出目录中看不到具体的菜单配置信息），所以菜单路径(menuPath）读取方式跟普通文件的读取有些许区别。

这样我们就得到了一个菜单对象。等需要的时候我们就可以按需添加到页面上.

步骤二 ： 定义接口

首先，我们创建一个窗体基类：BaseForm.cs，基类的好处，不多说了。

其次，上篇文章我们已经知道如何加载插件了，为了实现插件能够获取宿主信息，这里再增加一个上下文的接口IAppContext，用于插件获取宿主信息：

    /// <summary>
    /// 上下文
    /// </summary>
    public interface IAppContext
    {
        UserInfo User { get; set; }

        //还可以定义很多需要的属性
    }

上篇文章中的插件接口稍微修改一下：

    /// <summary>
    /// 插件接口
    /// </summary>
    public interface IPlugIn
    {
        /// <summary>
        /// 应用程序上下文
        /// </summary>
        IAppContext AppContext
        {
            get;
            set;
        }

        /// <summary>
        /// 创建子窗体
        /// </summary>
        /// <returns></returns>
        BaseForm CreatePlugInForm();
    }

通过属性AppContext插件可以获取到宿主相关信息；另外，由于我们这里做的是一个winform程序，所以提供CreatePlugInForm方法来创建具体的窗体。

需要指出的是,这里并没有直接将窗体作为插件，因为:

(1)窗体对象实在太大；

(2)限定为窗体后程序不方便移植到别的地方，如：WPF上。

定义好接口后，需要将宿主实现IAppContext,宿主想要给插件哪些信息，只需要给IAppContext中定义的属性赋值即可。

步骤三：创建菜单控件

创建菜单控件之前，先介绍本示例是如何实现插件的动态加载的：

我们将从配置文件中读取出的每一个菜单（即：每一个MenuItem对象），都绑定到每一个ToolStripMenuItem对象的Tag属性上。这样当我们点击某一个菜单时，便可去除Tag属性中的MenuItem对象，从而加载MenuItem中指定的插件。

到这里为止，我们知道宿主程序是一个Windows应用程序，有一个主窗体Mainform，实现了IAppContext接口，且已经从菜单项配置文件中获得了指定的菜单对象，那么这时我们应该创建一个菜单控件了，代码如下：

        /// <summary>
        /// 创建菜单控件
        /// </summary>
        /// <param name="appMenu">配置文件中读取的菜单对象</param>
        private void CreateMenuStrip(AppMenu appMenu)
        {
            foreach (var item in appMenu.MenuItems)
            {
                ToolStripMenuItem rootMenu = new ToolStripMenuItem();
                rootMenu.Name = item.MenuId;
                rootMenu.Text = item.MenuName;
                rootMenu.Tag = item;
                if (item.SubMenus != null && item.SubMenus.Count > 0)
                {
                    var subItem = CreateDropDownMenu(rootMenu, item.SubMenus);
                }
                MainMenu.Items.Add(rootMenu);
            }
            MainMenu.Refresh();
        }

        /// <summary>
        /// 创建下拉菜单
        /// </summary>
        /// <param name="rootMenu">根菜单</param>
        /// <param name="menuItems">需要加载的菜单项（配置文件中的）</param>
        /// <returns>一组完整的菜单</returns>
        private ToolStripMenuItem CreateDropDownMenu(ToolStripMenuItem rootMenu, List<MenuItem> menuItems)
        {
            foreach (var item in menuItems)
            {
                ToolStripMenuItem subItem = new ToolStripMenuItem();
                subItem.Name = item.MenuId;
                subItem.Text = item.MenuName;
                if (item.SubMenus != null && item.SubMenus.Count > 0)
                {
                    var dropdowmItem = CreateDropDownMenu(subItem, item.SubMenus);
                    rootMenu.DropDownItems.Add(subItem);
                }
                else
                {
                    subItem.Tag = item;
                    subItem.Click += subItem_Click;
                    rootMenu.DropDownItems.Add(subItem);
                }
            }
            return rootMenu;
        }

可能注意到有这样一句代码：subItem.Click += subItem_Click，这里既是为每一个叶子菜单绑定一个菜单点击事件，该事件里做的事情就是加载指定的插件，也就是步骤四将要描述的。

步骤四：动态加载插件

我们这里加载插件的方式和上篇文章中介绍的有点区别：这里是一次只加载一个插件。代码稍微修改后如下：

        /// <summary>
        /// 加载插件
        /// </summary>
        /// <param name="dllPath">插件所在路径</param>
        /// <param name="fullName">插件全名：namespace+className</param>
        /// <returns>具体插件</returns>
        public IPlugIn LoadPlugIn(string dllPath,string fullName)
        {
            Assembly pluginAssembly = null;
            string path = System.IO.Directory.GetCurrentDirectory() + dllPath;
            try
            {
                //加载程序集
                pluginAssembly = Assembly.LoadFile(path);
            }
            catch (Exception ex)
            {
                return null;
            }
            Type[] types = pluginAssembly.GetTypes();
            foreach (Type type in types)
            {
                if (type.FullName == fullName && type.GetInterface("IPlugIn") != null)
                {//仅是需要加载的对象才创建插件的实例
                    IPlugIn plugIn = (IPlugIn)Activator.CreateInstance(type);
                    plugIn.AppContext = this;
                    return plugIn;
                }
            }
            return null;
        }

代码说明：代码plugIn.AppContext = this;便是将宿主对象共享给插件使用。

点击菜单触发加载插件的点击事件实现如下：

        /// <summary>
        /// 点击菜单触发事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void subItem_Click(object sender, EventArgs e)
        {
            ToolStripMenuItem tooStripMenu = sender as ToolStripMenuItem;
            if (tooStripMenu == null)
            {
                return;
            }
            MenuItem menuItem = tooStripMenu.Tag as MenuItem;
            if (menuItem == null)
                return;
            //获取插件对象
            IPlugIn plugIn = LoadPlugIn(menuItem.PlugInPath, menuItem.PlugIn.Split(',')[0]);

            //创建子窗体并显示
            BaseForm plugInForm = plugIn.CreatePlugInForm();
            plugInForm.MdiParent = this;
            plugInForm.Show();
        }

上述几个步骤完成后，宿主程序就基本完成了，现在还需要一个插件。

步骤五：实现一个插件

插件项目wZhang.MyPlugIn我们已经建立，这是我们在项目中分别添加类MyPlugIn.cs和窗体MyPlugInForm.cs,其中MyPlugIn实现接口IPlugIn，窗口继承自BaseForm.我们在MyPlugIn的CreatePlugInForm方法中创建一个MyPlugInForm的实例，便完成了一个最基本的插件（当然实际业务中插件窗体中还有很多事情要处理）。代码如下（示例代码中奖应用程序上下文通过构造函数传给了插件窗体）：

    /// <summary>
    /// 插件
    /// </summary>
    public class MyPlugIn:IPlugIn
    {
        private IAppContext _app;

        public IAppContext AppContext
        {
            get { return _app; }
            set { _app = value; }
        }

        public BaseForm CreatePlugInForm()
        {
            return new MyPlugInForm(AppContext);
        }
    }

经过以上五个步骤，我们便完成了一个利用插件方式实现的Winform动态加载模块的小示例。最终的代码结构如下：

运行示例程序，点击某项菜单后的显示效果为：

示例代码：PlguIn.7z