EntLib

[C#][EntLib]Data Access Application Blockお試し

kazuki@wankuma.com (かずき) — Sun, 09 Nov 2008 14:30:00 GMT

次は、Data Access Application BLockを触ってみようと思う。
ざっとドキュメントを見た感じの印象だと、Data Access Application Block(DAAB)を使うと、DBに依存しないアプリケーションが作りやすくなるよっ！
ADO.NETの素のAPIみたいに煩雑なプログラミングしなくてもよくなるよっ！

ってのがいいみたい。
雑にいっちゃうとADO.NETを、いい感じにラップしてくれているもののようです。

ということで、早速お試し。

プロジェクトの作成

DAABSampleという名前でコンソールアプリケーションを作成する。
そこに、必要な参照を追加する。追加するものは以下の５つ。

Enterprise Library Data Access Application Block
Enterprise Library Shared Library
Microsoft.Practices.ObjectBuilder2
Microsoft.Practices.Unity
System.Configuration

データベースの作成

データベースにアクセスするプログラムを作るので、DBが無いと始まらない。
ということで、Visual StudioのサーバーエクスプローラからSQL ServerのDBを新規作成した。

DB名は、DAABSampleDBにした。

テーブルは、ありきたりな従業員(Employees)テーブルと部署（Departments）テーブルの２つを作ってEmployeesのDepartmentID列とDepartmentsのID列を外部キーで結んだ。
両テーブルの主キー列は、IDENTITYの設定をして自動で番号がふられるようにしておいた。

このテーブルに対して色々やっていこうと思う。

構成ファイルの編集

DBも準備できたので、続いてEnterprise Libraryではお馴染み構成ファイルを組み立てていこうと思う。
App.configをプロジェクトに追加して、右クリックメニューからEdit Enterprise Library Configurationを選択してApp.configを開く。

Data Access Application Blockが何故か自動的に作られているので、そこにあるLocal Sql Serverを選択してプロパティを編集していく。

Local Sql Serverのノードには、Name, ConnectionString, Provider Nameの３つのプロパティがある。
ここを適時設定していく。今回はNameをDAABSample、ConnectionStringを先ほど作ったDBのものに変更する。
ProviderNameは、SQL ServerなのでそのままでOK。

次に、Data Access Application Blockのノードを選択してDefaultDatabaseをDAABSampleに設定する。
こうすることで、プログラム側で名前を指定しない場合に、自動的にDAABSampleが使われるようになる。

設定は基本的に以上で終了。
やったことをまとめると。

App.config追加
Data Access Application BLock/Connection Stringsの下にDBへの接続文字列と名前の設定
Data Access Application BlockのDefaultDatabaseの設定

やることが少なくてよろしい。

ついにプログラミング

下準備が整ったのでプログラミングに入ろうと思う。
Enterprise Library 4.0から、UnityContainerを中心に物事が進むようになっているので、まずUnityContainerのインスタンスを生成する。

そこに、EnterpriseLibraryCoreExtensionとDataAccessBlockExtensionを追加する。この３つを追加することで、さっき作った構成ファイルをもとにコンテナ内にインスタンスの登録などが行われる。

IUnityContainer container = new UnityContainer();
container.AddNewExtension<EnterpriseLibraryCoreExtension>();
container.AddNewExtension<DataAccessBlockExtension>();

次に、Databaseオブジェクトを取得する。
いつもどおりUnityを使うようにResolveメソッドを使うことでインスタンスの取得が出来る。

// Databaseのインスタンスを取得
var database = container.Resolve<Database>();
// 接続文字列等を出力して正しく取得できているか確認
Console.WriteLine(database.ConnectionString);

正しく設定が出来ていれば、先ほど構成ファイルに記述した接続文字列がコンソールに出力される。
ここにDBアクセスする処理を足していこうと思う。

データの登録処理

まだDBのほうに何もデータが入っていないのでINSERT系の処理を書いていく。
とりあえず、データの登録は一度やっちゃえばいいので、privateメソッドに切り出して書いてみた。

// DBにデータを登録する
private static void DoInsert(Database database)
{
    // 部署データを３つ準備
    var depts = new[]
        {
            new { ID = 1, Name = "人事部" },
            new { ID = 2, Name = "総務部" },
            new { ID = 3, Name = "営業部" }
        };

    // 部署データ登録用のDbCommand作成
    DbCommand insertDept = database.GetSqlStringCommand(
        "insert into Departments(ID, Name) values(@ID, @Name)");
    // パラメータの登録
    database.AddInParameter(insertDept, "ID", DbType.Int64);
    database.AddInParameter(insertDept, "Name", DbType.String);

    // データの登録
    foreach (var dept in depts)
    {
        database.SetParameterValue(insertDept, "ID", dept.ID);
        database.SetParameterValue(insertDept, "Name", dept.Name);
        database.ExecuteNonQuery(insertDept);
    }

    // 登録用の従業員データを４つ準備
    var emps = new[]
        {
            new { ID = 1, Name = "田中　太郎", DepartmentID = 1 },
            new { ID = 2, Name = "鈴木　次郎", DepartmentID = 2 },
            new { ID = 3, Name = "丸井　三郎", DepartmentID = 3 },
            new { ID = 4, Name = "木村　四郎", DepartmentID = 3 }
        };

    // 従業員データ登録用のDbCommand作成
    DbCommand insertEmp = database.GetSqlStringCommand(
        "insert into Employees(ID, Name, DepartmentID) values(@ID, @Name, @DepartmentID)");
    // パラメータの登録
    database.AddInParameter(insertEmp, "ID", DbType.Int64);
    database.AddInParameter(insertEmp, "Name", DbType.String);
    database.AddInParameter(insertEmp, "DepartmentID", DbType.Int64);

    foreach (var emp in emps)
    {
        database.SetParameterValue(insertEmp, "ID", emp.ID);
        database.SetParameterValue(insertEmp, "Name", emp.Name);
        database.SetParameterValue(insertEmp, "DepartmentID", emp.DepartmentID);
        database.ExecuteNonQuery(insertEmp);
    }
}

長いけど、これを実行すると下のようなデータがDBに入る。

Departmentsテーブル

ID	Name
1	人事部
2	総務部
3	営業部

Employeesテーブル

ID	Name	DepartmentID
1	田中　太郎	1
2	鈴木　次郎	2
3	丸井　三郎	3
4	木村　四郎	3

更新系のSQLの発行までの流れは以下の通り。

database.GetSqlStringCommandメソッドでDbCommandを作成

DbCommand insertDept = database.GetSqlStringCommand(
     "insert into Departments(ID, Name) values(@ID, @Name)");

database.AddInParameterでパラメータの定義

// パラメータの登録
database.AddInParameter(insertDept, "ID", DbType.Int64);
database.AddInParameter(insertDept, "Name", DbType.String);

database.SetParameterValueでパラメータの値の設定

database.SetParameterValue(insertDept, "ID", dept.ID);
database.SetParameterValue(insertDept, "Name", dept.Name);

database.ExecuteNonQueryでSQL文の実行

database.ExecuteNonQuery(insertDept);

この一連の処理をTransactionScopeで括ってやると、トランザクションもばっちりになる。
しかも、TransactionScopeを使ってると、コネクションを自動でキャッシュしてくれるらしいので、ローカルなトランザクションで済むという素敵なつくりになっているみたいです。

データの検索処理

データの準備が出来たので、検索系の処理のときの例も作ってみる。

// DbCommandを作成してパラメータの設定を行う
DbCommand cmd = database.GetSqlStringCommand(
    "select d.ID, d.Name from Departments d where ID = @ID");
database.AddInParameter(cmd, "ID", DbType.Int64);
database.SetParameterValue(cmd, "ID", 1);

// DataSetを作成して、そこにSQLの結果を読み込む
DataSet ds = new DataSet();
database.LoadDataSet(cmd, ds, "Departments");

// 試しにデータを出力してみる
DataTable deptTable = ds.Tables["Departments"];
Console.WriteLine(deptTable.TableName);
DataRow deptRow = deptTable.Rows[0];
Console.WriteLine("Dept: ID = {0}, Name = {1}", deptRow["ID"], deptRow["Name"]); // -> Dept: ID = 1, Name = 人事部

これも、基本的にDbCommandを作ってパラメータの定義と値を設定する。
そして、Databaseクラスに定義されている、各種読み込みメソッドを使ってデータを読み込む。
今回は、LoadDataSetを使ってDataSetに直接SQLの実行結果を取り込んでいる。

IDataReaderを使う場合はExecuteReaderメソッドを使う。

using(IDataReader r = database.ExecuteReader(cmd))
{
    while (r.Read())
    {
        long id = r.GetInt64(0);
        string name = r.GetString(1);
        Console.WriteLine("Dept: ID = {0}, Name = {1}", id, name);
    }
}

ExecuteReaderの結果のIDataReaderは、きちんとCloseしないといけない。とりあえず、usingで括っておけばOK。

試してみた感想

試してみていいな～と思った部分を列挙してみる。

コネクションを意識しなくてもいい
ADO.NETで直接やるよりコードが少なくなる
TransactionScopeとの相性もよさそうらしい

次に、どうなんだろ？と思った点は

型付きデータセットとの相性は、そこまでよくないかも？
型付きデータセットを普通に作るとTableAdapterまで作られちゃうからそっち使っちゃいそう。
DataSetではない、普通のClassへデータを詰め替えるのがメンドクサイかも？
IDataReaderを使って地道にぐるぐる回すしかなさそう。（ユーテリティクラス作ればいいか）

全体的には、シンプルになっていいな～と思った。

[C#][EntLib]UnityContainerの拡張について

kazuki@wankuma.com (かずき) — Wed, 05 Nov 2008 13:08:00 GMT

さて、UnityContainerの拡張のお話。
UnityContainerExtensionを実装する形で作成するという例をちょっと前に書いた。

今日は、もうちょっと掘り下げてみようと思う。
前回の例では、UnityContainerExtensionのInitializeメソッドでフレームワークで使用するクラス群を登録しちゃえば便利そうだね～と言った。
今回は、それに加えてUnityContainerがクラスのインスタンスを生成する過程に割り込む方法を書いてみようと思う。

UnityContainerExtensionにはContextというプロパティがある。Contextの型はExtensionContextという型で、ここに色々なメソッドやプロパティが定義されている。
その中の１つにStrategiesというプロパティがある。

ここに、Microsoft.Practices.ObjectBuilder2.IBuilderStrategyを実装したクラスをAddメソッドを使って追加することで色々出来るようになる。

IBuilderStrategyインターフェースのメソッドは、以下の４つになる。

PostBuildUp
PostTearDown
PreBuildUp
PreTearDown

この中で、オブジェクトの生成に関わるメソッドは、PreBuildUpとPostBuildUpの２つになる。
～TearDownのほうは、IUnityContainerのTearDownメソッドを呼んでインスタンスを破棄するときに使われるので、今回はとりあえず無視する。

とりあえず、日本語で詳しく書かれた情報が見当たらなかったので適当に実装して動きを見てみるために適当な実装をでっちあげた。

public class MyStragety : IBuilderStrategy
{
    private string stage;
    public MyStragety(string stage)
    {
        this.stage = stage;
    }

    #region IBuilderStrategy メンバ

    public void PostBuildUp(IBuilderContext context)
    {
        Print("PostBuildUp", context);
    }

    public void PostTearDown(IBuilderContext context)
    {
        // no op
    }

    public void PreBuildUp(IBuilderContext context)
    {
        Print("PreBuildUp", context);
    }

    public void PreTearDown(IBuilderContext context)
    {
        // no op
    }

    private void Print(string method, IBuilderContext context)
    {
        Console.WriteLine(stage + ", " + method);
    }

    #endregion
}

これを登録するExtensionも作成する。

public class MyExtension : UnityContainerExtension
{
    protected override void Initialize()
    {
        Context.Strategies.Add(new MyStragety("Creation"), UnityBuildStage.Creation);
        Context.Strategies.Add(new MyStragety("Initialization"), UnityBuildStage.Initialization);
        Context.Strategies.Add(new MyStragety("Lifetime"), UnityBuildStage.Lifetime);
        Context.Strategies.Add(new MyStragety("PostInitialization"), UnityBuildStage.PostInitialization);
        Context.Strategies.Add(new MyStragety("PreCreation"), UnityBuildStage.PreCreation);
        Context.Strategies.Add(new MyStragety("Setup"), UnityBuildStage.Setup);
        Context.Strategies.Add(new MyStragety("TypeMapping"), UnityBuildStage.TypeMapping);
    }
}

さっきは、説明しなかったけどStrategiesのAddメソッドには、Stageと呼ばれるものも一緒に登録する。
これがどういう意味を持つのかわからないので、一応全部登録して動きを見てみることにした。

そして、このExtensionを追加して動きを確認するサンプルを作って動きを見てみた。

public interface IFoo
{
    void Foo();
}
public class FooImpl : IFoo
{
    public void Foo() { Console.WriteLine("Foo"); }
}

class Program
{
    static void Main(string[] args)
    {
        IUnityContainer container = new UnityContainer();
        container.AddNewExtension<MyExtension>();
        container.RegisterType<IFoo, FooImpl>();

        Console.WriteLine("Resolveするよ!!");
        var foo = container.Resolve<IFoo>();
        foo.Foo();

    }
}

これを実行すると、ちょっと長いけど下のような実行結果になった。

Resolveするよ!!
Setup, PreBuildUp
TypeMapping, PreBuildUp
Lifetime, PreBuildUp
PreCreation, PreBuildUp
Creation, PreBuildUp
Initialization, PreBuildUp
PostInitialization, PreBuildUp
PostInitialization, PostBuildUp
Initialization, PostBuildUp
Creation, PostBuildUp
PreCreation, PostBuildUp
Lifetime, PostBuildUp
TypeMapping, PostBuildUp
Setup, PostBuildUp
Foo

Setup, TypeMapping, Lifetime, PreCreation, Creation, Initialization, PostInitializationの順番でPreBuildUpが呼ばれて、今度は逆順にPostBuildUpが呼ばれてるのがわかると思う。
きっと各フェーズで何か処理がされているのだろうけど、ちょっと調べるのは今度にして簡単なサンプルを作ってみた。

サンプルは、IFooインターフェースを実装したクラスを作るときにこっそりインスタンスに細工をするというものにしてみた。

public interface IFoo
{
    void Foo();
}
public class FooImpl : IFoo
{
    public void Foo() { Console.WriteLine("Foo"); }
}

public class FooDecoratorExtension : UnityContainerExtension
{
    protected override void Initialize()
    {
        // 無条件にIFooをデコレートするStrategyを仕込む
        Context.Strategies.Add(
            new FooDecoratorStrategy(),
            UnityBuildStage.Creation);
    }
}

/// <summary>
/// IFooを作成しようとした場合に、無条件にFooDecoratorでデコレートする
/// </summary>
public class FooDecoratorStrategy : IBuilderStrategy
{
    #region IBuilderStrategy メンバ

    public void PostBuildUp(IBuilderContext context)
    {
        // IFooならFooDecoratorでくるむ
        if (context.Existing is IFoo)
        {
            context.Existing = new FooDecorator((IFoo)context.Existing);
        }
    }

    public void PostTearDown(IBuilderContext context)
    {
    }

    public void PreBuildUp(IBuilderContext context)
    {
    }

    public void PreTearDown(IBuilderContext context)
    {
    }

    #endregion
}


/// <summary>
/// IFooを飾り付けるよ
/// </summary>
public class FooDecorator : IFoo
{
    private IFoo org;

    public FooDecorator(IFoo org)
    {
        this.org = org;
    }

    public void Foo()
    {
        Console.WriteLine("デコレート！！");
        org.Foo();
        Console.WriteLine("デコレート！！");
    }
}


class Program
{
    static void Main(string[] args)
    {
        IUnityContainer container = new UnityContainer();
        container.AddNewExtension<FooDecoratorExtension>();
        container.RegisterType<IFoo, FooImpl>();

        Console.WriteLine("Resolveするよ!!");
        var foo = container.Resolve<IFoo>();
        foo.Foo();

    }
}

これを実行すると、以下のような結果になる。

Resolveするよ!!
デコレート！！
Foo
デコレート！！

これは、フレームワークとかで特定の型の場合に何か細工入れ込むとかステキな処理が出来そうだ。

[C#][EntLib]Policy Injection Application Block その３

kazuki@wankuma.com (かずき) — Tue, 04 Nov 2008 01:10:00 GMT

Policy Injection Application Blockを2回試してみた感想は、Unityと相性悪そう。
ということでぐぐってみると、下のスレッドを見つけた。
http://www.codeplex.com/unity/Thread/View.aspx?ThreadId=38040

どうやらPolicy Injection Application Blockの設定をUnityのInterceptionに食わせることが出来るみたい。
早速やってみた。前までのプロジェクトのMainメソッドを下のように書き換えた。

    class Program
    {
        static void Main(string[] args)
        {
            // Targetクラスのインスタンスを作成して
            // var target = PolicyInjection.Create<Target>();
            // 処理を呼び出す
            // target.Greet();

            IUnityContainer container = new UnityContainer();
            container.AddNewExtension<Interception>();
            container.Configure<Interception>().SetInterceptorFor<Target>(new TransparentProxyInterceptor());

            var configSource = ConfigurationSourceFactory.Create();
            var settings = (PolicyInjectionSettings)configSource.GetSection(PolicyInjectionSettings.SectionName);
            settings.ConfigureContainer(container, configSource);

            var target = container.Resolve<Target>();
            target.Greet();
        }
    }

実行結果は、今までのと同じなので省略。
ちゃんと動いているけど、SetInterceptorForを型ごとに設定しないといけないのはUnityのInterceptionなので仕方ないのだろうか…。
MatchingRuleにマッチする奴は、自動的にTransparentProxyInterceptorを適用するとか出来ないのかな？

[C#][EntLib]Policy Injection Application Blockお試しその２

kazuki@wankuma.com (かずき) — Tue, 04 Nov 2008 00:48:00 GMT

1つ前の記事で、メソッド呼び出しの前後にログを挟み込むPIABの使い方を試してみた。
今回は、あり合わせのHandlerじゃなくて、独自のHandlerを作ってみようと思う。

前回のプロジェクトにクラスライブラリのプロジェクトを１つ追加する。
名前はMyHandlersにした。

MyHandlersプロジェクトに以下の参照を追加する。

Enterprise Library Policy Injection Application Block
Enterprise Library Shared Library
Microsoft.Practices.Unity
Microsoft.Practices.Unity.InterceptionExtension
Microsoft.Practices.ObjectBuilder2
System.Configuration

Unity関連の3つの参照は、PIABSampleAppのほうにも追加しておく。

PIABのカスタムハンドラをここに作成していく。カスタムハンドラになるためには、最低限以下の条件を満たしてないといけないみたい。

Microsoft.Practices.Unity.InterceptionExtension.ICallHandlerを実装する
[ConfigurationElementType(typeof(CustomCallHandlerData))]属性がついている
NameValueCollectionを受け取るコンストラクタがある

ということで実装開始。とりあえず、メソッド呼び出しの前後に標準出力にメッセージをだすようにしてみた。

using System;
using System.Collections.Specialized;
using Microsoft.Practices.EnterpriseLibrary.Common.Configuration;
using Microsoft.Practices.EnterpriseLibrary.PolicyInjection.Configuration;
using Microsoft.Practices.Unity.InterceptionExtension;

namespace MyHandlers
{
    [ConfigurationElementType(typeof(CustomCallHandlerData))]
    public class MyHandler : ICallHandler
    {
        // このコンストラクタ必須！
        public MyHandler(NameValueCollection attributes) { }

        public IMethodReturn Invoke(IMethodInvocation input, GetNextHandlerDelegate getNext)
        {
            // 本来の処理の呼び出しの前後に、クラス名とメソッド名を出力する
            var name = input.Target.GetType() + "." + input.MethodBase.Name;
            Console.WriteLine("Before: " + name);
            try
            {
                return getNext().Invoke(input, getNext);
            }
            finally
            {
                Console.WriteLine("After: " + name);
            }
        }
        public int Order { get; set; }
    }
}

PIABSampleAppの参照に、今作成したMyHandlersを追加する。そして、App.configを以下のように構成する。

前のサンプルで作っていたLogging Handlerを削除して、かわりにCustom Handlerを追加する。

Custom HandlerのTypeにMyHandlers.MyHandlerを設定する。
Typeプロパティの横のボタンを押して、Handlerを選択するためのダイアログを表示する。そして、MyHandlers.dllを開く。そうするとMyHandlerが選択できるので選択してOKをクリックする。

TypeにMyHandlerが設定される。

これで、実行すると下のような実行結果になる。自作のHandlerが効いてるのがわかると思う。

実行結果
Before: PIABSampleApp.Target.Greet
Target.Greet Called.
After: PIABSampleApp.Target.Greet

[C#][EntLib]Policy Injection Application Blockお試し

kazuki@wankuma.com (かずき) — Tue, 04 Nov 2008 00:07:00 GMT

Enterprice Library 4.1も出たということで、触ってみてる。
まだ、LoggingとUnityくらいしか触れてない。

次は、UnityのInterceptionとかぶってるような気がするPolicy Injection Application Blockにチャレンジしてみる。
こいつは、説明を見る感じだとAOPみたいなことを実現するものらしい。裏側ではProxyクラスを作って、処理の呼び出しの際に間に処理を挟みこむといった感じになってるようだ。

とりあえず、入門用としてメソッドの呼び出しの前後にログ出力を挟み込むようなサンプルを作ってみようとおもう　。

プロジェクト作成

PIABSampleAppという名前でコンソールアプリケーションを作成する。そこに、以下の４つの参照を追加する。

Enterprise Library Shared Library
Enterprise Library Policy Injection Application Block
Enterprise Library Logging Application Block
Enterprise Library Handlers for Policy Injection Application Block

次に、処理を挟み込まれるターゲットのクラスを作成する。複雑なものにしてもしょうがないのでシンプルな感じにしてみた。

public class Target : MarshalByRefObject
{
    public void Greet()
    {
        Console.WriteLine("Target.Greet Called.");
    }
}

PIABで処理を挟み込むクラスは、とりあえずMarshalByRefObjectを継承して作るらしい。
ほかにもインターフェースを実装するとかあるみたいだけど、とりあえず一番無難そうなMarshalByRefObjectにしてみたよ。

次にMainを書いていく。Mainでは、PolicyInjectionというクラスを使ってTargetクラスのインスタンスを作ってGreetを呼び出している。

class Program
{
    static void Main(string[] args)
    {
        // Targetクラスのインスタンスを作成して
        var target = PolicyInjection.Create<Target>();
        // 処理を呼び出す
        target.Greet();
    }
}

これが基本形みたい。実行結果は、まだ何も設定してないので「Target.Greet Called.」が表示されるだけ。
ここにプログラムをいじらずに処理を足しこんでみようと思う。

まず、ログ出力をするのでLogging Application Blockの構成を行う。前やったのを参考に構成ファイルをぽちぽち組み立てる。

今回は、超シンプルにコンソールにログを吐くだけの構成にした。そのためSystem.Diagnostics TraceListenerを作って、TypeにSystem.Diagnostics.ConsoleTraceListenerを設定した。
そして、All Eventsに、そのTraceListenerを追加する。

これで、すべてのログがコンソールに出るっていう寸法だ。確認のためMainを下のようにいじって実行結果を確認してみる。

class Program
{
    static void Main(string[] args)
    {
        // Targetクラスのインスタンスを作成して
        var target = PolicyInjection.Create<Target>();
        // 処理を呼び出す
        target.Greet();

        // Logging Application Blockのテスト
        Logger.Write("Hello world");
    }
}

実行結果
Target.Greet Called.
All Events Information: 1 : Timestamp: 2008/11/03 14:46:50
Message: Hello world
Category: General
Priority: -1
EventId: 1
Severity: Information
Title:
Machine: KAZUKI-PC
App Domain: PIABSampleApp.exe
ProcessId: 4152
Process Name: C:\Users\Kazuki\Documents\Visual Studio 2008\Projects\PIABSampleAp
p\PIABSampleApp\bin\Debug\PIABSampleApp.exe
Thread Name:
Win32 ThreadId:2400
Extended Properties:

Logging Application Blockの構成が正しいのがわかったので、テスト用に追加したコードは消しておく。
次に本命のPolicy Injection Application Blockの構成に入る。

Policy Injection Application Blockのセクションを追加。

Policyを追加

MatchingRuleを追加。今回は、特定の型に対して処理を挟み込みたいのでType Matching Ruleを使う。

Type Matching RuleのMatchesプロパティにPIABSampleApp.Targetを追加する。

HandlersにLogging handlerを追加する。

Logging HandlerのAfterMessageとBeforeMessageに適当な文字列を設定する。

これで、App.configを保存してアプリケーションを再実行するとログがメソッド呼び出しの前後に入っているのがわかると思う。実行結果は、長いので省略して下に示します。

実行結果
All Events Information: 0 : Timestamp: 2008/11/03 14:54:21
Message: 前処理
// 省略
Target.Greet Called.
All Events Information: 0 : Timestamp: 2008/11/03 14:54:22
Message: 後処理
// 省略

こんな感じに、構成ファイルから任意のクラスのメソッドの呼び出しの前後に処理を挟み込むことが出来る。
MatchingRuleを変えることで、処理を挟み込む対象を変えたり、Handlerを変えることで挟み込む処理を変えることが出来るようになっている。

[C#][EntLib]Logging Application Block その２タイムスタンプをローカルの日時にしよう

kazuki@wankuma.com (かずき) — Sun, 02 Nov 2008 10:38:00 GMT

Logging Application Blockで、デフォルトのまま使ってるとタイムスタンプがUTCになっている。
FormatterのTemplateに

Timestamp: {timestamp}

と書いてある部分がそれにあたる。
俺はグローバルな人じゃなくて日本人なんだぜ？って理由で日本時間でログを記載して欲しい場合は、この部分を下のように書き換えるといいみたい。

Timestamp: {timestamp(local)}

めもめも。

[WPF][C#][EntLib]UnityでAOP

kazuki@wankuma.com (かずき) — Sun, 02 Nov 2008 02:01:00 GMT

Enterprise Library 4.1が出てた。
気になるのは、お気に入りのUnityContainerです。バージョンが1.2になるらしい。
その中でも、Policy Application Blockみたいな動きをするInterceptionというのが気になったのでつっついてみた。

AOPといえばロギング！！ということで、ロギングを例にしてみようと思う。まずは、土台作りから。
いつものに、ちょっぴり足したPersonクラスを作る。

namespace UnityEducation.Entities
{
    /// <summary>
    /// 挨拶できるよ
    /// </summary>
    public interface IGreeter
    {
        /// <summary>
        /// 挨拶を返すよ
        /// </summary>
        /// <returns>挨拶の文字列</returns>
        string Greet();
    }

    /// <summary>
    /// いつもの人間クラス
    /// </summary>
    public class Person : IGreeter
    {
        /// <summary>
        /// 名前あるよ
        /// </summary>
        public string Name { get; set; }

        /// <summary>
        /// 挨拶するよ
        /// </summary>
        /// <returns>名前入りの挨拶！</returns>
        public string Greet()
        {
            return string.Format("{0}です！こんにちは！", Name);
        }
    }
}

このGreetメソッドにログを仕込むのが最終目標になる。
続いてMainメソッドで、単純にUnityContainerにPersonを登録して使うところの処理を書く。

とりあえず、UnityContainerとInterceptionを使うのでObjectBuilder2とUnityとUnity.InterceptionExtensionをプロジェクトの参照に追加する。

そしてMainメソッドに処理を書いていく。

using System;
using Microsoft.Practices.Unity;
using UnityEducation.Entities;

namespace UnityEducation
{
    class Program
    {
        static void Main(string[] args)
        {
            IUnityContainer c = new UnityContainer();

            // インスタンスをコンテナに登録
            c.RegisterInstance<IGreeter>(new Person { Name = "大田" });

            // インスタンスをコンテナから取得して挨拶文を表示
            var ohta = c.Resolve<IGreeter>();
            Console.WriteLine(ohta.Greet());
        }
    }
}

これを実行すると、下のようになる。

やっと土台が完成。これに処理を挟み込んでみようと思う。処理を挟み込むためには、２つのクラスを作らないといけない。

HandlerAttributeを継承した属性
メソッドとハンドラを結びつけるための目印
ICallHandlerを継承したクラス
挟み込む処理

まずは属性から。

    /// <summary>
    /// ログを出力するためのAttribute
    /// </summary>
    public class LoggingAttribute : HandlerAttribute
    {
        /// <summary>
        /// 挟み込む処理を返す
        /// </summary>
        public override ICallHandler CreateHandler(IUnityContainer container)
        {
            return new LoggingHandler();
        }
    }

これは、CreateHandlerメソッドをオーバーライドするだけでOK。返すものは、この後作るハンドラです。
ということで、ハンドラを作成する。

/// <summary>
/// ログを出力するハンドラ
/// </summary>
public class LoggingHandler : ICallHandler
{
    public IMethodReturn Invoke(IMethodInvocation input, GetNextHandlerDelegate getNext)
    {
        Console.WriteLine("処理開始");
        try
        {
            // 処理を呼ぶ
            return getNext().Invoke(input, getNext);
        }
        finally
        {
            Console.WriteLine("処理終了");
        }
    }

    public int Order { get; set; }
}

ICallHandlerを継承して、Invokeメソッドを実装するだけでOK。最初と最後に処理の開始と終了のメッセージを出すようにしてみた。
実際のGreetメソッドの処理は、getNextデリゲートを呼ぶことで取得できる、getNext()の戻り値に対してInvokeメソッドを呼ぶと本来走る処理が実行される。（同じメソッドに複数のHandlerをセットしてたら別のHandlerの処理が呼ばれる）

そして、PersonクラスのGreetメソッドにLoggingAttributeをセットする。

/// <summary>
/// いつもの人間クラス
/// </summary>
public class Person : IGreeter
{
    /// <summary>
    /// 名前あるよ
    /// </summary>
    public string Name { get; set; }

    /// <summary>
    /// 挨拶するよ
    /// </summary>
    /// <returns>名前入りの挨拶！</returns>
    [Logging] // ログの処理を入れるよ
    public string Greet()
    {
        return string.Format("{0}です！こんにちは！", Name);
    }
}

最後にUnityContainerに対してInterceptionを使うということを示すコードを追加する。

    class Program
    {
        static void Main(string[] args)
        {
            IUnityContainer c = new UnityContainer();

            // Interceptionの拡張を追加
            c.AddNewExtension<Interception>();

            // Interceptionの設定
            c.Configure<Interception>().
                // IGreeterにはTransparentProxyInterceptorを使います
                SetInterceptorFor<IGreeter>(new TransparentProxyInterceptor());

            // インスタンスをコンテナに登録
            c.RegisterInstance<IGreeter>(new Person { Name = "大田" });

            // インスタンスをコンテナから取得して挨拶文を表示
            var ohta = c.Resolve<IGreeter>();
            Console.WriteLine(ohta.Greet());
        }
    }

これを実行すると、さっきまでの挨拶一行以外に、処理開始と処理終了も出力されるようになる。
いい感じだ。

参考：http://www.pnpguidance.net/Screencast/UnityInterceptionExtensionRemotingPolicyInjectorScreencastUnityTutorials.aspx

[EntLib][C#]IUnityContainerを拡張してしまおうぜ

kazuki@wankuma.com (かずき) — Thu, 31 Jul 2008 23:17:00 GMT

Unityは、結構お気に入りになりそうな感じなんだけど、あまりいじれてない。UnityContainerは、UnityContainerExtensionというものを使って簡単に拡張？出来るようになっている。

ということで、早速やってみた。

下準備として、IUnityContainerに登録するクラス群を定義する。とりあえず単純な足し算引き算を行うクラスを作った。

    interface ICalc
    {
        int Execute(int lhs, int rhs);
    }
    class AddCalc : ICalc
    {
        public int Execute(int lhs, int rhs)
        {
            return lhs + rhs;
        }
    }
    class MinusCalc : ICalc
    {
        public int Execute(int lhs, int rhs)
        {
            return lhs - rhs;
        }
    }

計算というものをICalcとしてインターフェースにしてみたよ。まぁ、サンプルなんでこんなもんで。次に、UnityContainerExtensionを継承したクラスを定義する。Initializeというメソッドをオーバーライドすることになるので、ここにコンテナの初期化処理を書く。今回は、AddUnityContainerExtensionとMinusUnityContainerExtensionを定義した。
上で作ったICalcやAddCalc,MinusCalcをUnityContainerに追加するためのクラスとして使える。

    // 計算といえば足し算用でしょ拡張
    class AddUnityContainerExtension : UnityContainerExtension
    {
        protected override void Initialize()
        {
            Container.RegisterType<ICalc, AddCalc>();
        }
    }

    // 計算といえば引き算でしょ拡張
    class MinusUnityContainerExtension : UnityContainerExtension
    {
        protected override void Initialize()
        {
            Container.RegisterType<ICalc, MinusCalc>();
        }
    }

UnityContainerExtensionにはContainerというプロパティが定義されているので、Containerプロパティを通じてUnityContainerにアクセスしている。ここで作ったUnityContainerExtensionは、AddNewExtensionメソッドを使ってUnityContainerに設定できるようになっている。

要は、各々のExtensionを追加することで、関連のあるものをUnityContainerに一括で登録できてしまうといったものみたいだ。早速作ったものを使ってみようと思う。

その前に、ICalcを使うクラスを定義してみた。

class CalcClient
{
    [Dependency]
    public ICalc Calc { get; set; }

    public void Execute()
    {
        Console.WriteLine(Calc.Execute(10, 3));
    }
}

計算して出力するだけ！シンプル。

長かったけど、やっとUnityContainerを使うよ！といってもコードは数行…

// コンテナを作って
var c = new UnityContainer();
// 足し算の計算用に拡張？して
c.AddNewExtension<AddUnityContainerExtension>();

// CalcClientをコンテナ経由で取得
c.RegisterType<CalcClient, CalcClient>();
var client = c.Resolve<CalcClient>();
client.Execute(); // -> 13

これを実行すると、10 + 3なので13と表示される。AddNewExtensionの部分をMinusUnityContainerExtensionに変更すると7 と表示される。

// コンテナを作って
var c = new UnityContainer();
// 引き算の計算用に拡張？して
c.AddNewExtension<MinusUnityContainerExtension>();

// CalcClientをコンテナ経由で取得
c.RegisterType<CalcClient, CalcClient>();
var client = c.Resolve<CalcClient>();
client.Execute(); // -> 7

今回のサンプルでは、一種類しかクラスを登録していなかったからありがたみは無いかもしれないけど、たとえばフレームワーク等で、関連のあるクラス群を一気に登録してしまおうというときにいいかもしれない。

[C#][EntLib]Logging Application Block その１「とりあえず使ってみよう」

kazuki@wankuma.com (かずき) — Tue, 22 Jul 2008 22:39:00 GMT

Unityが、いい感じのDIコンテナっぽい。
ということで、ほかのApplication Blockもぼちぼちいじってみようと思う。どれから使おうか悩んだけど、一番手軽に使えそうなものとして、Logging Application Blockを選んでみた。
EntLib4.0のLoggingの情報をWebで探してみたけど、簡単に探した範囲内だと、見つけきらなかったので泣く泣く英語のドキュメントを見ながられっつトライ！！

とりあえず、お試しのためにConsole Applicationのプロジェクトを１つ追加する。名前はLoggingTestにした。ここに、色々追加していってファイルにログを出力するようにしてみようと思う。

参照の追加

Enterprise Library Application Block
Enterprise Library Shared Library
Microsoft.Practices.ObjectBuilder2

この３つを参照に追加する。

App.configの編集

App.configにLogging Application Blockの設定を追加する。
log4netしかりs2.netしかり、こういうのは一番メンドクサイところでもある。俺様フレームワークでも、きっとApp.configにごにょごにょして…という感じに作ってしまいそう（というか、それが正当だしね）だ。しかし、EnterpriseLibraryでは、専用の編集ツールがついてきているので、めんどくささはあまり感じない。
GUIでの編集万歳！ということでぽちぽちします。

新規作成でアプリケーション構成ファイル（App.config）を追加する。
ソリューションエクスプローラで、App.configの右クリックメニューからEdit Enterprise Library Configurationを選ぶ
Logging Application Blockを追加する
Trace ListenersにFlat File Trace Listenerを追加する
FlatFile TraceListenerのプロパティを編集する。
保存するファイル名は、デフォルトでtrace.logになっているので、そのまま利用する。
Formatterプロパティには、Logging Application Blockを追加したときに作られているText Formatterを指定する。
Special SourcesのAll EventsにTraceListener Referenceを追加する。
TraceListener ReferenceのReferencedTraceListenerに、４で作ったFlatFile TraceListenerを設定する。
保存してApp.configを閉じる

これで、Logging Application BlockのAPIを使ってログを出力すると問答無用でtrace.logに出力されるようになるはず。
個人的な理解としては

～Listenerでどこに出力するか決める
～Formatterで、どういう書式で出力するか決める
～Sourcesで、どういう時に、どのListenerを使うか決める
～Filter（今回はつかってない）で、出力するログをフィルタリングする

くらいだと思ってる。TOEIC285点の英語力でなんとなく思ったことなので間違ってる可能性が非常に高いので、間違ってたら誰か指摘していただきたい。

APIを使ってログを出力する

ついに楽しいプログラミング！！
Program.csにHello worldというログを出力するプログラムを書いていく。といってもとっても簡単。説明をする前にプログラムをさくっと乗せてみる。

using Microsoft.Practices.EnterpriseLibrary.Logging;

namespace LoggingTest
{
    class Program
    {
        static void Main(string[] args)
        {
            // メッセージがHello worldのログエントリ
            var logEntry = new LogEntry
            {
                Message = "Hello world"
            };

            // ログエントリを出力
            Logger.Write(logEntry);
        }
    }
}

これを実行すると、exeと同じフォルダにtrace.logというファイルが出来上がる。内容は下のような感じ。

----------------------------------------
Timestamp: 2008/07/20 2:15:16
Message: Hello world
Category: General
Priority: -1
EventId: 0
Severity: Information
Title:
Machine: KAZUKI-PC2
Application Domain: LoggingTest.exe
Process Id: 5748
Process Name: C:\Users\Kazuki\Documents\Visual Studio 2008\Projects\LoggingTest\LoggingTest\bin\Debug\LoggingTest.exe
Win32 Thread Id: 1144
Thread Name:
Extended Properties:
----------------------------------------

Messageに、プログラムから指定したHello worldの文字列があるのがわかる。ここに列挙されているProirityやEventIdなんかも、LogEntryのプロパティとして用意されているので、プログラム上から指定すれば任意の値を設定することが出来るようになってる。

例えば、Titleを指定してログを出力する場合は下のようになる。

var logEntry = new LogEntry
{
    Title = "たいとる",
    Message = "Hello world"
};

このLogEntryを出力すると、下のようなログがファイルに保存される。

----------------------------------------
Timestamp: 2008/07/20 2:28:20
Message: Hello world
Category: General
Priority: -1
EventId: 0
Severity: Information
Title:たいとる
Machine: KAZUKI-PC2
Application Domain: LoggingTest.exe
Process Id: 4872
Process Name: C:\Users\Kazuki\Documents\Visual Studio 2008\Projects\LoggingTest\LoggingTest\bin\Debug\LoggingTest.exe
Win32 Thread Id: 4756
Thread Name:
Extended Properties:
----------------------------------------