1. 云栖社区>
  2. >
  3. 正文

基于MEF打造的插件系统的实现详解_毕业论文

作者:用户 来源:互联网 时间:2016-05-13 13:05:25

MEF插件系统

基于MEF打造的插件系统的实现详解_毕业论文 - 摘要: 本文讲的是基于MEF打造的插件系统的实现详解_毕业论文, 以实例说话,一起体验MEF带来的可扩展性吧,Let's Rock!!! 1:新建控制台程序SimpleCalculator 在这里要实现的程序时SimpleCalculator,顾名思义:简单的计算器。 所以我们需要定义一个用来计算的接

以实例说话,一起体验MEF带来的可扩展性吧,Let's Rock!!!

1:新建控制台程序SimpleCalculator

基于MEF打造的插件系统的实现详解_毕业论文-mef 插件

在这里要实现的程序时SimpleCalculator,顾名思义:简单的计算器。

所以我们需要定义一个用来计算的接口:

public interface ICalculator

{

    String Calculate(String input);

}

Program 的代码如下:

class Program
{
    private CompositionContainer _container;

    [Import(typeof(ICalculator))]
    private ICalculator calculator;

    public Program()
    {
        //var catalog = new AggregateCatalog();
        //catalog.Catalogs.Add(new AssemblyCatalog(typeof(Program).Assembly));

        var catalog = new AssemblyCatalog(typeof(Program).Assembly);
        _container = new CompositionContainer(catalog);

        try
        {
            this._container.ComposeParts(this);
        }
        catch (CompositionException compositionException)
        {
            Console.WriteLine(compositionException.ToString());
        }
    }

    static void Main(string[] args)
    {
        Program p = new Program();
        string s;
        Console.WriteLine("Enter Command:");

        while (true)
        {
            s = Console.ReadLine();
            Console.WriteLine(p.calculator.Calculate(s));
        }
    }
}

MEF所要解决的是寻找插件的功能,传统的实现插件的方式主要是使用接口,即声明一个接口,然后使用配置文件来配置接口使用哪个实现类。

微软知道有这种需求,于是提供了MEF来实现插件的功能。

Composite 原理

1:声明一个 CompositionContainer 对象,这个对象里面包含一堆Catalog.

2:这堆Catalog如果是AssemblyCatalog,则在Assembly中查找,如果是DirectoryCatalog,

在Directory 中查找,如果即想要在Assembly中查找,又需要在Directory中查找,

则采用AggregateCatalog。

3:然后在这堆Catalog中查找与Import 特性相对应的Export标记所标记的实现类,调用实现类的构造函数进行

Composite(组合)。

知道原理后,你也可以自己实现自己的CompositionContainer 类了,

要使用MEF 需要为SimpleCalculator添加 System.ComponentModel.Composition.dll 的引用,

然后导入命名空间:

using System.ComponentModel.Composition;

using System.ComponentModel.Composition.Hosting;

接下来看下Program 的构造函数所做的事情:

声明一个AssemblyCatalog,指向Program所在的Assembly. 然后把它添加到

CompositionContainer中,调用CompositionContainer 的ComposeParts 扩展方法,来Compose(this) 的Parts。

注:ComposeParts 是扩展方法,需要using System.ComponentModel.Composition;

OK,如何Compose,在哪个Assembly中查找实现类来进行Compose已经完成了。

目前的问题是:哪些类需要Compose??

为了回答这个问题,微软提供了Import和Export特性: 

Import:哪个对象需要Compose。也就是需要被实现类给填充,所以Import标记的是对象,一般该对象是接口,因为如果是具体类的话,那还需要Import吗?

Export:哪个类可以被用来Compose,也就是说这个类是不是可以用来填充的实现类,所以Export标记的是类,而不是具体的某个对象。

所以在这里calculator 使用Import 特性来标记:

[Import(typeof(ICalculator))]

private ICalculator calculator;

接下来MEF 的组合引擎在ComposeParts(this)的时候,就会在catalog 代表的AssemblyCatalog中查找Export特性所修饰的实现类了,找到实现类后进行Compose。

如果找不到Export特性修饰的类的话,结果如下:

基于MEF打造的插件系统的实现详解_毕业论文-特色小镇打造模式详解

OK,接下来添加一个实现类,并使用Export特性来进行修饰:

[Export(typeof(ICalculator))]

 public class MySimpleCalculator : ICalculator

 {

     public string Calculate(string input)

     {

         return "MySimpleCalculator 处理了" + input;

     }

 }

运行结果如下:

基于MEF打造的插件系统的实现详解_毕业论文-远征2装备打造详解

当然Import和Export还提供了其他的构造函数,所以你还可以将上面的Import和Export修改为:

[Import("calculator1", typeof(ICalculator))]

[Export("calculator1", typeof(ICalculator))]

之所以提供ContractName为calculator1 是因为你可能有多个ICalculator对象需要填充。

修改Program的代码如下:

class Program

{

    private CompositionContainer _container;

    [Import("calculator1", typeof(ICalculator))]

    private ICalculator calculator1;

    [Import("calculator2", typeof(ICalculator))]

    private ICalculator calculator2;

    public Program()

    {

        //var catalog = new AggregateCatalog();

        //catalog.Catalogs.Add(new AssemblyCatalog(typeof(Program).Assembly));

        var catalog = new AssemblyCatalog(typeof(Program).Assembly);

        _container = new CompositionContainer(catalog);

        try

        {

            this._container.ComposeParts(this);

        }

        catch(CompositionException compositionException)

        {

            Console.WriteLine(compositionException.ToString());

        }

    }

    static void Main(string[] args)

    {

        Program p = new Program();

        string s;

        Console.WriteLine("Enter Command:");

        while (true)

        {

            s = Console.ReadLine();

            Console.WriteLine(p.calculator1.Calculate(s));

            Console.WriteLine(p.calculator2.Calculate(s));

        }

    }

}

修改Export修饰的类为:

[Export("calculator1", typeof(ICalculator))]

public class MySimpleCalculator1 : ICalculator

{

    public string Calculate(string input)

    {

        return "第一个Calculator 处理了" + input;

    }

}

[Export("calculator2", typeof(ICalculator))]

public class MySimpleCalculator2 : ICalculator

{

    public string Calculate(string input)

    {

        return "第二个Calculator 处理了" + input;

    }

}

运行结果如下:

基于MEF打造的插件系统的实现详解_毕业论文-发蜡干胶打造发型详解

因为Import和Export是一一对应的,在现实世界中,存在着大量一对多的情况,微软也预料到了这种情况,所以提供了ImportMany 特性。

在上个例子中的MySimpleCalculator的Calculate方法返回的是一句话,在这个例子中要真正实现计算的功能,例如输入5+3,输出8,输入7*4,输出28。

为了支持 + - * / 四种Operation.所以在MySimpleCalculator中声明一个operations 的列表

[Export(typeof(ICalculator))]

class MySimpleCalculator : ICalculator

{

    [ImportMany]

    IEnumerable<Lazy<IOperation, IOperationData>> operations;

    public string Calculate(string input)

        {

return "calculate 处理了" + input;

        }

}

之所以在MySimpleCalculator 中声明operations ,是因为是计算器支持多种运算。因为operations 需要多个operation 来Compose(填充),所以使用ImportMany特性来修饰,和Import特性一样,ImportMany特性一般也是修饰接口。

Ioperation 和IOperationData的定义如下:

public interface IOperation

{

    int Operate(int left, int right);

}

public interface IOperationData

{

    Char Symbol { get; }

}

Lazy<IOperation, IOperationData> operations:

提供对对象及其关联的元数据的延迟间接引用,以供 Managed Extensibility Framework 使用。

意思是说IOperation 和IOperationData之间的引用需要延迟,为什么需要延迟?,因为IOperation需要根据IOperationData的Symbol符号来延迟创建。

也就是说,如果IOperationData的Symbol 等于 “+”,那么IOperation对象是AddOperation.如果IOperationData的Symbol等于”-”,那么IOperation对象是SubtractOperation.

那么如何保证这点呢?

关键点就在于ExportMetadata attribute 上。

看下Add Operation 的定义:

[Export(typeof(IOperation))]

[ExportMetadata("Symbol", '+')]

class Add : IOperation

{

    public int Operate(int left, int right)

    {

        return left + right;

    }

}

在这里ExportMetadata特性的Symbol 为+。所以当IOperationData的Symbol为”+” 的时候,匹配的就是Add Operation

MySimpleCalculator 的完整代码如下:

[Export(typeof(ICalculator))]

class MySimpleCalculator : ICalculator

{

    [ImportMany]

    IEnumerable<Lazy<IOperation, IOperationData>> operations;

    public string Calculate(string input)

        {

            int left;

            int right;

            char operation;

            int fn = FindFirstNonDigitPosition(input);

            if (fn < 0) return "Could not parse command.";

            try

            {

                left = int.Parse(input.Substring(0, fn));

                right = int.Parse(input.Substring(fn + 1));

            }

            catch

            {

                return "Could not parse command";

            }

            operation = input[fn];

            foreach (Lazy<IOperation, IOperationData> i in operations)

            {

                if (i.Metadata.Symbol.Equals(operation))

                    return i.Value.Operate(left, right).ToString();

            }

            return "Operation Not Found!";

        }

    private int FindFirstNonDigitPosition(string s)

    {

        for (int i = 0; i < s.Length; i++)

        {

            if (!(Char.IsDigit(s[i]))) return i;

        }

        return -1;

    }

}

回头再看看上例的Program代码:

class Program

{

    private CompositionContainer _container;

    [Import(typeof(ICalculator))]

    private ICalculator calculator;

    public Program()

    {

        //var catalog = new AggregateCatalog();

        //catalog.Catalogs.Add(new AssemblyCatalog(typeof(Program).Assembly));

        var catalog = new AssemblyCatalog(typeof(Program).Assembly);

        _container = new CompositionContainer(catalog);

        try

        {

            this._container.ComposeParts(this);

        }

        catch(CompositionException compositionException)

        {

            Console.WriteLine(compositionException.ToString());

        }

    }

    static void Main(string[] args)

    {

        Program p = new Program();

        string s;

        Console.WriteLine("Enter Command:");

        while (true)

        {

            s = Console.ReadLine();

            Console.WriteLine(p.calculator.Calculate(s));

        }

    }

}

当this._container.ComposeParts(this); 的时候,MEF组合引擎就开始对标记了Import特性的接口进行Compose,所以在这里是calculator。在哪里找实现类呢?,AssemblyCatalog表明在Program的当前Assembly中查找实现类,所以找到了MySimpleCalculator在构造MySimpleCalculator 的时候,发现了ImportMany特性修饰的operations。于是继续在AssemblyCatalog中找到了Add。

上面的过程是Compose的过程。

那么MySimpleCalculator 如何进行Calculate的呢?

例如5+3

1:找出第一个非数字的位置,也就是需要找出 +。

2:声明left,right.并且left 为5,right为3.

3:根据符号+来构造IOperation对象,接着调用IOperation对象的Operate(left,right)方法。

foreach (Lazy<IOperation, IOperationData> i in operations)

 {

     if (i.Metadata.Symbol.Equals(operation))

         return i.Value.Operate(left, right).ToString();

 }

运行结果:

基于MEF打造的插件系统的实现详解_毕业论文-飞凡网 打造实现多方

因为目前定义了Add 的Operation。所以根据符号+ 能够找到Add,但是*我们没有定义,所以Operation Not Found!.

于是开始定义Multiple:

[Export(typeof(IOperation))]

 [ExportMetadata("Symbol", '*')]

 class Multiple : IOperation

 {

     public int Operate(int left, int right)

     {

         return left * right;

     }

 }

再次运行,结果如下:

基于MEF打造的插件系统的实现详解_毕业论文-mef 插件

当然还可以在当前程序集下面增加- ,/,^,% 等Operation。

为了让事情更加的有趣,我打算在Debug目录下增加一个目录CalculateExtensions,然后将-,/ ..的Operation放到里面来,让MEF自动发现。

基于MEF打造的插件系统的实现详解_毕业论文-特色小镇打造模式详解

首先新建类库项目:SimpleCalculatorExtension

因为需要实现IOperation ,所以需要添加对SimpleCalculator项目的引用。

因为需要Export特性,所以需要添加对System.ComponentModel.Composition的引用。

整个项目的结果如下:

基于MEF打造的插件系统的实现详解_毕业论文-远征2装备打造详解

Subtract代码如下:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.ComponentModel.Composition;

namespace SimpleCalculatorExtension

{

    [Export(typeof(SimpleCalculator.IOperation))]

    [ExportMetadata("Symbol", '-')]

    class Subtract : SimpleCalculator.IOperation

    {

        public int Operate(int left, int right)

        {

            return left - right;

        }

    }

}

生成成功后,将SimpleCalculatorExtension.dll 拷贝到CalculateExtensions目录下:

现在SimpleCalculator的Debug目录应该是这样。

基于MEF打造的插件系统的实现详解_毕业论文-发蜡干胶打造发型详解

并且CalculateExtensions文件夹下面有SimpleCalculatorExtension.dll.

接下来唯一要修改的是Program的catalog 对象。

为了让catalog既支持在Program的Assembly中查找,又支持在CalculateExtensions目录下查找。修改代码如下:

public Program()

 {

     var catalog = new AggregateCatalog();

     catalog.Catalogs.Add(new AssemblyCatalog(typeof(Program).Assembly));

     catalog.Catalogs.Add(new DirectoryCatalog("CalculateExtensions"));

     _container = new CompositionContainer(catalog);

     try

     {

         this._container.ComposeParts(this);

     }

     catch(CompositionException compositionException)

     {

         Console.WriteLine(compositionException.ToString());

     }

 }

运行结果如下:

基于MEF打造的插件系统的实现详解_毕业论文-飞凡网 打造实现多方

修改SimpleCalculatorExtension 的Subtract方法为:

namespace SimpleCalculatorExtension

{

    [Export(typeof(SimpleCalculator.IOperation))]

    [ExportMetadata("Symbol", '-')]

    class Subtract : SimpleCalculator.IOperation

    {

        public int Operate(int left, int right)

        {

            Console.WriteLine("SimpleCalculatorExtension的方法");

            return left - right;

        }

    }

}

重新生成SimpleCalculatorExtension.dll 然后拷贝到CalculateExtensions 文件夹下:

再次运行程序,输出入下:

基于MEF打造的插件系统的实现详解_毕业论文-mef 插件

文章有点长,而且有点乱,最好自己动手实践下MEF,不过讲的都是MEF的基础,希望对你有所帮助,另外如果你不使用MEF,采用面向接口的编程原则的话,相信你自己也很容易实现自己的“MEF”

】:

以实例说话,一起体验MEF带来的可扩展性吧,Let's Rock!!!

1:新建控制台程序SimpleCalculator

基于MEF打造的插件系统的实现详解_毕业论文-特色小镇打造模式详解

在这里要实现的程序时SimpleCalculator,顾名思义:简单的计算器。

所以我们需要定义一个用来计算的接口:

public interface ICalculator

{

    String Calculate(String input);

}

Program 的代码如下:

class Program
{
    private CompositionContainer _container;

    [Import(typeof(ICalculator))]
    private ICalculator calculator;

    public Program()
    {
        //var catalog = new AggregateCatalog();
        //catalog.Catalogs.Add(new AssemblyCatalog(typeof(Program).Assembly));

        var catalog = new AssemblyCatalog(typeof(Program).Assembly);
        _container = new CompositionContainer(catalog);

        try
        {
            this._container.ComposeParts(this);
        }
        catch (CompositionException compositionException)
        {
            Console.WriteLine(compositionException.ToString());
        }
    }

    static void Main(string[] args)
    {
        Program p = new Program();
        string s;
        Console.WriteLine("Enter Command:");

        while (true)
        {
            s = Console.ReadLine();
            Console.WriteLine(p.calculator.Calculate(s));
        }
    }
}

MEF所要解决的是寻找插件的功能,传统的实现插件的方式主要是使用接口,即声明一个接口,然后使用配置文件来配置接口使用哪个实现类。

微软知道有这种需求,于是提供了MEF来实现插件的功能。

Composite 原理

1:声明一个 CompositionContainer 对象,这个对象里面包含一堆Catalog.

2:这堆Catalog如果是AssemblyCatalog,则在Assembly中查找,如果是DirectoryCatalog,

在Directory 中查找,如果即想要在Assembly中查找,又需要在Directory中查找,

则采用AggregateCatalog。

3:然后在这堆Catalog中查找与Import 特性相对应的Export标记所标记的实现类,调用实现类的构造函数进行

Composite(组合)。

知道原理后,你也可以自己实现自己的CompositionContainer 类了,

要使用MEF 需要为SimpleCalculator添加 System.ComponentModel.Composition.dll 的引用,

然后导入命名空间:

using System.ComponentModel.Composition;

using System.ComponentModel.Composition.Hosting;

接下来看下Program 的构造函数所做的事情:

声明一个AssemblyCatalog,指向Program所在的Assembly. 然后把它添加到

CompositionContainer中,调用CompositionContainer 的ComposeParts 扩展方法,来Compose(this) 的Parts。

注:ComposeParts 是扩展方法,需要using System.ComponentModel.Composition;

OK,如何Compose,在哪个Assembly中查找实现类来进行Compose已经完成了。

目前的问题是:哪些类需要Compose??

为了回答这个问题,微软提供了Import和Export特性: 

Import:哪个对象需要Compose。也就是需要被实现类给填充,所以Import标记的是对象,一般该对象是接口,因为如果是具体类的话,那还需要Import吗?

Export:哪个类可以被用来Compose,也就是说这个类是不是可以用来填充的实现类,所以Export标记的是类,而不是具体的某个对象。

所以在这里calculator 使用Import 特性来标记:

[Import(typeof(ICalculator))]

private ICalculator calculator;

接下来MEF 的组合引擎在ComposeParts(this)的时候,就会在catalog 代表的AssemblyCatalog中查找Export特性所修饰的实现类了,找到实现类后进行Compose。

如果找不到Export特性修饰的类的话,结果如下:

基于MEF打造的插件系统的实现详解_毕业论文-远征2装备打造详解

OK,接下来添加一个实现类,并使用Export特性来进行修饰:

[Export(typeof(ICalculator))]

 public class MySimpleCalculator : ICalculator

 {

     public string Calculate(string input)

     {

         return "MySimpleCalculator 处理了" + input;

     }

 }

运行结果如下:

基于MEF打造的插件系统的实现详解_毕业论文-发蜡干胶打造发型详解

当然Import和Export还提供了其他的构造函数,所以你还可以将上面的Import和Export修改为:

[Import("calculator1", typeof(ICalculator))]

[Export("calculator1", typeof(ICalculator))]

之所以提供ContractName为calculator1 是因为你可能有多个ICalculator对象需要填充。

修改Program的代码如下:

class Program

{

    private CompositionContainer _container;

    [Import("calculator1", typeof(ICalculator))]

    private ICalculator calculator1;

    [Import("calculator2", typeof(ICalculator))]

    private ICalculator calculator2;

    public Program()

    {

        //var catalog = new AggregateCatalog();

        //catalog.Catalogs.Add(new AssemblyCatalog(typeof(Program).Assembly));

        var catalog = new AssemblyCatalog(typeof(Program).Assembly);

        _container = new CompositionContainer(catalog);

        try

        {

            this._container.ComposeParts(this);

        }

        catch(CompositionException compositionException)

        {

            Console.WriteLine(compositionException.ToString());

        }

    }

    static void Main(string[] args)

    {

        Program p = new Program();

        string s;

        Console.WriteLine("Enter Command:");

        while (true)

        {

            s = Console.ReadLine();

            Console.WriteLine(p.calculator1.Calculate(s));

            Console.WriteLine(p.calculator2.Calculate(s));

        }

    }

}

修改Export修饰的类为:

[Export("calculator1", typeof(ICalculator))]

public class MySimpleCalculator1 : ICalculator

{

    public string Calculate(string input)

    {

        return "第一个Calculator 处理了" + input;

    }

}

[Export("calculator2", typeof(ICalculator))]

public class MySimpleCalculator2 : ICalculator

{

    public string Calculate(string input)

    {

        return "第二个Calculator 处理了" + input;

    }

}

运行结果如下:

基于MEF打造的插件系统的实现详解_毕业论文-飞凡网 打造实现多方

因为Import和Export是一一对应的,在现实世界中,存在着大量一对多的情况,微软也预料到了这种情况,所以提供了ImportMany 特性。

在上个例子中的MySimpleCalculator的Calculate方法返回的是一句话,在这个例子中要真正实现计算的功能,例如输入5+3,输出8,输入7*4,输出28。

为了支持 + - * / 四种Operation.所以在MySimpleCalculator中声明一个operations 的列表。

[Export(typeof(ICalculator))]

class MySimpleCalculator : ICalculator

{

    [ImportMany]

    IEnumerable<Lazy<IOperation, IOperationData>> operations;

    public string Calculate(string input)

        {

return "calculate 处理了" + input;

        }

}

之所以在MySimpleCalculator 中声明operations ,是因为是计算器支持多种运算。因为operations 需要多个operation 来Compose(填充),所以使用ImportMany特性来修饰,和Import特性一样,ImportMany特性一般也是修饰接口。

Ioperation 和IOperationData的定义如下:

public interface IOperation

{

    int Operate(int left, int right);

}

public interface IOperationData

{

    Char Symbol { get; }

}

Lazy<IOperation, IOperationData> operations:

提供对对象及其关联的元数据的延迟间接引用,以供 Managed Extensibility Framework 使用。

意思是说IOperation 和IOperationData之间的引用需要延迟,为什么需要延迟?,因为IOperation需要根据IOperationData的Symbol符号来延迟创建。

也就是说,如果IOperationData的Symbol 等于 “+”,那么IOperation对象是AddOperation.如果IOperationData的Symbol等于”-”,那么IOperation对象是SubtractOperation.

那么如何保证这点呢?

关键点就在于ExportMetadata attribute 上。

看下Add Operation 的定义:

[Export(typeof(IOperation))]

[ExportMetadata("Symbol", '+')]

class Add : IOperation

{

    public int Operate(int left, int right)

    {

        return left + right;

    }

}

在这里ExportMetadata特性的Symbol 为+。所以当IOperationData的Symbol为”+” 的时候,匹配的就是Add Operation

MySimpleCalculator 的完整代码如下:

[Export(typeof(ICalculator))]

class MySimpleCalculator : ICalculator

{

    [ImportMany]

    IEnumerable<Lazy<IOperation, IOperationData>> operations;

    public string Calculate(string input)

        {

            int left;

            int right;

            char operation;

            int fn = FindFirstNonDigitPosition(input);

            if (fn < 0) return "Could not parse command.";

            try

            {

                left = int.Parse(input.Substring(0, fn));

                right = int.Parse(input.Substring(fn + 1));

            }

            catch

            {

                return "Could not parse command";

            }

            operation = input[fn];

            foreach (Lazy<IOperation, IOperationData> i in operations)

            {

                if (i.Metadata.Symbol.Equals(operation))

                    return i.Value.Operate(left, right).ToString();

            }

            return "Operation Not Found!";

        }

    private int FindFirstNonDigitPosition(string s)

    {

        for (int i = 0; i < s.Length; i++)

        {

            if (!(Char.IsDigit(s[i]))) return i;

        }

        return -1;

    }

}

回头再看看上例的Program代码:

class Program

{

    private CompositionContainer _container;

    [Import(typeof(ICalculator))]

    private ICalculator calculator;

    public Program()

    {

        //var catalog = new AggregateCatalog();

        //catalog.Catalogs.Add(new AssemblyCatalog(typeof(Program).Assembly));

        var catalog = new AssemblyCatalog(typeof(Program).Assembly);

        _container = new CompositionContainer(catalog);

        try

        {

            this._container.ComposeParts(this);

        }

        catch(CompositionException compositionException)

        {

            Console.WriteLine(compositionException.ToString());

        }

    }

    static void Main(string[] args)

    {

        Program p = new Program();

        string s;

        Console.WriteLine("Enter Command:");

        while (true)

        {

            s = Console.ReadLine();

            Console.WriteLine(p.calculator.Calculate(s));

        }

    }

}

当this._container.ComposeParts(this); 的时候,MEF组合引擎就开始对标记了Import特性的接口进行Compose,所以在这里是calculator。在哪里找实现类呢?,AssemblyCatalog表明在Program的当前Assembly中查找实现类,所以找到了MySimpleCalculator在构造MySimpleCalculator 的时候,发现了ImportMany特性修饰的operations。于是继续在AssemblyCatalog中找到了Add。

上面的过程是Compose的过程。

那么MySimpleCalculator 如何进行Calculate的呢?

例如5+3

1:找出第一个非数字的位置,也就是需要找出 +。

2:声明left,right.并且left 为5,right为3.

3:根据符号+来构造IOperation对象,接着调用IOperation对象的Operate(left,right)方法。

foreach (Lazy<IOperation, IOperationData> i in operations)

 {

     if (i.Metadata.Symbol.Equals(operation))

         return i.Value.Operate(left, right).ToString();

 }

运行结果:

基于MEF打造的插件系统的实现详解_毕业论文-mef 插件

因为目前定义了Add 的Operation。所以根据符号+ 能够找到Add,但是*我们没有定义,所以Operation Not Found!.

于是开始定义Multiple:

[Export(typeof(IOperation))]

 [ExportMetadata("Symbol", '*')]

 class Multiple : IOperation

 {

     public int Operate(int left, int right)

     {

         return left * right;

     }

 }

再次运行,结果如下:

基于MEF打造的插件系统的实现详解_毕业论文-特色小镇打造模式详解

当然还可以在当前程序集下面增加- ,/,^,% 等Operation。

为了让事情更加的有趣,我打算在Debug目录下增加一个目录CalculateExtensions,然后将-,/ ..的Operation放到里面来,让MEF自动发现。

基于MEF打造的插件系统的实现详解_毕业论文-远征2装备打造详解

首先新建类库项目:SimpleCalculatorExtension

因为需要实现IOperation ,所以需要添加对SimpleCalculator项目的引用。

因为需要Export特性,所以需要添加对System.ComponentModel.Composition的引用。

整个项目的结果如下:

基于MEF打造的插件系统的实现详解_毕业论文-发蜡干胶打造发型详解

Subtract代码如下:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.ComponentModel.Composition;

namespace SimpleCalculatorExtension

{

    [Export(typeof(SimpleCalculator.IOperation))]

    [ExportMetadata("Symbol", '-')]

    class Subtract : SimpleCalculator.IOperation

    {

        public int Operate(int left, int right)

        {

            return left - right;

        }

    }

}

生成成功后,将SimpleCalculatorExtension.dll 拷贝到CalculateExtensions目录下:

现在SimpleCalculator的Debug目录应该是这样。

基于MEF打造的插件系统的实现详解_毕业论文-飞凡网 打造实现多方

并且CalculateExtensions文件夹下面有SimpleCalculatorExtension.dll.

接下来唯一要修改的是Program的catalog 对象。

为了让catalog既支持在Program的Assembly中查找,又支持在CalculateExtensions目录下查找。修改代码如下:

public Program()

 {

     var catalog = new AggregateCatalog();

     catalog.Catalogs.Add(new AssemblyCatalog(typeof(Program).Assembly));

     catalog.Catalogs.Add(new DirectoryCatalog("CalculateExtensions"));

     _container = new CompositionContainer(catalog);

     try

     {

         this._container.ComposeParts(this);

     }

     catch(CompositionException compositionException)

     {

         Console.WriteLine(compositionException.ToString());

     }

 }

运行结果如下:

基于MEF打造的插件系统的实现详解_毕业论文-mef 插件

修改SimpleCalculatorExtension 的Subtract方法为:

namespace SimpleCalculatorExtension

{

    [Export(typeof(SimpleCalculator.IOperation))]

    [ExportMetadata("Symbol", '-')]

    class Subtract : SimpleCalculator.IOperation

    {

        public int Operate(int left, int right)

        {

            Console.WriteLine("SimpleCalculatorExtension的方法");

            return left - right;

        }

    }

}

重新生成SimpleCalculatorExtension.dll 然后拷贝到CalculateExtensions 文件夹下:

再次运行程序,输出入下:

基于MEF打造的插件系统的实现详解_毕业论文-特色小镇打造模式详解

文章有点长,而且有点乱,最好自己动手实践下MEF,不过讲的都是MEF的基础,希望对你有所帮助,另外如果你不使用MEF,采用面向接口的编程原则的话,相信你自己也很容易实现自己的“MEF”

以上是云栖社区小编为您精心准备的的内容,在云栖社区的博客、问答、公众号、人物、课程等栏目也有的相关内容,欢迎继续使用右上角搜索按钮进行搜索MEF 插件系统 mef 插件、特色小镇打造模式详解、远征2装备打造详解、发蜡干胶打造发型详解、飞凡网 打造实现多方,以便于您获取更多的相关知识。