EntLib

Unity を使って WCF で AOP する

なかむら — Thu, 12 Nov 2009 07:06:00 GMT

はじめに

先日、Unity で AOP を使う方法を紹介しました。

Unity を使って AOP

なかむら — Tue, 10 Nov 2009 06:28:00 GMT

かな～り前に、Enterprise Library の Policy Injection Application Block の機能が Unity に統合された、という記事を書きました。

EntLib4.1 での PIAB 仕様変更 (2)

なかむら — Thu, 04 Dec 2008 09:46:00 GMT

はじめに

先日に引き続き Policy Injection Application Block (以下 PIAB) の変更点を調べました。

変更点

EntLib4.1 では、メソッドのインターセプトを Unity がやってくれるようになりました。 PIAB は Unity の機能を利用するだけです。

Unity を使ったメソッドのインターセプト方法

Microsoft.Practices.Unity.Interception を参照に追加し、例えば下記のようなコードを書けばＯＫです。

// DI コンテナを生成する。
IUnityContainer container = new UnityContainer();

// DI コンテナのインスタンス生成パイプラインを拡張する。
// インスタンスをラップしてメソッドをインターセプト可能にする処理が追加される。
container.AddNewExtension<Interception>();

// DI コンテナから取得するインスタンスをインターセプトする方法を指定。
container.Configure<Interception>()
         .SetInterceptorFor<IAnimal>(new TransparentProxyInterceptor());

// 型を登録する。
container.RegisterType<IAnimal, Wankuma>("Wankuma");

// コンテナから取得した animal オブジェクトの、
// Cry メソッドはインターセプトされる。
var animal = container.Resolve<IAnimal>("Wankuma");
animal.Cry();

最後に

Unity だけでアスペクト指向プログラミングが可能になっています。 PIAB の存在意義が・・・(;^_^A

EntLib4.1 での PIAB 仕様変更

なかむら — Tue, 02 Dec 2008 09:13:00 GMT

一部のクラスやインタフェースが無くなっていました

Microsoft.Practices.EnterpriseLibrary.PolicyInjection.ICallHandler
Microsoft.Practices.EnterpriseLibrary.PolicyInjection.IMethodInvocation
Microsoft.Practices.EnterpriseLibrary.PolicyInjection.IMethodReturn
Microsoft.Practices.EnterpriseLibrary.PolicyInjection.GetNextHandlerDelegate
Microsoft.Practices.EnterpriseLibrary.PolicyInjection.HandlerAttribute

でも代わりが用意されています

Microsoft.Practices.Unity.InterceptionExtension.ICallHandler
Microsoft.Practices.Unity.InterceptionExtension.IMethodInvocation
Microsoft.Practices.Unity.InterceptionExtension.IMethodReturn
Microsoft.Practices.Unity.InterceptionExtension.GetNextHandlerDelegate
Microsoft.Practices.Unity.InterceptionExtension.HandlerAttribute

HandlerAttributeのインタフェースも変更されていました

CreateHandler メソッドが引数を受け取るようになっています。

public class EventLogCallHandlerAttribute : HandlerAttribute
{
    public override ICallHandler CreateHandler(IUnityContainer container)
    {
        return new EventLogCallHandler();
    }
}

このコードは「PIABで属性を使ってインターセプト対象メソッドを指定する」で作成した EvetnLogCallHandler を EntLib4.1 に対応させたものです。

まだまだ変更がありそう

もっと調べてみます。

Unity の LifetimeManager

なかむら — Mon, 01 Dec 2008 09:33:00 GMT

UnityContainer に型を登録するとき

container.RegisterType<IAnimal, Wankuma>(lifetimeManager);

という風に LifetimeManager も一緒に指定できます。 UnityContainer を使って生成したインスタンスの生存期間は、一緒に登録した LifetimeManager が管理してます。

Unity が提供する LifetimeManager

表にしてみました。

種類	説明
ContainerControlledLifetimeManager	LifetimeManagerが破棄されるときにインスタンスも破棄します。それまで１つのインスタンスを使い回します。
ExternallyControlledLifetimeManager	インスタンスの管理に WeakReference を使用しています。
PerThreadLifetimeManager	スレッド内で１つのインスタンスを使い回します。
TransientLifetimeManager	毎回新しいインスタンスを生成します。

例えば

毎回新しいインスタンスを生成して欲しい場合、 TransientLifetimeManager を指定すればいいですね。

Unity と PIAB を連携させる

なかむら — Fri, 21 Nov 2008 09:54:00 GMT

はじめに

Unity と Policy Injection Application Block (以下 PIAB) と連携させてみました。

カスタム Callhandler とカスタム HandlerAttribute

[ConfigurationElementType(typeof(CustomCallHandlerData))]
public class EventLogCallHandler : ICallHandler
{
    public int Order { get; set; }

    public EventLogCallHandler(NameValueCollection attributes)
    {
        // このコンストラクタは必須みたい
    }

    private const string SOURCE = "PIABSample";

    public IMethodReturn Invoke(IMethodInvocation input, GetNextHandlerDelegate getNext)
    {
        // メソッド呼び出し前にログを出力
        EventLog.WriteEntry(SOURCE,
            string.Format("{0} メソッドを呼び出します。", input.MethodBase.Name),
            EventLogEntryType.Information);

        // メソッド呼び出し
        IMethodReturn result = getNext()(input, getNext);

        // メソッド呼び出し後にログを出力
        if (result.Exception != null)
        {
            // 例外が発生したとき
            EventLog.WriteEntry(SOURCE,
            string.Format("{0} メソッド呼び出しで例外が発生しました。", input.MethodBase.Name),
            EventLogEntryType.Error);
        }
        else
        {
            EventLog.WriteEntry(SOURCE,
            string.Format("{0} メソッドを呼び出しました。", input.MethodBase.Name),
            EventLogEntryType.Information);
        }

        return result;
    }
}

public class EventLogCallHandlerAttribute : HandlerAttribute
{
    public override ICallHandler CreateHandler()
    {
        return new EventLogCallHandler();
    }
}

『PIAB で属性を使ってインターセプト対象メソッドを指定する』のエントリで作成したものを流用します。

DI で使用するインタフェースとクラスを用意

public interface IAnimal
{
    // Cry メソッド呼び出し時にイベントログを出力する
    [EventLogCallHandler]
    void Cry();
}

public class Wankuma : IAnimal
{
    public void Cry()
    {
        Console.WriteLine("クマ～");
    }
}

public class Person
{
    [Dependency]
    public IAnimal Pet { get; set; }

    public void CallPet()
    {
        Pet.Cry();
    }
}

毎度おなじみのインタフェースとクラスです^^;

PIAB と Unity を連携させるために UnityContainerExtension を作成

ここからが本番。

public class EventLogExtension : UnityContainerExtension
{
    protected override void Initialize()
    {
        // ここで登録した PolicyIjectionPolicy は次に登録する
        // PolicyInjectionStrategy で使われます。
        Context.Policies.SetDefault<IPolicyInjectionPolicy>(new PolicyInjectionPolicy(true));
        
        // Unity がインスタンスを生成するパイプラインの PreCreation ステージで、
        // PolicyInjectionStrategy の処理が実行されるように登録します。
        Context.Strategies.AddNew<PolicyInjectionStrategy>(UnityBuildStage.PreCreation);
    }
}

PolicyInjectionStrategy は登録した PolicyInjectionPolicy を使って、Unity が生成したインスタンスに PIAB のポリシーを適用します。つまり RealProxy の派生クラスでラップする。この辺りは『PIABの中身を見てみた』のエントリを見て下さい。

Strategies や Policies がどう利用されるのかについては、後でエントリにする予定です。

作成した UnityContainerExtension を使ったコードに修正

static void Main(string[] args)
{
    // DI コンテナ取得
    UnityContainer container = new UnityContainer();

    // DI コンテナを拡張
    container.AddNewExtension<EventLogExtension>();

    // 型を登録
    container.RegisterType<IAnimal, Wankuma>();

    // インスタンスを取得
    Person person = container.Resolve<Person>();

    // ペットを呼び出す
    person.CallPet();

    Console.ReadLine();
}

作成した EventLogExtension を使って、UnityContainer を拡張しています。

このコードを実行すると、CallPet メソッド内で Cry メソッドが呼ばれる前後にイベントログが出力されます。

まとめ

Unity と PIAB の連携は、UnityContainer のインスタンス生成処理のパイプラインに、ポリシーを適用する処理を組み込むための UnityContainerExtension を作成することで実現可能です。

PIAB の中身を見てみた

なかむら — Thu, 20 Nov 2008 11:30:00 GMT

はじめに

「使っているものの仕組みをしれ！」みたいな教えを以前受けた気がするので、 Policy Injection Application Block のソースコードを読んでみました。

先日のエントリ『PIABで属性を使ってインターセプト対象メソッドを指定する』で作成したサンプルの

var animal = PolicyInjection.Create<Wankuma>();

の部分で何をやっているのかを、ざっと追っていきます。

PolicyInjection クラス

Create メソッド

public static class PolicyInjection
{
    private static volatile PolicyInjector defaultPolicyInjector;
    private static readonly object singletonLock = new object();

    public static TObject Create<TObject>(params object[] args)
    {
        return DefaultPolicyInjector.Create<TObject>(args);
    }

デフォルトの PolicyInjector を取得して、Create メソッドを呼んでいます。

DefaultPolicyInjector プロパティ

private static PolicyInjector DefaultPolicyInjector
{
    get
    {
        if( defaultPolicyInjector == null)
        {
            lock(singletonLock)
            {
                if(defaultPolicyInjector == null)
                {
                    IConfigurationSource configurationSource =
                        ConfigurationSourceFactory.Create();
                    defaultPolicyInjector = GetInjectorFromConfig(configurationSource);
                }
            }
        }
        return defaultPolicyInjector;
    }
}

private static PolicyInjector GetInjectorFromConfig(IConfigurationSource configurationSource)
{
    PolicyInjectorFactory injectorFactory = new PolicyInjectorFactory(configurationSource);
    return injectorFactory.Create();
}

構成ファイルの内容を PolicyInjectorFactory に渡し、Create メソッドで PolicyInjector を生成してます。初めてこのプロパティを使うときに、1回だけ生成されるみたいですね。

PolicyInjectorFactory クラス

Create メソッド

public class PolicyInjectorFactory
{
    public PolicyInjector Create()
    {
        return EnterpriseLibraryFactory.BuildUp<PolicyInjector>(configurationSource);
    }

EnterpriseLibraryFactory は内部で ObjectBuilder を使って PolicyInjector を生成しています。

PolicyInjector クラス

Create メソッド

[CustomFactory(typeof(PolicyInjectorCustomFactory))]
public abstract class PolicyInjector
{
    public object Create(Type typeToCreate, Type typeToReturn, params object[] args)
    {
        // 構成ファイルや属性をチェックして、型に適用するポリシーを取り出す
        PolicySet policiesForThisType = policies.GetPoliciesFor(typeToCreate);

        // インターセプト可能かどうかチェックする。
        // インターセプト出来ない場合は ArgumentException を発生させる。
        EnsureTypeIsInterceptable(typeToReturn, policiesForThisType);

        return DoCreate(typeToCreate, typeToReturn, policiesForThisType, args);
    }

インターセプト可能かどうかの判断基準は「ポリシーが指定されているか」「MarshalByRefObject を継承しているか」など。PolicyInjector の実装によって異なります。あと、実際にインスタンスを生成しているのは DoCreate メソッド。

DoCreate メソッド

protected virtual object DoCreate(Type typeToCreate, Type typeToReturn, PolicySet policiesForThisType, object[] arguments)
{
    object target = Activator.CreateInstance(typeToCreate, arguments);
    return DoWrap(target, typeToReturn, policiesForThisType);
}

リフレクションを使ってインスタンスを生成したあと、DoWrap メソッド呼んでいますね。 DoWrap メソッドは abstract なので、今回は RemotingPolicyInjector クラスの DoWrap を見てみる。

RemotingPolicyInjector クラス

DoWrap メソッド

[ConfigurationElementType(typeof(RemotingInjectorData))]
public class RemotingPolicyInjector : PolicyInjector
{
    protected override object DoWrap(object instance, Type typeToReturn, PolicySet policiesForThisType)
    {
        if (PolicyRequiresInterception(policiesForThisType))
        {
            // instance が既に RealProxy でラップされている場合は、ラップを解いて渡す。
            // ラップされていない場合はそのまま渡す。
            InterceptingRealProxy proxy =
                new InterceptingRealProxy(UnwrapTarget(instance), typeToReturn, policiesForThisType);
            return proxy.GetTransparentProxy();
        }
        return instance;
    }

InterceptingReadProxy は RealProxy を継承したクラスです。透過プロキシを返しているのかぁ。

InterceptingReadProxy クラス

コンストラクタ

public InterceptingRealProxy(object target, Type classToProxy, PolicySet policies)
    : base(classToProxy)
{
    this.target = target;
    this.typeName = target.GetType().FullName;
    Type targetType = target.GetType();

    memberHandlers = new Dictionary<MethodBase, HandlerPipeline>();

　　// クラスの情報から CallHandler を取得して memberHandlers に追加します
    AddHandlersForType(targetType, policies);

    // ここではベースクラスから
    Type baseTypeIter = targetType.BaseType;
    while (baseTypeIter != null && baseTypeIter != typeof(object))
    {
        AddHandlersForType(baseTypeIter, policies);
        baseTypeIter = baseTypeIter.BaseType;
    }

    foreach (Type inter in targetType.GetInterfaces())
    {
        // クラスとインタフェースをマッピングしたあと、
        // クラスのメソッド情報をもとに取得した CallHandler を
        // インタフェースのメソッド用の CallHandler として再登録している
        AddHandlersForInterface(targetType, inter);
    }        
}

コンストラクタ内でクラスの情報をもとに CallHandler を取得して、メンバに保存しています。

Create の流れはここで終了。でもせっかくなので、メソッドが実際にインターセプトされる処理も見てみます。

Invoke メソッド

public class InterceptingRealProxy : RealProxy, IRemotingTypeInfo
{
    public override IMessage Invoke(IMessage msg)
    {
        IMethodCallMessage callMessage = (IMethodCallMessage)msg;

        // メソッドをインターセプトして実行する CallHandler を取得する
        HandlerPipeline pipeline;
        if (memberHandlers.ContainsKey(callMessage.MethodBase))
        {
            pipeline = memberHandlers[callMessage.MethodBase];
        }
        else
        {
            pipeline = new HandlerPipeline();
        }

        RemotingMethodInvocation invocation = new RemotingMethodInvocation(callMessage, target);
        IMethodReturn result =
            pipeline.Invoke(
                invocation,
                delegate(IMethodInvocation input, GetNextHandlerDelegate getNext)
                {
                    try
                    {
                        // インターセプト対象のメソッドを実行
                        object returnValue = callMessage.MethodBase.Invoke(target, invocation.Arguments);
                        return input.CreateMethodReturn(returnValue, invocation.Arguments);
                    }
                    catch (TargetInvocationException ex)
                    {
                        // The outer exception will always be a reflection exception; we want the inner, which is
                        // the underlying exception.
                        return input.CreateExceptionMethodReturn(ex.InnerException);
                    }
                });
        return ((RemotingMethodReturn)result).ToMethodReturnMessage();
    }

インターセプト対象メソッドの情報をもとに HandlerPipeline を取得して、その Invoke メソッドを呼び出しているのか。インターセプトされたメソッドは、リフレクション(MethodBase.Invoke)で呼び出しています。

HandlerPipeline クラス

Invoke メソッド

public class HandlerPipeline
{
    private List<ICallHandler> handlers;

    public IMethodReturn Invoke(IMethodInvocation input, InvokeHandlerDelegate target)
    {
        if( handlers.Count == 0 )
        {
            return target(input, null);
        }

        int handlerIndex = 0;

        // メソッドをインターセプトして実行する処理を、連鎖して呼び出す
        IMethodReturn result = handlers[0].Invoke(input, delegate
                                  {
                                      ++handlerIndex;
                                      if(handlerIndex < handlers.Count)
                                      {
                                          return handlers[handlerIndex].Invoke;
                                      }
                                      else
                                      {
                                          return target;
                                      }
                                  });
        return result;
    }

構成ファイルなどで指定した CallHander がこのクラスに登録されています。先に登録されているハンドラを呼び出して、最後にインターセプト対象のメソッドが呼ばれる・・・と。

最後に

PIAB では RealProxy を使って AOP を実現しているのか！

PIABで属性を使ってインターセプト対象メソッドを指定する

なかむら — Tue, 18 Nov 2008 16:47:00 GMT

はじめに

以前書いた Policy Injection Application Block のサンプルは構成ファイルでインターセプトするメソッドを指定していました。インターセプトするメソッドは属性でも指定可能なので、今回はその方法を試してみました。

カスタム CallHandler を作成

[ConfigurationElementType(typeof(CustomCallHandlerData))]
public class EventLogCallHandler : ICallHandler
{
    public int Order { get; set; }

    public EventLogCallHandler(NameValueCollection attributes)
    {
        // このコンストラクタは必須みたい
    }

    private const string SOURCE = "PIABSample";

    public IMethodReturn Invoke(IMethodInvocation input, GetNextHandlerDelegate getNext)
    {
        // メソッド呼び出し前にログを出力
        EventLog.WriteEntry(SOURCE,
            string.Format("{0} メソッドを呼び出します。", input.MethodBase.Name),
            EventLogEntryType.Information);

        // メソッド呼び出し
        IMethodReturn result = getNext()(input, getNext);

        // メソッド呼び出し後にログを出力
        if (result.Exception != null)
        {
            // 例外が発生したとき
            EventLog.WriteEntry(SOURCE,
            string.Format("{0} メソッド呼び出しで例外が発生しました。", input.MethodBase.Name),
            EventLogEntryType.Error);
        }
        else
        {
            EventLog.WriteEntry(SOURCE,
            string.Format("{0} メソッドを呼び出しました。", input.MethodBase.Name),
            EventLogEntryType.Information);
        }

        return result;
    }
}

前に作成したものをそのまま流用。

カスタム HandlerAttribute を作成

public class EventLogCallHandlerAttribute : HandlerAttribute
{
    public override ICallHandler CreateHandler()
    {
        return new EventLogCallHandler();
    }
}

EventLogCallHandler クラスのインスタンスを生成して返しているだけ。

インターセプト対象のメソッドを持つクラスを作成

public class Wankuma : MarshalByRefObject
{
    // 作成した属性を付与
    [EventLogCallHandler]
    public void Cry()
    {
        Console.WriteLine("クマ～");
    }
}

作成した EventLogCallHandlerAttribute をCry メソッドに付与しています。構成ファイルでメソッドを指定する必要はありません。

これで PolicyInjection.Create メソッドで生成した Wankuma インスタンスの、 Cry メソッドが呼び出される前と後にイベントログが出力されます。

まとめ

インターセプトするメソッドの指定は、構成ファイルを記述するよりも、属性を使った方が遥かに楽ですね。ちなみに、PIAB には既にロギングや検証など数種類の CallHandler と HandlerAttribute が用意されています。今回のサンプルで取り上げたロギングは、自作せずに用意されているクラスを使うのも良いでしょう。

Policy Injection Application Block を使ってロギング処理を分離する

なかむら — Wed, 12 Nov 2008 00:42:00 GMT

いきなりですが

簡単なサンプルを。

class Program
{
    static void Main(string[] args)
    {
        var animal = new Wankuma();

        animal.Cry();

        Console.ReadLine();
    }
}

public class Wankuma
{
    public void Cry()
    {
        Console.WriteLine("クマ～");
    }
}

これを実行すると

と表示されます。

呼び出されたメソッドをログに残したい！

私が携わったプロジェクトでは、業務アプリではログを出力する場面がほとんどでした。でもログを出力するコードで汚されるのは嫌…。

そこで Policy Injection Application Block の出番

Policy Injection Application Block (以下 PIAB)はアスペクト指向によるソフトウェア開発を可能にするアプリケーションブロックです。PIAB を使う事で、ビジネスロジックなどの本来的な機能から、ロギングや例外処理などの横断的な機能を分離し、外部から注入することができるようになります。

さっそく試してみます！

参照するアセンブリを追加

次の2つを追加します。

Microsoft.Practices.EnterpriseLibrary.Common
Microsoft.Practices.EnterpriseLibrary.PolicyInjection

CustomCallHandler を作成

[ConfigurationElementType(typeof(CustomCallHandlerData))]
public class EventLogCallHandler : ICallHandler
{
    public int Order { get; set; }

    public EventLogCallHandler(NameValueCollection attributes)
    {
        // このコンストラクタは必須みたい
    }

    private const string SOURCE = "PIABSample";

    public IMethodReturn Invoke(IMethodInvocation input, GetNextHandlerDelegate getNext)
    {
        // メソッド呼び出し前にログを出力
        EventLog.WriteEntry(SOURCE,
            string.Format("{0} メソッドを呼び出します。", input.MethodBase.Name),
            EventLogEntryType.Information);

        // メソッド呼び出し
        IMethodReturn result = getNext()(input, getNext);

        // メソッド呼び出し後にログを出力
        if (result.Exception != null)
        {
            // 例外が発生したとき
            EventLog.WriteEntry(SOURCE,
            string.Format("{0} メソッド呼び出しで例外が発生しました。", input.MethodBase.Name),
            EventLogEntryType.Error);
        }
        else
        {
            EventLog.WriteEntry(SOURCE,
            string.Format("{0} メソッドを呼び出しました。", input.MethodBase.Name),
            EventLogEntryType.Information);
        }

        return result;
    }
}

イベントログにメソッド名を出力します。

冒頭のサンプルを書き変えます

class Program
{
    static void Main(string[] args)
    {
        // PolicyInjection クラスを使って生成
        var animal = PolicyInjection.Create<Wankuma>();

        animal.Cry();

        Console.ReadLine();
    }
}

// MarshalByRefObject から派生させる
public class Wankuma : MarshalByRefObject
{
    public void Cry()
    {
        Console.WriteLine("クマ～");
    }
}

最後に構成ファイルを記述

<?xml version="1.0" encoding="utf-8"?>
<configuration>
    <configSections>
        <section name="policyInjection" type="Microsoft.Practices.EnterpriseLibrary.PolicyInjection.Configuration.PolicyInjectionSettings, Microsoft.Practices.EnterpriseLibrary.PolicyInjection, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />
        <section name="dataConfiguration" type="Microsoft.Practices.EnterpriseLibrary.Data.Configuration.DatabaseSettings, Microsoft.Practices.EnterpriseLibrary.Data, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />
    </configSections>
    <policyInjection>
        <policies>
            <add name="Policy">
                <matchingRules>

                    <!--Cry メソッドをインターセプトする-->
                    <add match="Cry" ignoreCase="false" type="Microsoft.Practices.EnterpriseLibrary.PolicyInjection.MatchingRules.MethodSignatureMatchingRule, Microsoft.Practices.EnterpriseLibrary.PolicyInjection, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
                      name="Method Signature Matching Rule" />

                </matchingRules>
                <handlers>

                    <!--自作の Callhandler を指定-->
                    <add order="0" type="PIABSample.EventLogCallHandler, PIABSample, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"
                      name="Custom Handler" />

                </handlers>
            </add>
        </policies>
    </policyInjection>
</configuration>

Cry メソッドをインターセプトして、前後でログを出力します。

実行結果

メソッド呼び出し前と後の、２つのログが出力されています。

まとめ

見ての通り、横断的な機能（ここではロギング）が本来的な機能（鳴き声出力）から分離されているため、スッキリしたコードになりました。

UnityContainer を拡張する

なかむら — Tue, 04 Nov 2008 11:40:00 GMT

はじめに

UnityContainer を拡張するために UnityContainerExtension クラスが用意されています。このクラスを継承して独自の Extension を作れば、UnityContainer の挙動を拡張できます。

例として、先日のサンプルを書き換えてみます。

独自の Extension を作成

public class AnimalExtension : UnityContainerExtension
{
    protected override void Initialize()
    {
        // 動物クラスを複数まとめて登録する
        Container.RegisterType<IAnimal, Dog>("Dog");
        Container.RegisterType<IAnimal, Cat>("Cat");
        Container.RegisterType<IAnimal, Wankuma>("Wankuma");
    }
}

Container だけでなく、Policies や Strategies にもアクセスできます。 Policies や Strategies は後日調べる予定。

作成した Extension を UnityContainer に登録する

static void Main(string[] args)
{
    // DI コンテナ生成
    IUnityContainer container = new UnityContainer();

    // Extension を登録
    container.AddNewExtension<AnimalExtension>();

    // 依存性注入済みのインスタンスを生成
    Person person = container.Resolve<Person>();

    person.CallPet();
}

もちろん構成ファイルで Extension を指定可能

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <configSections>
        <section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection,Microsoft.Practices.Unity.Configuration,Version=1.1.0.0,Culture=neutral,PublicKeyToken=31bf3856ad364e35"/>
    </configSections>
    <unity>
        <containers>
            <container name="Sample">
                <extensions>
                    <add type="ExtensionSample.AnimalExtension, ExtensionSample"/>
                </extensions>
            </container>
        </containers>
    </unity>
</configuration>

まとめ

自社フレームワークなんかに UnityContainer を採用するなら、まとめて型を登録できるように Extension を用意した方が良さそうです。 Enterprise Library の各 Application Block も、構成ファイルの内容を元に型を登録する Extension を提供していますしね。