基於插件架構的簡單的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