插件編程小窺

　　　　我們在前面的文章中提到了兩中實現晚綁定的方式，那么在用的時候是否發現有什么不同呢？

　　　　是的，我們會很容易的發現Activator.CreateInstance（）創建的對象，我們只能訪問他的訪問級別為public的方法，但是我們僅僅小小的統一下手腳，使用BindingFlags.NonPublic|BindingFlags.Instance就可以獲得該對象的internal,private級別的變量。但是往往后一種方式我們也是不經常采取的，因為我們需要穩定的成員支持，而私有類型的成員往往是程序中最容易更新的，假如一個程序集更新后，我們使用這種方式調用即會發生錯誤。

　　　　今天剛剛過完五一長假回學校（自己給自己放了十天假，哈哈），今天就和同學們一起學習一下插件編程，既然上面我提到了基本安全（穩定）的方式，就一定會用到Activator.CreateInstance，今天我在博客里一共做兩個試驗，一個是Winfrom的插件體系的構建，一個是控制台的插件體系的構建，當然都是很簡單的那種。

1.Winfrom小實驗（實驗要求：）

1. 動態的加載菜單項
2. 動態的綁定菜單單擊事件

現在我們來整理一下思路:動態的加載當然需要使用反射,前面的文章我們提到了先要加載程序集,然后獲得程序集的相關類型的對象,通過對象來訪問相應的方法,現在我們可以確定應該是主程序(我在這里稱之為宿主程序)下載插件程序集，但是問題來了，即便是加載了我們又怎么去約束我們要實用的插件方法呢。難道所有的插件方法都需要嗎？當然不是，這時候我們就用到了插件接口來約束，也就是為插件程序來制定調用規則。

現在我們已經有了個大概思路，改程序該分為三部分：宿主程序，約定接口，插件程序。

為了我們在今后可以編譯管理我們將一些有關管理插件的程序集都已XML的方式進行管理，這樣將不會遺漏和便於修改。

<Assemblypaths> 
    <oper type="toUpper" path="G:\C#\測試程序集\toUpper.dll"/>
    <oper type="toLower" path="G:\C#\測試程序集\toLower.dll"/>
</Assemblypaths> 

在這個Xml文件里保存着插件實現接口成員的功能以及插件的保存路徑。
到了這里我們肯定要定義一個約定接口程序集了，具體實現如下：

namespace EditPlus 2 { 3     public interface IEditPlus 4  { 5         string Name { get;} 6         string OperEdit(string str); 7  } 8 }

接下來的任務就很簡單了，插件是用來干什么的，他就是來實現這個約定接口的，現在我們暫時安裝上面xml文件的需求定義2個擴展插件，具體實現如下：
1.toUpper功能：

using EditPlus;

namespace letterUpper
{
    public class letterUpper :IEditPlus
    {
        public string Name
        {
            get
            {
                return "全部大寫";
            }
        }

        public string OperEdit(string str)
        {
            return str.ToUpper();
        }
    }
}

2.toLower功能：

using EditPlus;

namespace toLower
{
    public class letterLower:IEditPlus
    {
        public string Name
        {
            get { return "全部小寫"; }
        }

        public string OperEdit(string str)
        {
            return str.ToLower();
        }
    }
}

 現在我們就來宿主程序中加載插件程序集，動態添加菜單項並綁定相應的方法。

using System;
using System.Windows.Forms;
using System.Reflection;
using EditPlus;
using System.Xml.Linq;
using System.Collections;

namespace 插件宿主程序
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            //讀取xml文件，獲取要加載的菜單名稱和程序集路徑
            XDocument doc = XDocument.Load(@"G:\C#\測試程序集\path.xml", LoadOptions.None);
            IEnumerable Opers = doc.Root.Elements("oper");
            foreach (XElement oper in Opers)
            {
                //加載程序集
                Assembly a = Assembly.LoadFrom(oper.LastAttribute.Value);
                Type[] types=a.GetTypes();
                foreach(Type type in types)
                {
                    if (!type.IsAbstract && !type.IsNotPublic && typeof(IEditPlus).IsAssignableFrom(type))
                    {
                        IEditPlus idplus = (IEditPlus)Activator.CreateInstance(type);
                        ToolStripMenuItem subItem = new ToolStripMenuItem(idplus.Name);
                        菜單ToolStripMenuItem.DropDownItems.Add(subItem);
                        subItem.Tag = idplus;
                        //綁定事件
                        subItem.Click += new EventHandler(subItem_Click);
                    }
                }
            }
        }

        void subItem_Click(object sender, EventArgs e)
        {
            ToolStripMenuItem subItem = (ToolStripMenuItem)sender;
            IEditPlus idplus = (IEditPlus)subItem.Tag;
            richTextBox1.Text=idplus.OperEdit(richTextBox1.Text);
        }
  }
      
}

運行效果：

---

 　　通過上面的例子我們已經知道插件是怎么回事了，現在我們就來正規的定義一下插件。

插件（plugin）：是指遵循一定的接口規范，可以動態的加載和運行的程序模塊。從上面的例子可以看出，利用反射動態加載程序集的能力，可以加載和實現插件的功能，實現插件的功能的所有類必須實現定義插件的接口。

下面我們在控制台實現一個小插件的開發。

基本思路和上面的差不多，只是上面的程序我們使用了同一個接口來規范，現在我們對於插件和宿主程序使用不同的接口來分別規范一下，看看有什么改進。

代碼簡單，就不在說什么實現要求，一看便明白了。

1.首先定義一個插件接口

namespace PluginInterface
{
    public interface IPlugin
    {
        //插件名稱
        string Name { get;}
        //插件的方法
        object Todo(object parameter);
    }
}

2.定義一個宿主接口

using System.Collections.Generic;
using PluginInterface;

namespace HostInterface
{
    public interface IHost
    {
        //獲得已加載的插件集合
        List<IPlugin> Plugins {get ;}
        //裝載所有實現了IPlugin接口的插件,path為存放目錄
        int LoadPlugin(string path);//返回加載插件的數量、
        //獲取指定的插件
        IPlugin getPlugin(string Plugin_name);
    }
}

3.編寫插件

using System;
using PluginInterface;

namespace Plugin1
{
    public class Plugin1 : IPlugin
    {
        private string name;
        public string Name
        {
            get { return name; }
        }
        public Plugin1()
        {
            name = "Plugin1";
        }
        public object Todo(object parameter)
        {
            Console.WriteLine(name+" todo: "+parameter.ToString());
            return parameter;
        }
    }
}

using System;
using PluginInterface;

namespace Plugin2
{
    public class Plugin2 : IPlugin
    {
        private string name;
        public string Name
        {
            get { return name; }
        }
        public Plugin2()
        {
            name = "Plugin2";
        }
        public object Todo(object parameter)
        {
            Console.WriteLine(name + " todo: " + parameter.ToString());
            return parameter;
        }
    }
}

4.主程序模塊

using System;
using System.Collections.Generic;
using HostInterface;
using PluginInterface;
using System.IO;
using System.Reflection;

namespace 插件編程測試
{
    class Host:IHost
    {
        //用來存放已加載的插件集合
        private List<IPlugin> plugins = new List<IPlugin>();
        static void Main(string[] args)
        {
            //創建Host對象
            Host host = new Host();
           //加載插件
            host.LoadPlugin(@"G:\C#\測試程序集");
            //顯示所有已加載的插件
            Console.WriteLine("所有已加載的插件:");
            int i = 1;
            foreach (IPlugin ip in host.plugins)
            {
                Console.WriteLine("{0}--{1}",i++,ip.Name);
            }
            //選擇指定的插件
            int index = InputNumber("請選擇一個插件並確認");
            //執行插件的功能
            IPlugin plugin = host.getPlugin(host.plugins[index-1].Name);
            plugin.Todo("完成測試！");
            Console.ReadKey();
        }
        private static int InputNumber(string prompt)
        {
            Console.Write(prompt);
            string s = Console.ReadLine();
            int count = 0;
            try
            {
                count = Int32.Parse(s);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            return count;
        }
        public List<PluginInterface.IPlugin> Plugins
        {
            get { return plugins;}
            
        }

        public int LoadPlugin(string path)
        {
           string[] dll_Files=Directory.GetFiles(path, "*.dll");
            //判斷每個程序集是否實現了插件接口
           foreach (string file in dll_Files)
           {
               Assembly a = Assembly.LoadFrom(file);
               //檢查程序的公開接口是否是類，是否實現了IPlugin接口
               foreach (Type t in a.GetExportedTypes())
               {
                   if (t.IsClass && typeof(IPlugin).IsAssignableFrom(t))
                   { 
                        //如果是則創建實現了Iplugin接口的對象
                       IPlugin plugin=Activator.CreateInstance(t) as IPlugin;
                       //添加到集合中
                       Plugins.Add(plugin);
                   }
               }
           }
           return plugins.Count;//返回合格插件的數目
        }

        /// <summary>
        /// 返回指定的插件
        /// </summary>
        /// <param name="Plugin_name">插件名</param>
        /// <returns>插件</returns>
        public IPlugin getPlugin(string Plugin_name)
        {
            foreach (IPlugin ip in plugins)
            {
                if (ip.Name == Plugin_name)
                {
                    return ip;
                }
            }
            return null;
        }
    }
}

效果圖：

　　從上面兩個程序我們可以分析出來，是否能開發插件、如何開發插件是由寫主程序的人來決定的