MEF学习笔记

之前公司里用到了一个叫MEF的东西，说来惭愧一直只管写代码却不曾理解MEF框架为何物，今天就来学习一下，这是一篇迟到了不知多久的博客。

--------------------------------------------------------进入正题-------------------------------------------------------------------

1.MEF概念

MEF,全称Managed Extensibility Framework（托管可扩展框架）。单从名字我们不难发现：MEF是专门致力于解决扩展性问题的框架，MSDN中对MEF有这样一段说明：

　　Managed Extensibility Framework 或 MEF 是一个用于创建可扩展的轻型应用程序的库。 应用程序开发人员可利用该库发现并使用扩展，而无需进行配置。 扩展开发人员还可以利用该库轻松地封装代码，避免生成脆弱的硬依赖项。 通过 MEF，不仅可以在应用程序内重用扩展，还可以在应用程序之间重用扩展。

2.MEF使用

　　MEF的使用范围广泛，在Winform、WPF、Win32、Silverlight中都可以使用，我们就从控制台说起，看看控制台下如何实现MEF，下面先新建一个win32控制台项目MEF_1的Demo，添加一个IBookService接口一个继承这个接口的类MusicBook ，如图:

首先需要手动添加对System.ComponentModel.Composition命名空间的引用，由于在控制台程序中没有引用这个DLL，所以要手动添加：

我们再回到program类中写如下代码：

class Program
    {
        [Import]
        public IBookService Service { get; set; }
 
        static void Main(string[] args)
        {
            Program pro = new Program();
            pro.Compose();
            if (pro.Service != null)
            {
                Console.WriteLine(pro.Service.GetBookName());
            }
            Console.Read();
        }

       //宿主MEF并组合部件

         private void Compose() { 
       //获取包含当前执行的代码的程序集 
             var catalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
            CompositionContainer container = new CompositionContainer(catalog);

      //将部件（part）和宿主程序添加到组合容器

      container.ComposeParts(this); } 
}

　　这个方法表示添加当前Program这个类到组合容器，为什么要添加到组合容器？是因为只要添加到组合容器中之后，如果该类里面有Import，MEF才会自动去寻找对应的Export。这也就是为什么使用MEF前必须要组合部件的原因。

代码运行情况：

可以看到调用了MusicBook类的GetBookName方法，但是我们并没有实例化MusicBook类，是不是很神奇呢？？？

这一就是实现了主程序和类之间的解耦，大大提高了代码的扩展性和易维护性！

看到这里可能有人就会说这个Import是多此一举了，既然我们可以new，为什么非要用这种奇怪的语法呢，怪别扭的。其实如果我们站在架构的层面，它的好处就是可以减少dll之间的引用。

------------------------------------------------MEF中的Import(导入)和Export(导出)-------------------------------------

上面的测试小Demo我们对MEF有了一个初步的了解，下面我们来细看一下MEF中的Import(导入)和Export(导出)。

 class Program
    {
        [Import("MusicBook")]
        public IBookService Service { get; set; }
 
        static void Main(string[] args)
        {
            Program pro = new Program();
            pro.Compose();
            if (pro.Service != null)
            {
                Console.WriteLine(pro.Service.GetBookName());
            }
            Console.Read();
        }
        //宿主MEF并组合部件
        private void Compose()
        {
            //获取包含当前执行的代码的程序集
            var catalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
            CompositionContainer container = new CompositionContainer(catalog);
            //将部件（part）和宿主程序添加到组合容器
            container.ComposeParts(this);
        }
    }
}

 ////Export(typeof(IBookService)) 这句话将类声明导出为IBookService接口类型
    //[Export(typeof(IBookService))]
    [Export("MusicBook",typeof(IBookService))]
    class MusicBook:IBookService
    {
 
        public string BookName { get; set; }
 
        public string GetBookName()
        {
            return "音乐书本";
        }
    }

注意，标红的是改动过的地方，其他地方的代码没有变，上一次我们使用的是Export的方法是[Export(typeof(IBookService))],这次前面多了一个参数，没错，这个就是一个契约名，名字可以随便起，而且可以重复，但是如果名字乱起，和其他DLL中的重复，到时候会导致程序出现很多Bug，最好按照一定的规范去起名字。

这里有了契约名以后，导入(Import)时就要指定的契约名，否则将无法找到MusicBook，Export还有一个方法是[Export("Name")],这个方法只指定了契约名，没有指定导出类型，那么默认的导出类型是object类型，在导入时导出到的对象就要为object类型，否则将匹配不到那个组件。

　　到现在，我们只写了一个接口和一个实现类，导出的也是一个类，下面我们多添加几个类来看看会怎么样，为了方便大家测试，我把实现接口的类写在一个文件里面，新加几个类后，的MusicBook类文件代码如下：

[Export("MusicBook",typeof(IBookService))]
    public class MusicBook:IBookService
    {
 
        public string BookName { get; set; }
 
        public string GetBookName()
        {
            return "音乐书本";
        }
    }
    [Export("MusicBook", typeof(IBookService))]
    public class MathBook : IBookService
    {
 
        public string BookName { get; set; }
 
        public string GetBookName()
        {
            return "数学课本";
        }
    }
    [Export("MusicBook", typeof(IBookService))]
    public class HistoryBook:IBookService
    {
 
        public string BookName { get; set; }
 
        public string GetBookName()
        {
            return "历史课本";
        }
    }

这里添加两个类，HistoryBook和MathBook，都继承自IBookService接口，注意他们的契约名都相同，都为MusicBook，后面再详细的说这个问题，修改后的program的代码如下：

class Program
    {
        [ImportMany("MusicBook")]
        public IEnumerable<IBookService> Services { get; set; }
 
        static void Main(string[] args)
        {
            Program pro = new Program();
            pro.Compose();
            if (pro.Services != null)
            {
                foreach (var service in pro.Services)
                {
                    Console.WriteLine(service.GetBookName());
                }
            }
            Console.Read();
        }
        //宿主MEF并组合部件
        private void Compose()
        {
            //获取包含当前执行的代码的程序集
            var catalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
            CompositionContainer container = new CompositionContainer(catalog);
            //将部件（part）和宿主程序添加到组合容器
            container.ComposeParts(this);
        }
    }

这里需要注意的是标红的两行代码，[ImportMany("MusicBook")]还有下面的声明变成了IEnumerable<>,因为要导出多个实例，所以要用到集合，下面采用foreach遍历输出，运行的结果如下图：

现在三个类的契约名都不相同了，其他的代码不动，再次运行程序看看，是不是现在只输出MusicBook了，同理，修改[Import("Name")]中的契约名称，就会导入指定含有名称的类，契约名可以重复，这一以来，我们就可以用契约名给类进行分类，导入时可以根据契约名来导入。

注意：IEnumerable<T>中的类型必须和类的导出类型匹配，如类上面标注的是[Exprot(typeof(object))]，那么就必须声明为IEnumerable<object>才能匹配到导出的类。

例如：我们在类上面标注[Export("Book")],我们仅仅指定了契约名，而没有指定类型，那么默认为object，此时还用IEnumerable<IBookService>就匹配不到。

那么，这种情况就要在输出是进行强制类型转换，代码如下：

 [Export("MusicBook")]
    public class MusicBook:IBookService
    {
 
        public string BookName { get; set; }
 
        public string GetBookName()
        {
            return "音乐书本";
        }
    }

如果我们这样写了那样结果就只能匹配到后两个：

此时我们需要强制转换一下输出的类型：

[ImportMany("MusicBook")]
        public IEnumerable<object> Services { get; set; }
 
        static void Main(string[] args)
        {
            Program pro = new Program();
            pro.Compose();
            if (pro.Services != null)
            {
                foreach (var service in pro.Services)
                {
                    var ss = (IBookService)service;
                    Console.WriteLine(ss.GetBookName());
                }
            }
            Console.Read();
        }

结果就匹配到了所有类的输出：

------------------------------------------------MEF中方法和属性能不能导出呢？---------------------------------------------

前面说完了导入和导出的几种方法，如果大家细心的话会注意到前面我们导出的都是类，那么方法和属性能不能导出呢？？？答案是肯定的，下面就来说下MEF是如何导出方法和属性的：

首先是导出属性：

 [Export("MusicBook", typeof(IBookService))]
    public class MathBook : IBookService
    {
        //导出私有的属性
        [Export(typeof(string))]
        private string _privateBookName = "私有的属性BookName";
        //导出公用的属性
        [Export(typeof(string))]
        public string _publicBookName = "公有的属性BookName";
 
        public string BookName { get; set; }
 
        public string GetBookName()
        {
            return "数学课本";
        }
    }

 class Program
    {
        [ImportMany("MusicBook")]
        public IEnumerable<object> Services { get; set; }
 
        //导入属性(这里不区分public还是private)
        [ImportMany]
        public List<string> InputString { get; set; } 
 
        static void Main(string[] args)
        {
            Program pro = new Program();
            pro.Compose();
            if (pro.Services != null)
            {
                foreach (var service in pro.Services)
                {
                    var ss = (IBookService)service;
                    Console.WriteLine(ss.GetBookName());
                }
                foreach (var str in pro.InputString)
                {
                    Console.WriteLine(str);
                }
            }
            Console.Read();
        }
        //宿主MEF并组合部件
        private void Compose()
        {
            //获取包含当前执行的代码的程序集
            var catalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
            CompositionContainer container = new CompositionContainer(catalog);
            //将部件（part）和宿主程序添加到组合容器
            container.ComposeParts(this);
        }
    }

最后的输出结果为：

下面说导出方法吧，同理无论是公有方法还是私有方法都是可以导出的，MusicBook代码如下：

        //导出公用方法(无参数)
        [Export(typeof (Func<string>))]
        public string PublicGetBookName()
        {
            return "PublicMathBook";
        }
        //导出私有方法(有参数)
        [Export(typeof (Func<int,string>))]
        public string PrivateGetBookName(int count)
        {
            return string.Format("我看到一个好书,我买了{0}本", count);
        }

class Program
    {
        [ImportMany("MusicBook")]
        public IEnumerable<object> Services { get; set; }
 
        //导入属性(这里不区分public还是private)
        [ImportMany]
        public List<string> InputString { get; set; }
 
        //导入无参数方法
        [Import]
        public Func<string> methodWithoutPara { get; set; }
        //导入有参数的方法
        [Import]
        public Func<int, string> methodWithPara { get; set; }
 
        static void Main(string[] args)
        {
            Program pro = new Program();
            pro.Compose();
            if (pro.Services != null)
            {
                foreach (var service in pro.Services)
                {
                    var ss = (IBookService)service;
                    Console.WriteLine(ss.GetBookName());
                }
                foreach (var str in pro.InputString)
                {
                    Console.WriteLine(str);
                }
            }
            //调用无参数的方法
            if (pro.methodWithPara != null)
            {
                Console.WriteLine(pro.methodWithoutPara());
            }
 
            //调用有参数的方法
            if (pro.methodWithoutPara!=null)
            {
                Console.WriteLine(pro.methodWithPara(5));
            }
            Console.Read();
        }
        //宿主MEF并组合部件
        private void Compose()
        {
            //获取包含当前执行的代码的程序集
            var catalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
            CompositionContainer container = new CompositionContainer(catalog);
            //将部件（part）和宿主程序添加到组合容器
            container.ComposeParts(this);
        }
    }

导入导出方法用到了Func<T>委托，当然没有返回值的话可以用Action<T>委托。

------------------------------------------------MEF在分层架构中的使用---------------------------------------------

前面讲了MEF的基础和基本到导入导出方法，下面就是见证MEF真正魅力所在的时刻。如果没有看过前面的文章，请到我的博客首页查看。

　　前面我们都是在一个项目中写了一个类来测试的，但实际开发中，我们往往要采用分层架构，就拿最简单的三层架构来说吧，我们通常把业务逻辑写在DLL中，现在就来写一个例子，看看如何在不编译整个项目的情况下，轻松的实现扩展。先透露一下，我们只要添加一个DLL就可以了。

　　这里就以银行为例子吧，首先新建一个控制台项目，叫MEF_2吧，然后建一个类库写接口，然后再建一个类库实现接口。项目结构如下：

其中MEF_2和BankOfChina都只引用接口项目,MEF_2不需要引用BankOfChina。

BankInterface的代码如下，做个简单实例，写几个方法测试一下：

public interface ICard
    {
       //账户金额
        double Money { get; set; }
        //获取账户信息
        string GetCountInfo();
        //存钱
        void SaveMoney(double money);
        //取钱
        void CheckOutMoney(double money);
    }

这里添加一个中国银行卡，实现接口，引用命名空间什么的不再重复说了，不懂看前面的文章，代码如下：

namespace BankOfChina
{
    [Export(typeof(ICard))]
    public class ZHCard : ICard
    {
        public string GetCountInfo()
        {
            return "中国银行";
        }
        public double Money { get; set; }
 
        public void SaveMoney(double money)
        {
            this.Money += money;
        }
 
        public void CheckOutMoney(double money)
        {
            this.Money -= money;
        }
 
    }
}

主程序中的代码：

namespace MEF_2
{
    class Program
    {
        [ImportMany(typeof(ICard))]
        public IEnumerable<ICard> cards { get; set; } 
 
        static void Main(string[] args)
        {
            Program pro = new Program();
            pro.Compose();
            foreach (var c in pro.cards)
            {
                Console.WriteLine(c.GetCountInfo());
            }
            Console.Read();
        }
 
        private void Compose()
        {
            var catalog = new DirectoryCatalog("MyCards");
            var container = new CompositionContainer(catalog);
            container.ComposeParts(this);
        }
    }
}

现在，我们知道只有一种银行卡，及中国银行的，注意我标红的代码，这里是一个目录，及主程序所在目录的Cards(bin-debug-Cards)文件夹(我们需要提前建立好)，我们把生成的BankOfChian.dll拷贝到这个文件夹下，然后运行才可以正确输出信息(毕竟我们没有引用那个项目)，如图：

此时我们看到输出结果为"中国银行"。

到了这里相信大家已经明白了，如果现在需求改变了，需要支持建行、农行等银行卡，怎么办呢？通常我们要改项目，把整个项目都编译再重新发布。但是现在不需要这么做了，我们只需要添加一个类库项目，把生成的dll拷贝到Cards目录下即可。

我们在这个解决方案下继续添加一个类库项目，实现ICard接口，代码如下：

namespace NongHang
{
    [Export(typeof(ICard))]
    public class NHCard:ICard
    {
        public double Money { get; set; }
 
        public string GetCountInfo()
        {
            return "中国农业银行";
        }
 
        public void SaveMoney(double money)
        {
            this.Money += money;
        }
 
        public void CheckOutMoney(double money)
        {
            this.Money -= money;
        }
    }
}

点击右键编译，把生成的dll拷贝到Cards目录下面，运行看到如下结果：

再看看Cards目录中，现在你添加几个dll,就会显示多少条信息了。

------------------------------------------------MEF的高级用法 MEF中如何访问某个具体的对象-----------------------------------

前面我们讲过在导出的时候，可以在[Export()]注解中加入名称标识，从而识别某个具体的对象，然而这种方法只是用于页面初始化的时候就行过滤，页面打开后没有导入的就再也导入不了了，就是说我们不能在导入的集合中分辨各自的不同，所有导入的类都是没有标识的。

待续...