MEF

[MEF][WPF]XAMLからMEFのコンテナにアクセスするマークアップ拡張

k.ota.0130@gmail.com(かずき) — Fri, 29 Jan 2010 01:11:00 GMT

何となく作ってみた。

まず、コンテナを保持しておくためのstaticなクラスを用意する。

[WPF][C#][MEF]MEF(Managed Extensibility Framework) & WPFでHello world

k.ota.0130@gmail.com(かずき) — Sat, 05 Dec 2009 01:05:00 GMT

注意：MEFは、正式リリース前のbeta版を使ってるので、正式版とは違うかもしれません。

次期.NET Framework4に入るDIコンテナのMEFとWPFを組み合わせて、簡単なHello worldを作ってみようと思います。

[Silverlight][MEF]MEFのbeta2(preview 7)が出てました

kazuki@wankuma.com (かずき) — Fri, 11 Sep 2009 12:40:00 GMT

ぽろっと覗きに行ったら、MEF Preview 7が出てました。↓からダウンロードできます。
http://mef.codeplex.com/Release/ProjectReleases.aspx?ReleaseId=30259

Preview 6がどうだったか覚えてませんが、今回は.net 3.5で動くものと、Silverlight3で動くものを別々にダウンロードしないといけないみたいです。

このMEFは、次バージョンの.NET Framework 4.0にのると思う（情報のソースは忘れました！）ので、勉強しておいて損はない一品だと思います。
というか、言語の標準ライブラリにDIコンテナがついてくるのは、.NETが初？？（.NETは言語じゃね～っていう突っ込みはしないでね♪）

JavaやRubyやPerlやJavaScriptやC++やHaskellには、少なくともついてない！！
これは、アツイ。

[C#][MEF]Managed Extensibility Framework入門その８

kazuki@wankuma.com (かずき) — Fri, 10 Jul 2009 01:38:00 GMT

前回に引き続き、Catalog関連の部分をやってみようと思います。
今回のターゲットはDirectoryCatalogです。

こいつは、Directory内にあるアセンブリを自動で読み取って登録してくれるものです。
ということで、いつもどおりのコンソールアプリケーションにも飽きてきたので、WPFアプリケーションで実験してみようと思います。

WpfMEFという名前でWPFアプリケーションを作成します。
そして、Window1にExport属性をつけてコンテナにExportします。

[Export]
public partial class Window1 : Window
{
	// 省略
}

そして、App.xamlのStartupUri属性を消してStartupイベントを作り、そこに以下のようなコンテナの初期化コードと、Window1を表示する処理を書きます。

using System.ComponentModel.Composition;
using System.ComponentModel.Composition.Hosting;
using System.Windows;

namespace WpfMEF
{
    public partial class App : Application
    {
        private void Application_Startup(object sender, StartupEventArgs e)
        {
            // カレントディレクトリにあるアセンブリを対象にするDirectoryCatalogを作成
            var dirCatalog = new DirectoryCatalog(".");
            // 自アセンブリと↑をまとめたカタログを作成
            var catalog = new AggregateCatalog(
                new AssemblyCatalog(typeof(App).Assembly),
                dirCatalog);

            // コンテナを作成してDirectoryCatalogを明示的にコンテナに追加
            var con = new CompositionContainer(catalog);
            var batch = new CompositionBatch();
            batch.AddExportedObject<DirectoryCatalog>(dirCatalog);
            con.Compose(batch);

            // Window1を表示
            var window = con.GetExportedObject<Window1>();
            window.Show();
        }
    }
}

今回のキモは、DirectoryCatalogをあえてコンテナに登録しているところです。
こうすることで、DirectoryCatalogをImportできるようになります。

次に、Window1.xamlを編集していきます。Window1.xamlは、プラグインをホストするためのItemsControlと、プラグインの再読み込みを行うRefreshボタンがあるだけのシンプル構造にしました。

<Window x:Class="WpfMEF.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Loaded="Window_Loaded"
    Title="Window1">
    <DockPanel>
        <Button DockPanel.Dock="Top" Content="Refresh" Click="Button_Click" />
        <ItemsControl ItemsSource="{Binding Plugins}"/>
    </DockPanel>
</Window>

Window1のイベントとしては、Loadedイベントと、Refreshボタンのクリックイベントを登録しています。Loadedイベントとクリックイベントでは、プラグインの再読み込みを行っています。

コードとしては、こんな感じです。

using System.Collections.ObjectModel;
using System.ComponentModel.Composition;
using System.ComponentModel.Composition.Hosting;
using System.Windows;

namespace WpfMEF
{
    [Export]
    public partial class Window1 : Window
    {
        // プラグイン
        [Import(AllowRecomposition=true)]
        public ExportCollection<FrameworkElement> ExportedFrameworkElements { get; set; }

        // カタログ
        [Import]
        public DirectoryCatalog Catalog { get; set; }

        // ここにプラグインに定義されたFrameworkElementが入る.
        // XAML側のItemsControlとバインドされているので、ここに入れたFrameworkElementが画面に
        // 表示される。
        public ObservableCollection<FrameworkElement> Plugins { get; private set; }

        // プラグインの初期化・再読み込みを行う
        private void LoadPlugins()
        {
            // 初回のときはコレクションを作成する
            if (Plugins == null)
            {
                this.Plugins = new ObservableCollection<FrameworkElement>();
            }

            // 再読み込み開始
            Catalog.Refresh();
            Plugins.Clear();

            // 新たなプラグインをコレクションに追加
            foreach(var plugin in ExportedFrameworkElements)
            {
                Plugins.Add(plugin.GetExportedObject());
            }
        }

        public Window1()
        {
            InitializeComponent();
        }

        private void Button_Click(object sender, RoutedEventArgs e)
        {
            LoadPlugins();
        }

        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            LoadPlugins();

            // とりあえずコードビハインドがViewModel役
            DataContext = this;
        }
    }
}

これで、プラグインをホストする側は完成です。
実行すると、ボタンがあるだけの悲しい画面が起動するのが確認できます。

プラグインを作成

プラグインのプロジェクトを２つ作成します。WpfPlugin1とWpfPlugin2という名前でWPFのユーザコントロールライブラリを作成します。System.ComponentModel.Composition.dllへの参照を各々追加しておきます。
それぞれ、非常にシンプルなユーザコントロールを１つずつ定義しておきます。

Plugin1のほうのユーザコントロール

<UserControl x:Class="WpfPlugin1.Plugin1Control"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
    <Grid>
        <TextBlock Text="Plugin1" />
    </Grid>
</UserControl>

Plugin2のほうのユーザコントロール

<UserControl x:Class="WpfPlugin2.UserControl1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
    <Grid>
        <TextBlock Text="Plugin2" />
    </Grid>
</UserControl>

各々のコードビハインドで、クラスにExport(typeof(FrameworkElement))属性をつけます。
こうすることで、プラグインをホストする側のExportCollection<FrameworkElement>にImportされるようになります。

Plugin1のほうのコードビハインド

using System.ComponentModel.Composition;
using System.Windows;
using System.Windows.Controls;

namespace WpfPlugin1
{
    [Export(typeof(FrameworkElement))]
    public partial class Plugin1Control : UserControl
    {
        public Plugin1Control()
        {
            InitializeComponent();
        }
    }
}

Plugin2のほうのコードビハインド

using System.ComponentModel.Composition;
using System.Windows;
using System.Windows.Controls;

namespace WpfPlugin2
{
    [Export(typeof(FrameworkElement))]
    public partial class UserControl1 : UserControl
    {
        public UserControl1()
        {
            InitializeComponent();
        }
    }
}

それでは、実行して動きを見ていきます。
WpfMEFを起動してボタン１つだけの画面が起動することを確認します。

アプリケーションをいったん終了して、WpfMEFのbin\Debugフォルダに、WpfPlugin1.dllをコピーして起動します。
すると、画面にPlugin1が表示されます。

続いて、起動したままの状態でWpfPlugin2.dllをWpfEMFのbin\DebugフォルダにコピーしてRefreshボタンを押すと…

Plugin2が追加されました！
ということで、DirectoryCatalogを使うと、プラグインみたいな機能が割りと簡単に作れるということでした。

[C#][MEF]Managed Extensibility Framework入門その７

kazuki@wankuma.com (かずき) — Sun, 05 Jul 2009 11:46:00 GMT

MEF入門も、既に7回目になりました。
あと何個か書くネタがありますが、今回は今までと趣向を変えてCatalogについてちょっと試してみようと思います。

同一アセンブリしか駄目なの？

いきなり変なタイトルをつけましたが、今までのサンプルは、AssemblyCatalogというクラスを使ってコンテナを作成していました。このAssemblyCatalogは、引数で指定したアセンブリの中からExport属性やImport属性のついたものを自動的に収集してくれるいい奴です。

ただ、これだと１つのアセンブリからしかクラスを取得できません。
後は、第二回で使ったCompositionBatchを使って１つ１つ登録しないといけないみたいに感じてしまいますが、そんなことはありません。

ちゃんと、他にも～Catalogクラスがあります。

Catalog系クラス達

Catalog系というのも今勝手につけた言い方ですが、～Catalogという名前のクラスを４つ紹介したいと思います。

System.ComponentModel.Composition.Hosting.TypeCatalog
名前からわかるとおり、指定された型を対象にするカタログクラスです。
System.ComponentModel.Composition.Hosting.AssemblyCatalog
今までお世話になってきた、指定したアセンブリ内のクラスを対象にするカタログクラスです。
System.ComponentModel.Composition.Hosting.DirectoryCatalog
こいつが今回の大本命です。
指定したディレクトリ内にあるアセンブリを勝手に読み込んでくれます。うわさによると、実行中に追加されたDLLも認識するとか・・・。
System.ComponentModel.Composition.Hosting.AggregateCatalog
複数のCatalogを一まとめにする縁の下の力持ち

TypeCatalog

TypeCatalogは、コンストラクタで渡したTypeを対象にするクラスです。何かフレームワークとかで決まった型を登録したいとかいうときに使いそう？

using System;
using System.ComponentModel.Composition;
using System.ComponentModel.Composition.Hosting;

namespace MEFCatalog
{
    [Export]
    public class Greeter
    {
        public string Greet()
        {
            return "Hello world";
        }
    }

    [Export]
    public class GreetApp
    {
        [Import]
        public Greeter Greeter { get; set; }

        public void Execute()
        {
            Console.WriteLine(Greeter.Greet());
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            // TypeCatalogにGreeterとGreetAppを登録
            var typeCatalog = new TypeCatalog(
                typeof(Greeter), typeof(GreetApp));
            // TypeCatalogでContainerを作成
            var container = new CompositionContainer(typeCatalog);

            // 後はいつもどおり
            var app = container.GetExportedObject<GreetApp>();
            app.Execute();
        }
    }
}

このコードでHello worldが表示されます。

AssemblyCatalog

これまでのサンプルの通りなので省略

AggregateCatalog

AggregateCatalogは、複数のCatalogを１まとめにするために使います。
例えば、AssemblyCatalogとTypeCatalogを１まとめにして、コンテナに渡す場合は下のようになります。

// 型A, B, Cを登録するよ
var typeCatalog = new TypeCatalog(
  typeof(A), typeof(B), typeof(C));

// 型Programのあるアセンブリ内のクラスを登録するよ
var assmCatalog = new AssemblyCatalog(
  typeof(Program).Assembly);

// typeCatalogとassmCatalogを１まとめに
var aggCatalog = new AggregateCatalog(
  typeCatalog, assmCatalog);

// typeCatalogとassmCatalogにある両方の型が登録されたコンテナの完成
var container = new CompositionContainer(aggCatalog);

CompositionContainerが、Catalogを１つしか受け取らないので、複数のCatalogを使いたいときは、AggregateCatalogで事前に１まとめにしておく必要があるようです。

DirectoryCatalogについては、また次回で(時間切れ)！

[C#][MEF]Managed Extensibility Framework入門その６

kazuki@wankuma.com (かずき) — Fri, 03 Jul 2009 12:52:00 GMT

前回は、MethodのExportとImportについて試してみました。
これまでの5回で、基本的なImportとExportについては出来るようになりました。そして、適切にExport属性をつけるだけで勝手に適切なImport属性がついてるプロパティに設定されるのは素敵だということを感じたと思います。

今回は、同じ条件に合致する複数のExport属性があるときのImportの仕方について見ていこうと思います。

見ていくといっても大して書くことはなくて、これまで

[Import]
public TPropertyType PropertyName { get; set; }

のように普通のプロパティにしていた部分を

[Import]
public List<TPropertyType> PropertyName { get; set; }

のようにコレクションにするだけでExportが複数ある場合にコレクションにImportされるようになります。

ということで簡単に動きを見ていきます。
とりあえず、MEFEduというコンソールアプリケーションを作って、System.ComponentModel.Composition.dllを参照に追加して、いつもどおりのコンテナの初期化のコードを書きます。

using System.ComponentModel.Composition.Hosting;

namespace MEFEdu
{
    class Program
    {
        static void Main(string[] args)
        {
            // コンテナの初期化
            var catalog = new AssemblyCatalog(
                typeof(Program).Assembly);
            var container = new CompositionContainer(catalog);
        }
    }
}

まず、GreetAppクラスを作成します。Actionのコレクションのプロパティを定義して、Import(“Greet”)という属性を付けています。ついでに、Mainのほうも、コンテナからGreetAppのインスタンスを取得して実行するようにします。

using System.ComponentModel.Composition.Hosting;
using System;
using System.ComponentModel.Composition;
using System.Collections.Generic;

namespace MEFEdu
{
    class Program
    {
        static void Main(string[] args)
        {
            // コンテナの初期化
            var catalog = new AssemblyCatalog(
                typeof(Program).Assembly);
            var container = new CompositionContainer(catalog);

            var app = container.GetExportedObject<GreetApp>();
            app.Execute();
        }
    }

    [Export]
    public class GreetApp
    {
        [Import("Greet")]
        public List<Action> GreetActions { get; set; }

        public void Execute()
        {
            // 登録されている挨拶を実行！
            foreach (var action in GreetActions)
            {
                action();
            }
        }
    }
}

GreetAppクラスのGreetActionsに登録するメソッドを定義していきます。Greeterクラスを作成して、そこにメソッドを定義してExport(“Greet”)属性をつけています。

public class Greeter
{
    [Export("Greet")]
    public void HelloWorld()
    {
        Console.WriteLine("Hello world");
    }

    [Export("Greet")]
    public void こんにちは世界()
    {
        Console.WriteLine("こんにちは世界");
    }
}

これで実行すると、複数のアクションが登録されて、実行されるのがわかります。

実行結果

Hello world
こんにちは世界

こういう風にして、アプリケーションを何か作る時に、追加処理したいポイントをDelegateのコレクションのプロパティにImport属性をつけたものにしておくと、簡単に拡張できるようになります！！

素敵だ。

[C#][MEF]Managed Extensibility Framework入門その５

kazuki@wankuma.com (かずき) — Thu, 02 Jul 2009 12:45:00 GMT

前回は、プロパティをExportして、それをImportすることをやりました。MEFでは、そのほかに、メソッドをExportすることが出来ます。
このメソッドのExportは、個人的にほかのDIコンテナでは見たことないと感じてる機能なので割りとお気に入りです。

メソッドにExportをつけると、DelegateとしてImportすることが出来ます。
例えば…

public void Foo(string value)
{
}

のようなメソッドにExport属性をつけると

public Action<string> Hoge { get; set; }

こんなプロパティにImportすることが出来ます。

特に難しいことはないと思うので、さくっとサンプルを書いてみようと思います。
MEFExportMethodという名前で、コンソールアプリケーションを作成してSystem.ComponentModel.Composition.dllを参照に追加します。

まずは、Importをするほうのプログラムを書いてみようと思います。

[Export]
public class FooProcess
{
    [Import("FooProcessPreProcess", AllowDefault=true)]
    public Action<string> PreProcess { get; set; }

    public void Execute()
    {
        if (PreProcess != null)
        {
            // 前処理をしてから主処理を実行する
            PreProcess("FooProcess");
        }
        Console.WriteLine("主処理実行！！");
    }
}

PreProcessプロパティにImport属性がついています。FooProcessPreProcessという名前のものをImportするという定義にしました。AllowDefault=trueをつけることで、デフォルト値を許すようにしました。AllowDefaultをつけてないと、無理やりImportしようとして、次に書く予定のMainで例外が発生してしまいます。

次に、Exportのプログラムではなくて、Mainの流れを先に書いて動きを見てみます。
コンテナを作成して、FooProcessのインスタンスを取得してExecuteを呼び出しています。

class Program
{
    static void Main(string[] args)
    {
        // 自身のアセンブリ内のクラスを自動で登録するコンテナを作成
        var catalog = new AssemblyCatalog(typeof(Program).Assembly);
        var container = new CompositionContainer(catalog);

        // FooProcessを取得して処理実行
        var process = container.GetExportedObject<FooProcess>();
        process.Execute();
    }
}

これを実行すると

主処理実行！！

と表示されます。とりあえず何も不思議なことはないはず！

次にメソッドをExportするクラスを書いてみようと思います。

public class CustomPreProcess
{
    [Export("FooProcessPreProcess")]
    public void PrintMessage(string message)
    {
        Console.WriteLine(message);
    }
}

Action<string>型に入れれるように戻り値がvoidで、引数がstring１つのメソッドを定義しています。これにExport属性をつけて、Import側で指定したFooProcessPreProcessという文字列を指定します。

このクラスを追加して実行すると・・・

FooProcess
主処理実行！！

FooProcessが表示されているのがわかると思います。
こうすることで、任意の処理を差し込むポイントを簡単に作りこむことが出来ます。

個人的にこれはお気に入り！

[C#][MEF]Managed Extensibility Framework入門その４

kazuki@wankuma.com (かずき) — Thu, 02 Jul 2009 00:22:00 GMT

[C#][MEF]Managed Extensibility Framework入門その１
 [C#][MEF]Managed Extensibility Framework入門その２
 [C#][MEF]Managed Extensibility Framework入門その３

今回は、ExportAttributeをプロパティにつけたときの動作を見てみようと思います。
今までのExportは、一般的なDIコンテナにありがちな感じで、クラスにつけて他のクラスから使えるようにしていました。

このExport属性は、実はクラスだけではなく、プロパティにつけることもできます。こうすることで、プロパティの戻り値をImportのついているプロパティに設定することが出来ます。

using System;
using System.ComponentModel.Composition;

namespace MEFExportEdu
{
    // メッセージを提供する人
    public class MessageProvider
    {
        // Messageという名前でExport
        [Export("Message")]
        public string GreetMessage
        {
            get
            {
                return "Hello world";
            }
        }
    }

    [Export]
    public class Greeter
    {
        // MessageをImport
        [Import("Message")]
        public string Message { get; set; }

        public void Greet()
        {
            // 結果としてHello worldが表示されます
            Console.WriteLine(Message);
        }
    }

}

そして、確認用のMainを作ります。

using System.ComponentModel.Composition.Hosting;

namespace MEFExportEdu
{
    class Program
    {
        static void Main(string[] args)
        {
            var catalog = new AssemblyCatalog(typeof(Program).Assembly);
            var container = new CompositionContainer(catalog);

            // 実行！
            var g = container.GetExportedObject<Greeter>();
            g.Greet();
        }
    }
}

実行するとHello worldが表示されます。

この例では、とても無駄なような気がしますが、構成ファイルから読み込んだ文字列を、属性を指定するだけでさくっと取得できるようなことも出来そう。

[C#][MEF]Managed Extensibility Framework入門その３

kazuki@wankuma.com (かずき) — Wed, 01 Jul 2009 13:01:00 GMT

[C#][MEF]Managed Extensibility Framework入門その１
 [C#][MEF]Managed Extensibility Framework入門その２

その２で簡単なHello worldを作りました。
その３では、このHello worldをちょっと改良して、めんどくさかったクラスのインスタンスをコンテナに登録する部分と、DIコンテナチックに実装との間に一枚インターフェースを挟むようにしてみようと思います。

適当にコンソールアプリケーションを作成して、System.ComponentModel.Composition.dllを参照に追加します。

まず最初に、クラスのインスタンスを登録する部分を改善しようと思います。コンテナがどういう風にクラスのインスタンスを登録していくかを指定するものとして、～Catalogというものがあります。

その中に、System.ComponentModel.Composition.Hosting.AssemblyCatalogというものがあります。これは、指定したアセンブリの中にあるクラス群を自動で登録してくれるかわいい奴です。

ということでMainを、それをつかってコンテナを作成するように書きます。

using System.ComponentModel.Composition.Hosting;

namespace MEFSample2
{
    class Program
    {
        static void Main(string[] args)
        {
            // アセンブリからクラス登録してね
            var catalog = new AssemblyCatalog(typeof(Program).Assembly);
            // catalogを使用してコンテナを初期化
            var container = new CompositionContainer(catalog);
        }
    }
}

次に、GreeterとGreeterApp(前のエントリではApplicationって書いてたけどうつのがめんどくさくなったので短いAppにしました）を作成します。
各々、IGreeterとIGreetAppインターフェースと、それを実装するGreeterImplとGreetAppImplクラスがあります。

中身は対して変わりませんが、Export属性とかは、実装クラスのほうにつけて、Export属性の引数にインターフェースの型を指定します。
これでコンテナにIGreeterのインスタンス下さいと、問い合わせるとGreeterImplのインスタンスをくれるようになります。

IGreeterインターフェースとGreeterImplクラス

using System.ComponentModel.Composition;

namespace MEFSample2
{
    // 挨拶をする人が実装すべきインターフェース
    public interface IGreeter
    {
        string Greet();
    }

    // IGreeterの実装　IGreeterインターフェースをキーにしてExportする
    [Export(typeof(IGreeter))]
    public class GreeterImpl : IGreeter
    {
        // 単純にHello worldを返す
        public string Greet()
        {
            return "Hello world";
        }
    }
}

IGreetAppインターフェースとGreetAppImplクラス

using System;
using System.ComponentModel.Composition;

namespace MEFSample2
{
    // 挨拶アプリケーションの実装すべきインターフェース
    public interface IGreetApp
    {
        void Run();
    }

    // IGreetAppの実装 IGreetAppをキーにしてExportする
    [Export(typeof(IGreetApp))]
    public class GreetAppImpl : IGreetApp
    {
        // IGreeterをImportする
        [Import]
        public IGreeter Greeter { get; set; }

        public void Run()
        {
            // ちゃんとGreeterにインスタンスが設定されてれば挨拶が表示されるはず
            Console.WriteLine(this.Greeter.Greet());
        }
    }
}

何処にExportとImportがついてるかがポイントです。
さて、最後に、Mainを実装します。コンテナからIGreetAppのインスタンスを取得してRunメソッドを呼び出します。

using System.ComponentModel.Composition.Hosting;

namespace MEFSample2
{
    class Program
    {
        static void Main(string[] args)
        {
            // アセンブリからクラス登録してね
            var catalog = new AssemblyCatalog(typeof(Program).Assembly);
            // catalogを使用してコンテナを初期化
            var container = new CompositionContainer(catalog);

            // 実行！
            var app = container.GetExportedObject<IGreetApp>();
            app.Run();
        }
    }
}

だいぶスッキリしました。

[C#][MEF]Managed Extensibility Framework入門その２

kazuki@wankuma.com (かずき) — Tue, 30 Jun 2009 23:05:00 GMT

[C#][MEF]Managed Extensibility Framework入門その１

ということで、MEF Preview 5を試してみます。
プログラムを始めるときは、何事もHello worldからです！！ということで、MEFでも慣例に沿ってHello worldを作っていこうと思います。

プロジェクトの作成～下準備

ということで、早速コンソールアプリケーションを「MEFHelloWorldApp」という名前で新規作成します。MEF Preview 5を解凍したフォルダの下のbinにあるSystem.ComponentModel.Composition.dllを参照に追加します。

プロジェクトを作成したら、最初に、MEFのコンテナの初期化を行います。
とりあえずソースの上にusing(VBならImports)に

System.ComponentModel.Composition
System.ComponentModel.Composition.Hosting

の２つを追加します。

using System;
using System.ComponentModel.Composition;
using System.ComponentModel.Composition.Hosting;

namespace MEFHelloWorldApp
{
    class Program
    {
        static void Main(string[] args)
        {
        }
    }
}

Imports System.ComponentModel.Composition
Imports System.ComponentModel.Composition.Hosting

Module Module1

    Sub Main()

    End Sub

End Module

そしてMainにコンテナの初期化コードを書いていきます。

// コンテナのインスタンスを生成
var container = new CompositionContainer();
// これにコンテナに登録するクラスを指定する
var batch = new CompositionBatch();
// ここでコンテナに登録するクラスを指定する

container.Compose(batch);

// 好きな処理を書く

' コンテナのインスタンスを生成
Dim container As New CompositionContainer
' これにコンテナに登録するクラスを指定する
Dim batch As New CompositionBatch
' ここでコンテナに登録するクラスを指定する

container.Compose(batch)

' 好きな処理を書く

これで下準備完了です。

Hello worldの作成

ここまでは、どのプログラムでも共通する処理です。ここからついにHello worldを作りこんでいきます。
作るクラスとしては、Hello worldという文字列を返すGreeterと、それを標準出力へ印字するGreetApplicationの2つのクラスを作ります。これは、説明もいらない程簡単なクラスなのでさくっとコードを載せます。

using System;

namespace MEFHelloWorldApp
{
    public class Greeter
    {
        public string Greet()
        {
            return "Hello world";
        }
    }

    public class GreetApplication
    {
        public Greeter Greeter { get; set; }

        public void Run()
        {
            Console.WriteLine(this.Greeter.Greet());
        }
    }
}

Public Class Greeter
    Public Function Greet() As String
        Return "Hello world"
    End Function
End Class

Public Class GreetApplication
    Private _greeter As Greeter
    Public Property Greeter() As Greeter
        Get
            Return _greeter
        End Get
        Set(ByVal value As Greeter)
            _greeter = value
        End Set
    End Property

    Public Sub Run()
        Console.WriteLine(Me.Greeter.Greet())
    End Sub
End Class

ここからMEF固有のことをやります。
まず、今回のアプリケーションの形は、GreetApplicationが、Greeterを使うという形になります。そのため、GreetApplicationではGreeterクラスを取得できないといけません。逆にGreeterクラスは、他のクラスに自分を使ってもらえないといけません。

そういうのを表すために属性を追加します。追加する属性は２つで

System.ComponentModel.Composition.ExportAttribute
自分を外部の人が使えるようにする。
System.ComponentModel.Composition.ImportAttribute
外部の人を取り込む。

です。

ということで、今回はGreeterクラスにExport属性をつけて、GreetApplicationのGreeterプロパティにImport属性をつけます。

using System;
using System.ComponentModel.Composition;

namespace MEFHelloWorldApp
{
    [Export]
    public class Greeter
    {
        public string Greet()
        {
            return "Hello world";
        }
    }

    public class GreetApplication
    {
        [Import]
        public Greeter Greeter { get; set; }

        public void Run()
        {
            Console.WriteLine(this.Greeter.Greet());
        }
    }
}

Imports System.ComponentModel.Composition

<Export()> _
Public Class Greeter
    Public Function Greet() As String
        Return "Hello world"
    End Function
End Class

Public Class GreetApplication
    Private _greeter As Greeter

    <Import()> _
    Public Property Greeter() As Greeter
        Get
            Return _greeter
        End Get
        Set(ByVal value As Greeter)
            _greeter = value
        End Set
    End Property

    Public Sub Run()
        Console.WriteLine(Me.Greeter.Greet())
    End Sub
End Class

コンテナにクラスを登録して使う

粒がそろったので、MEFのコンテナに登録して使ってみようと思います。
CompositionBatchのAddPart(object)メソッドを使ってインスタンスを登録します。

using System;
using System.ComponentModel.Composition;
using System.ComponentModel.Composition.Hosting;

namespace MEFHelloWorldApp
{
    class Program
    {
        static void Main(string[] args)
        {
            // コンテナのインスタンスを生成
            var container = new CompositionContainer();
            // これにコンテナに登録するクラスを指定する
            var batch = new CompositionBatch();
            // ここでコンテナに登録するクラスを指定する

            // GreeterとGreetApplicationを追加する
            batch.AddPart(new Greeter());
            var app = new GreetApplication();
            batch.AddPart(app);

            container.Compose(batch);

            // 好きな処理を書く
            app.Run(); // Hello world!!
        }
    }
}

Imports System.ComponentModel.Composition
Imports System.ComponentModel.Composition.Hosting

Module Module1

    Sub Main()
        ' コンテナのインスタンスを生成
        Dim container As New CompositionContainer
        ' これにコンテナに登録するクラスを指定する
        Dim batch As New CompositionBatch
        ' ここでコンテナに登録するクラスを指定する

        ' GreeterとGreetApplicationを追加する
        batch.AddPart(New Greeter())
        Dim app As New GreetApplication
        batch.AddPart(app)

        container.Compose(batch)

        ' 好きな処理を書く
        app.Run()
    End Sub

End Module

これで、コンテナにGreeterクラスのインスタンスとGreetApplicationクラスのインスタンスを登録してGreetApplicationのRunを実行してます。恐らくcontainer.Compose(batch)の時点で、Export属性やImport属性を見て適切にコンテナが依存性を解決してくれてると思われます。

証拠にこのアプリケーションを実行すると、GreetApplicationのGreeterプロパティに値を設定してるコードが無いにもかかわらず、Hello worldが表示されます。

ということでMEFのHello worldでした。
今回の方法だと、コンテナに登録するインスタンスを全て事前に作っておかないといけないのか！？って感じですけど、ちゃんとフル機能使えば、アセンブリにある属性のついたクラス全部を対象にしたり、フォルダに入ってるアセンブリから読み込んだり夢広がる設計になっています。

ということで、今日はここまで！続きもやるかも・・・？（C#とVB両方用意するの疲れた）

MEF