Ninject之旅之三：Ninject對象生命周期

摘要

DI容器的一個責任是管理他創建的對象的生命周期。他應該決定什么時候創建一個給定類型的對象，什么時候使用已經存在的對象。他還需要在對象不需要的時候處理對象。Ninject在不同的情況下管理對象的生命周期提供了強大的支持。在我們定義一個綁定的時候，定義創建對象的范圍。在那個范圍內，對象將被重用，每次綁定只存在一次。注意，對象不允許依賴於生命周期短自己小的對象。

1、暫時范圍

在暫時態范圍內，對象生命周期不被Ninject進行管理。任何時候請求一個類型的對象，都將創建一新對象。Ninject不管理保持創建的對象或者在范圍內處理他。這是Ninject默認的范圍。如果不指定范圍，默認是暫時態。在上一篇文章里，ConsoleLogger和MailServer對象都是暫時態，因為沒有指定他的范圍。

2、單例范圍

有時候我們不想每次需要的時候都創建一個新的對象，這時候使用單例。有兩種方法創建單例。一種是使用單例模式。一種是使用Ninject方法InSingletonScope。
1）使用單例模式：

class ConsoleLogger:ILogger
{
    public static readonly ConsoleLogger Instance = new ConsoleLogger();
    private static ConsoleLogger()
    {
        // Hiding constructor
    }
    public void Log(string message)
    {
        Console.WriteLine("{0}: {1}", DateTime.Now, message);
    }
}

然后在Bind方法后調用ToConstant方法指定靜態只讀對象ConsoleLogger.Instance為常量對象。

kernel.Bind<ILogger>().ToConstant(ConsoleLogger.Instance);

2）使用方法InSingletonScope：

kernel.Bind<ILogger>().To<ConsoleLogger>().InSingletonScope();

如果要給MailServerConfig類對象設置單例，則先調用ToSelf方法將他綁定自身，然后再調用方法InSingletonScope。

kernel.Bind<MailServerConfig>().ToSelf().InSingletonScope();

3、線程范圍

如果定義在線程范圍內，每一個線程將只創建一個給定類型的對象。對象的生命周期跟對象所在的線程一樣長。

調用方法InThreadScope創建線程范圍：

kernel.Bind<object>().ToSelf().InThreadScope();

創建兩個Test方法測試線程范圍。

using Ninject;
using NUnit.Framework;
using System.Threading;

namespace Demo.Ninject
{
    [TestFixture]
    class NinjectTest
    {
        [Test]
        public void ReturnsTheSameInstancesInOneThread()
        {
            using (var kernel = new StandardKernel())
            {
                kernel.Bind<object>().ToSelf().InThreadScope();
                var instance1 = kernel.Get<object>();
                var instance2 = kernel.Get<object>();
                Assert.AreEqual(instance1, instance2);
            }
        }

        [Test]
        public void ReturnsDifferentInstancesInDifferentThreads()
        {
            var kernel = new StandardKernel();
            kernel.Bind<object>().ToSelf().InThreadScope();
            var instance1 = kernel.Get<object>();
            new Thread(() =>
            {
                var instance2 = kernel.Get<object>();
                Assert.AreNotEqual(instance1, instance2);
                kernel.Dispose();
            }).Start();
        }
    }
}

第一個方法在同一個線程內請求了兩個object對象，他們是相同的實例。第二個方法先在主線程內請求一個object實例，然后開啟另一個線程請求另一個實例，他們不是相同的實例。

需要添加NUnit和NUnit.Console才能測試上面的方法。我使用的是NUnit 2.6.4和NUnit.Console 2.0.0。

4、請求范圍

請求范圍在web應用程序里非常有用。可以在相同的請求范圍內得到一個單例的對象。一旦一個請求被處理，另一個請求到來，Ninject創建新的對象實例，並保持他直到請求結束。

調用方法InRequestScope設置請求范圍，例如：

kernel.Bind<MailServerConfig>().ToSelf().InRequestScope();

需要添加Ninject.Web.Common引用才能夠調用InRequestScope方法。

5、自定義范圍

自定義范圍讓我們定義我們自己的范圍，在這個范圍內保持一類型的唯一對象。只要提供的回調方法返回的對象引用是一樣的，Ninject在這個范圍內返回相同的實例。只要返回的對象引用變了，將創建一新的指定類型的對象。創建的對象實例將一直保存在緩存里，直到返回的范圍對象被垃圾回收器回收。一旦范圍對象被垃圾回收器回收，Ninject創建的所有的對象實例將被從緩存中釋放和處理。

調用InScope方法傳入Lamda表達式定義自定義返回。例如：

kernel.Bind<object>().ToSelf().InScope(ctx => User.Current);

用例子來介紹自定義范圍：

1）創建User類。

    class User
    {
        public string Name { get; set; }
        public static User Current { get; set; }
    }

2）創建函數ReturnsTheSameInstancesForAUser。

        [Test]
        public void ReturnsTheSameInstancesForAUser()
        {
            using (var kernel = new StandardKernel())
            {
                kernel.Bind<object>().ToSelf().InScope(ctx => User.Current);
                User.Current = new User();
                var instance1 = kernel.Get<object>();
                User.Current.Name = "Foo";
                var instance2 = kernel.Get<object>();
                Assert.AreEqual(instance1, instance2);
            }
        }

雖然User.Current.Name的值變了，但是User.Current的引用沒變。因此，兩次請求返回的對象是同一個對象。

3）創建函數ReturnsDifferentInstancesForDifferentUsers。

        [Test]
        public void ReturnsDifferentInstancesForDifferentUsers()
        {
            using (var kernel = new StandardKernel())
            {
                kernel.Bind<object>().ToSelf().InScope(ctx => User.Current);
                User.Current = new User();
                var instance1 = kernel.Get<object>();
                User.Current = new User();
                var instance2 = kernel.Get<object>();
                Assert.AreNotEqual(instance1, instance2);
            }
        }

因為改變了User.Current對象引用，因此，兩次請求返回的對象是不同的對象。

你可能注意到了回調函數提供了一個名字是ctx的IContext參數。這個對象提供了綁定的用來創建范圍對象的上下文環境。自定義范圍是最靈活最有用的范圍。其實其他范圍都可以用自定義范圍來實現。

線程范圍：

kernel.Bind<object>().ToSelf().InScope(ctx=>Thread.CurrentThread);

請求范圍：

kernel.Bind<object>().ToSelf().InScope(ctx=>HttpContext.Current);

可以使用Release方法強制釋放創建的對象實例。

var myObject = kernel.Get<MyService>();
..
kernel.Release(myObject);