NopCommerce使用Autofac实现依赖注入

NopCommerce使用Autofac实现依赖注入

文章内容：

• 什么是依赖注入
• NopCommerce网站中使用Autofac

---

什么是依赖注入

 依赖注入也叫"控制反转（IOC）"，目的在于将组件的配置与使用分离开来。

举个简单的例子：我饿了，要叫外卖吃，我只要打开APP，选好吃的，然后付钱，等着外卖到了就可以吃了。至于外卖员怎么送外卖，是步行送还是骑车送, 是走什么路线，这些我不需要知道，也无法知道。

我们从代码来看，理解起来会更清晰一点
首先，我给送餐定义了一个接口ITakeout：

//送餐接口,SendFood送餐的方法定义
 public interface ITakeout
 {
    string SendFood()
 }

然后，订餐的实现类：

  public class OnlineOrdering
    {
        private ITakeout _takeoutService;
        public string Ordering()
        {
            APP订餐付款();
            //调用_takeoutService的SendFood方法获得食物food, _takeoutService的具体实现类我是不知道的。  
            string food = _takeoutService.SendFood();
            return food;
        }
    }

在上面的例子中，虽然我知道有送餐这个过程，但是我并不知道它的具体实现方式，所以我不能new一个实例给_takeoutService属性。退一步讲，就算我知道一个类TakeoutByFoot实现了这个接口，于是我将它赋值给 _takeoutService, 将构造函数改为如下代码：

public OnlineOrdering()
{
    this._takeoutService=new TakeoutByFoot();
}

这样做的问题是，如果明天换了个外卖员，他是骑车送餐的，后天又换了一个，他是开车送的。那我不是要频繁的更改OnlineOrdering类。这就造成了耦合。

依赖注入的好处在于我只要定义一个送餐的接口,然后就可以使用它，至于接口的实现类是什么我不需要知道，因为IOC框架会自动为接口赋值。将OnlineOrdering构造方法改为：

  public OnlineOrdering(ITakeout takeoutService)
  {
     this._takeoutService = takeoutService;
  }

这样IOC框架就可以用构造子注入的方式，为 _takeoutService 添加具体实现类。至于是实现那个类，这个可以交给配置来做。如何配置这个后面会讲。这就是”使用”与 “配置”分离。

有人会说为什么不直接在外部给 _takeoutService 属性赋值，那样的话 _takeoutService 属性就必须是public ，可我并不想将这个属性暴露给外部。另外，如果ITakeout实现类中还定义了其他引用型属性，我就必须一层层赋值，这不是理想的方式。

NopCommerce网站中使用Autofac

官方网站地址
NopCommerce的官方网站，可以下载源码，详见[http://www.nopcommerce.com/][1].
Autofac的官方网站，详见[http://autofac.org/][1].

NopCommerce是国外的一个高质量的开源b2c网站系统。该网站使用了名为Autofac的依赖注入框架。Autofac的使用方法这里就不做介绍了，可以去官网上看，我只是简单分析一下NopCommerce是如何使用Autofac框架的。（本人水平有限，这只是我自己的理解，如果有不对的地方，欢迎指正）

代码在Nop.Core.Infrastructure和Nop.Core.Infrastructure.DependencyManagement命名空间。主要分为两个模块：

ContainerManager 的功能有：管理依赖注入的容器，实例化服务。
Engine 的功能有：管理ContainerManager， 实例化服务，在程序启动时注册各种服务。
另外还有一些工具模块，这里只简单说明。具体实现可以看代码：

模块	作用
TypeFinder	通过反射，找到某个Type的类，子类或实现类
Singleton	用于存储单例
Config	系统设置

首先，来看ContainerManager 类，部分代码：

    public class ContainerManager
    {
        private readonly IContainer _container;

        public ContainerManager(IContainer container)
        {
            this._container = container;
        }

        public virtual IContainer Container
        {
            get
            {
                return this._container;
            }
        }

        //........各种Resolve方法，略

   }

ContainerManager 中有个只读属性IContainer _container这是依赖注入容器，我们注册的服务都有保存到 _container中，同时实例化服务也是从 _container中获取。它相当于一个仓库。ContainerManager 通过在构造函数中传入IContainer 的实例，为 _container赋值。同时，ContainerManager 也提供了Resolve方法，为在 _container中注册的服务提供实例。

再来看下Engion模块，Engion模块定义了一个接口IEngine，该接口的实现类NopEngine，以及用来保存NopEngine单例的EngineContext。
IEngine定义如下：

 public interface IEngine
    {
        ContainerManager ContainerManager { get; }

        void Initialize(NopConfig config);

        T Resolve<T>() where T : class;

        object Resolve(Type type);

        T[] ResolveAll<T>();
    }

很清楚看到，IEngion有个ContainerManager 类型的属性,通过这个属性我们可以获得IContainer ， 看一下NopEngine的代码就会发现ContainerManager 是在执行Initialize方法的时候赋值的。IEngion还提供了Resolve方法，其实就是调用ContainerManager 的Resolve方法,向外界提供服务。

IEngion的实现类NopEngine：

  public class NopEngine : IEngine
    {
        private ContainerManager _containerManager;

        protected virtual void RegisterDependencies(NopConfig config)
        {
            // ①
            var builder = new ContainerBuilder();
            var container = builder.Build();
            this._containerManager = new ContainerManager(container);

            //dependencies WebAppTypeFinder是ITypeFinder的实现类，属于TypeFinder 模块。暂时知道它是干什么的就行了。
            var typeFinder = new WebAppTypeFinder();
            //因为ContainerBuilder只能Build()或Update()一次，所以要新建一个
            builder = new ContainerBuilder();
            // ②
            builder.RegisterInstance(this).As<IEngine>().SingleInstance();
            builder.RegisterInstance(typeFinder).As<ITypeFinder>().SingleInstance();
            builder.Update(container);

            //register dependencies provided by other assemblies ③
            builder = new ContainerBuilder();
            var drTypes = typeFinder.FindClassesOfType<IDependencyRegistrar>();
            var drInstances = new List<IDependencyRegistrar>();
            foreach (var drType in drTypes)
                drInstances.Add((IDependencyRegistrar) Activator.CreateInstance(drType));
            //sort
            drInstances = drInstances.AsQueryable().OrderBy(t => t.Order).ToList();
            foreach (var dependencyRegistrar in drInstances)
                dependencyRegistrar.Register(builder, typeFinder, config);
            builder.Update(container);

            //set dependency resolver ④
            DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
        }

        public void Initialize(NopConfig config)
        {
            //register dependencies
            RegisterDependencies(config);
            //.......执行启动任务,与依赖注入无关,略
        }

        //.............Resolve方法，略

        public ContainerManager ContainerManager
        {
            get { return _containerManager; }
        }
    }

以上代码我只截取了比较重要的部分，NopEngine类的重点在Initialize方法，该方法调用了RegisterDependencies方法，从方法名可以知道用来注册依赖项（服务）。

详细过程如下：

① build 了一个IContainer 容器，然后用该容器初始化ContainerManager ，以后注册的服务都将保存在这个容器中。由于NopEngine是单例，所以IContainer 容器也只有一个。

②将自己注册为一个单例，TypeFinder 模块也注册一个单例。注意builder.Update(container)这句一定要加，它用来将注册的服务保存到容器中去。

③首先来看这句代码var drTypes = typeFinder.FindClassesOfType<IDependencyRegistrar>(); 这句的意思是找出所有IDependencyRegistrar接口的实现类。IDependencyRegistrar的定义如下：

    public interface IDependencyRegistrar
    {
        void Register(ContainerBuilder builder, ITypeFinder typeFinder, NopConfig config);
        int Order { get; }
    }

然后再看这两句代码：

1.foreach (var drType in drTypes)
   drInstances.Add((IDependencyRegistrar) Activator.CreateInstance(drType));
2.foreach (var dependencyRegistrar in drInstances)
   dependencyRegistrar.Register(builder, typeFinder, config);
  builder.Update(container);

1表示实例化所有IDependencyRegistrar实现类，2表示执行IDependencyRegistrar实现类的Register方法，并且将builder作为参数传进去。然后将builder更新到container容器中。
这步操作有什么用呢？ 举例一个IDependencyRegistrar的实现类：

    public class DependencyRegistrar : IDependencyRegistrar
    {
        public void Register(ContainerBuilder builder, ITypeFinder finder ,FLOWConfig config)
        {
            builder.RegisterType<TakeoutByFoot>().As<ITakeout>().InstancePerLifetimeScope();
        }

        public int Order
        {
            get { return 1; }
        }
    }

DependencyRegistrar 可以通过Register方法注册自己需要的服务。这样做的好处是，不同的服务使用者可以定义自己的IDependencyRegistrar实现类，然后注册自己需要的服务，这样服务使用起来非常方便，更换服务也很快捷。而服务提供者，我只要提供一个接口给使用者，至于使用者如何配置，我可以不用考虑。拿开始的例子说就是，外卖员如何送餐由他自己选择，而不是我来选择一个骑摩托的外卖员。

④set dependency resolver

NopEngine理解了以后，剩下就很好理解了。EngionContext提供了NopEngine的单例，代码如下：

 public class EngineContext
    {
        #region Methods
        [MethodImpl(MethodImplOptions.Synchronized)]
        public static IEngine Initialize(bool forceRecreate)
        {
            if (Singleton<IEngine>.Instance == null || forceRecreate)
            {
                Singleton<IEngine>.Instance = new NopEngine();

                var config = ConfigurationManager.GetSection("NopConfig") as NopConfig;
                Singleton<IEngine>.Instance.Initialize(config);
            }
            return Singleton<IEngine>.Instance;
        }

        public static void Replace(IEngine engine)
        {
            Singleton<IEngine>.Instance = engine;
        }
        #endregion

        #region Properties
        public static IEngine Current
        {
            get
            {
                if (Singleton<IEngine>.Instance == null)
                {
                    Initialize(false);
                }
                return Singleton<IEngine>.Instance;
            }
        }
        #endregion
    }

可以看出，Singleton.Instance保存了IEngine的单例，Current用来获取IEngine单例。Initialize方法在IEngine单例为空或强制Recreate的情况下，初始化IEngine引擎。Singleton<IEngine>.Instance.Initialize(config); 这句代码表示IEngine引擎初始化，在初始化过程中，会注册服务。

最后，在程序启动时初始化IEngine引擎就会自动注册服务了：

  protected void Application_Start()
  {
        ........
        //initialize engine context
        EngineContext.Initialize(false);
        .......
  }

---