简要介绍 My.Ioc 的用法

下面这段代码展示了 My.Ioc 的基本用法：

using System;
using System.Collections.Generic;

namespace My.Ioc.Sample
{
    public interface IConcurrency
    {
        int Code { get; }
    }

    public interface IConcurrencyService
    {
        string Name { get; }
        void AddConcurrency(IConcurrency concurrency);
        void RemoveConcurrency(IConcurrency concurrency);
    }

    public class ConcurrencyService : IConcurrencyService
    {
        readonly Dictionary<int, IConcurrency> _concurrencies = new Dictionary<int, IConcurrency>();

        public string Name
        {
            get { return GetType().Name; }
        }

        public void AddConcurrency(IConcurrency concurrency)
        {
            _concurrencies.Add(concurrency.Code, concurrency);
        }

        public void RemoveConcurrency(IConcurrency concurrency)
        {
            _concurrencies.Remove(concurrency.Code);
        }
    }

    public class NewConcurrencyService : IConcurrencyService
    {
        #region IConcurrencyService Members

        public string Name
        {
            get { return GetType().Name; }
        }

        public void AddConcurrency(IConcurrency concurrency)
        {
            throw new NotImplementedException();
        }

        public void RemoveConcurrency(IConcurrency concurrency)
        {
            throw new NotImplementedException();
        }

        #endregion
    }

    public interface ISimpleConsumer
    {
        IConcurrencyService ConcurrencyService { get; }
    }

    public class SimpleConsumer : ISimpleConsumer
    {
        readonly IConcurrencyService _concurrencyService;

        public SimpleConsumer(IConcurrencyService concurrencyService)
        {
            _concurrencyService = concurrencyService;
        }

        public IConcurrencyService ConcurrencyService
        {
            get { return _concurrencyService; }
        }
    }

    public interface IComplexConsumer : IDisposable
    {
        IConcurrencyService ConcurrencyService { get; }
    }

    public class ComplexConsumer : IComplexConsumer
    {
        readonly string _name;
        readonly IConcurrencyService _concurrencyService;

        public ComplexConsumer(string name, IConcurrencyService concurrencyService)
        {
            _name = name;
            _concurrencyService = concurrencyService;
        }

        public IConcurrencyService ConcurrencyService
        {
            get { return _concurrencyService; }
        }

        public string Name
        {
            get { return _name; }
        }

        public string Address { get; set; }

        public void Print()
        {
            Console.WriteLine(_name + " who lives in " + (Address ?? "Fujian") + " is using the service " + _concurrencyService.Name);
        }

        public void Dispose()
        {
            Console.WriteLine("ComplexConsumer is disposing...");
        }
    }

    class Program
    {
        static IObjectRegistration _concurrencyServiceRegistration;
        static IObjectObserver<ISimpleConsumer> _simpleConsumerObserver;

        static void Main(string[] args)
        {
            // First, we need to create an instance of IObjectContainer.
            IObjectContainer container = new ObjectContainer(true);

            // Then, we register some services
            container.Register<IConcurrencyService, ConcurrencyService>()
                .WhenParentTypeIsAny(typeof(SimpleConsumer), typeof(ComplexConsumer))
                .In(Lifetime.Container())
                .Set("ConcurrencyService")
                .Return(out _concurrencyServiceRegistration);

            container.Register<ISimpleConsumer, SimpleConsumer>();

            var consumerName = Parameter.Positional("Johnny.Liu");
            container.Register<IComplexConsumer, ComplexConsumer>()
                .WithConstructor(consumerName)
                .WithPropertyValue("Address", "Fujian")
                .WithMethod("Print")
                .In(Lifetime.Transient());

            // Finally, don't forget to commit the registrations to the registry.
            container.CommitRegistrations();

            // Now you can ask the container to build instances for you.
            var simpleConsumer1 = container.Resolve<ISimpleConsumer>();

            if (!container.TryGetObserver(out _simpleConsumerObserver))
                throw new Exception();
            _simpleConsumerObserver.Changed += OnObjectBuilderChanged;
            var simpleConsumer2 = container.Resolve(_simpleConsumerObserver);

            using (var scope = container.BeginLifetimeScope())
            {
                var complexConsumer = scope.Resolve<IComplexConsumer>();
            }

            // At last, we will unregister the current concurrency service to let the other concurrency 
            // service implementations to have a chance to replace it.
            container.Unregister(_concurrencyServiceRegistration);
            container.Register(typeof(IConcurrencyService), typeof(NewConcurrencyService));
            // As we said, don't forget to commit the registrations to the registry.
            container.CommitRegistrations();

            using (var scope = container.BeginLifetimeScope())
            {
                var complexConsumer = scope.Resolve<IComplexConsumer>();
            }

            Console.ReadLine();
        }

        static void OnObjectBuilderChanged(ObjectBuilderChangedEventArgs args)
        {
            Console.WriteLine(args.ChangeMode);
        }
    }
}

用法比较简单，跟大家熟悉的大多数 Ioc 容器差不多。我们这里来逐句解释一下：

IObjectContainer container = new ObjectContainer(true);

这一句创建了一个 ObjectContainer 对象。构造参数 true 表示容器默认将采用 Emit（动态生成代码）方式来构建对象。

container.Register<IConcurrencyService, ConcurrencyService>()
                .WhenParentTypeIsAny(typeof(SimpleConsumer), typeof(ComplexConsumer))
                .In(Lifetime.Container())
                .Set("ConcurrencyService")
                .Return(out _concurrencyServiceRegistration);

Register 方法将一个 ConcurrencyService 实现绑定到 IConcurrencyService 契约。WhenParentTypeIsAny 方法指定该服务只能用于 SimpleConsumer 或 ComplexConsumer 类。因此，如果您稍后在解析时写上以下这句：

var concurrencyService = container.Resolve<IConcurrencyService>();

则会收到一个 InvalidObjectBuilderException 错误，因为我们在上面的配置中已经指定了 IConcurrencyService 这个服务只能在构造 SimpleConsumer 或 ComplexConsumer 实例时由相应的 ObjectBuilder 向容器请求。

In 方法指定该服务注册项的生命周期，这里使用的是 Container 生命周期，即注册项的生命周期将同容器一样长，而且每次向容器请求该服务时，返回的都是相同的实例。也就是说，这是一个单例对象。Set 方法表明附加一个元数据 ("ConcurrencyService") 到该服务注册项中。Return 方法返回一个 IObjectRegistration 对象。该对象可以作为一个存根，用于在不再需要该服务的时候注销该服务。同时，它也可用于解析服务对象（调用 container.Resolve(IObjectRegistration registration) 方法重载），而不必像调用 container.Resolve(Type contractType) 时一样每次都从注册表中检索服务。

var consumerName = Parameter.Positional("Johnny.Liu");
container.Register<IComplexConsumer, ComplexConsumer>()
    .WithConstructor(consumerName)
    .WithPropertyValue("Address", "Fujian")
    .WithMethod("Print")
    .In(Lifetime.Transient());

上面这句代码指定将 ComplexConsumer 绑定到 IComplexConsumer，同时我们注意到这里还提供了一个默认构造参数。在这里，这个构造参数是必需的，因为 ComplexConsumer 构造函数的签名是：

public ComplexConsumer(string name, IConcurrencyService concurrencyService)

我们看到这个构造函数的第一个参数是 string 类型，在 My.Ioc 中这种类型的参数是不可自动装配的 (non-autowirable)，用户必须为不可自动装配的依赖项提供一个默认值（不可自动装配的类型包括：所有值类型 + string + Type）。

WithPropertyValue 方法和 WithMethod 方法告诉容器，在构建好 ComplexConsumer 对象后，立即将该对象的 Address 属性赋值为“Fujian”，并调用该对象的“Print”方法。

配置（注册）好所有服务之后，此时这些服务并没有添加到注册表，而是被缓存到一个 RegistrationCommitter 中，因此我们需要显式调用下面这句代码将所有注册项提交到注册表中：

container.CommitRegistrations();

经过上面的配置，我们终于可以让容器为我们构建对象实例了。

var simpleConsumer1 = container.Resolve<ISimpleConsumer>();

这句正是向容器请求返回一个实现 ISimpleConsumer 接口的对象。

除了直接向容器请求对象之外，我们还可以向容器请求返回一个 IObjectObserver/IObjectCollectionObserver 对象，并通过该对象来解析服务实例，如下所示：

if (!container.TryGetObserver(out _simpleConsumerObserver))
    throw new Exception();
_simpleConsumerObserver.Changed += OnObjectBuilderChanged;
var simpleConsumer2 = container.Resolve(_simpleConsumerObserver);

这样做的好处是，当该对象 (SimpleConsumer) 依赖的其他子对象（这里是 IConcurrencyService 对象）注册/注销/激活/停用时， Observer 对象将会收到通知（需要订阅该 Observer 对象的 Changed 事件）。此外，IObjectObserver 和 IObjectCollectionObserver 对象与 IObjectRegistration 对象一样，也可以直接用于解析服务对象，而不必每次都向注册表检索服务，从而可以提高性能。

IComplexConsumer 对象的解析与 ISimpleConsumer 有点不一样，我们看下面这段代码：

using (var scope = container.BeginLifetimeScope())
{
    var complexConsumer = scope.Resolve<IComplexConsumer>();
}

这里，我们首先向容器请求获取一个 ILifetimeScope 对象，然后使用该对象来解析 IComplexConsumer 对象。这是因为 IComplexConsumer 实现了 IDisposable 接口，这表明该对象在使用完之后需要清理资源。在 My.Ioc 框架中，解析任何实现了 IDisposable 接口的对象时都需要先申请一个 ILifetimeScope，因为对象资源的清理是通过 ILifetimeScope 来完成的。ILifetimeScope 类似于我们通常所说的“变量作用域”的概念，但它还实现了对象共享的功能，关于这个话题我们还会在以后的文章中加以介绍，这里不再赘言。

使用完毕之后，我们可以将不再需要的服务注册项注销，如下所示：

container.Unregister(_concurrencyServiceRegistration);

运行这句之后，_simpleConsumerObserver 将被停用，而无法再用于解析服务对象，因为其依赖的服务 (IConcurrencyService) 已被注销。同时 OnObjectBuilderChanged 方法也会收到相应通知。不仅 ISimpleConsumer，此时所有直接和间接依赖于 IConcurrencyService 的服务都将被停用，而无法用于解析服务对象。如果我们想要让这些服务再次恢复功能，可以再注册一个实现了 IConcurrencyService 契约的服务并将其注册到容器中，如下代码所示：

container.Register(typeof(IConcurrencyService), typeof(NewConcurrencyService));
container.CommitRegistrations();

这样，那些依赖于 IConcurrencyService 契约的服务都将恢复功能。我们来再次运行下面的代码看一看：

using (var scope = container.BeginLifetimeScope())
{
    var complexConsumer = scope.Resolve<IComplexConsumer>();
}

如无意外，运行上面这段代码，控制台将会输出：

"Johnny.Liu who lives in Fujian is using the service NewConcurrencyService"
"ComplexConsumer is disposing..."

表明我们的新 NewConcurrencyService 服务已取代了原来的 ConcurrencyService 并正常工作，且 ComplexConsumer 对象在超出作用域后已被清理。

总结

上面，我们简单地介绍了 My.Ioc 的使用方法。由于篇幅的缘故，很多问题并未谈及，我们将在以后的文章中逐一向大家介绍。