Autofac 简单应用

在面向对象程序设计中，封装、继承、多态是面向的三个基本特征，设计模式的应用是对面向对象思想的一种体现，在设计模式中的几大设计原则中有个原则叫依赖倒转（置）原则（DIP），其思想强调的是“抽象不应依赖于细节，细节应依赖于抽象”，即要多面向接口编程而非具体实现类编程。由DIP衍生出了控制反转（IoC）、IoC容器和依赖注入（DI）这三个概念，它们到底有什么关系呢？我们下面捋一捋。

依赖倒转（DIP）：指的是一种软件设计原则。

控制反转（IoC）：DIP的一种实现方式，使用控制反转的思想可以让开发者不用将类绑定在应用里，而是在类的构造方法中将依赖传递进去。

依赖注入（DI）：IoC的一种实现方式，用来反转依赖。

IoC容器：DI框架，用来映射依赖，管理对象的创建和其生命周期。

今天的主角Autofac就是一种IoC框架，IoC框架有很多种，原理大致相同。Autofac在.net平台使用很广泛，性能很不错，有人做过性能测试，据说是速度排第一。下面让我们了解并使用它。

第一步添加Nuget包

添加

Microsoft.Extensions.Configuration,

Microsoft.Extensions.Configuration.Json,

Autofac

 添加完成后

 我们现在有这样一个读取数据的需求，数据来源可能是本地csv，或者oracle数据库，那么我们定义一个读取数据的接口

public interface IData
    {
        /// <summary>
        /// 获取数据接口
        /// </summary>
        /// <returns></returns>
        DataTable GetData();
    }

/// <summary>
    /// 数据库查询数据
    /// </summary>
    public class DataFromDB : IData
    {
        public DataTable GetData()
        {
            ///执行sql 查询数据逻辑
            return new DataTable();
        }
    }

/// <summary>
    /// 读取本地文件
    /// </summary>
    public class DataFromFile : IData
    {
        public DataTable GetData()
        {
            ///读取本地文件查询数据
            return new DataTable();
        }
    }

在没有使用Autofac 之前我们可能会这样做

  public class Factory
    {
        private static IData data;
        public static IData Create(string type)
        {
            switch (type)
            {
                case "1":
                    data = new DataFromDB();
                    break;
                case "2":
                    data = new DataFromFile();
                    break;
            }
            return data;
        }
    }
前端调用
        static void Main(string[] args)
        {
            var data = Factory.Create("1").GetData();
            Console.WriteLine("Hello World!");
        }

使用Autofac完全可以省略上述创建具体对象的过程，如下构建auto 帮助类

using Autofac;
using Autofac.Configuration;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Configuration.Json;
 public class AutofacEx
    {
        private static IContainer _container;

        public static void InitAutofac()
        {
            // Add the configuration to the ConfigurationBuilder.
            var config = new ConfigurationBuilder();
            IConfigurationSource autofacJsonConfigSource = new JsonConfigurationSource()
            {
                Path = "/autofac.json",
                Optional = false,//boolean,默认就是false,可不写
                ReloadOnChange = false,//boolean,默认就是false,可不写
            };

            config.Add(autofacJsonConfigSource);

            var module = new ConfigurationModule(config.Build());
            var builder = new ContainerBuilder();
            builder.RegisterModule(module);
            _container = builder.Build();
        }

        /// <summary>
        /// 从容器中获取对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        public static T GetFromFac<T>()
        {
            return _container.Resolve<T>();
            //   return (T)DependencyResolver.Current.GetService(typeof(T));
        }

        public static T GetFromFac<T>(string name)
        {
            return _container.ResolveNamed<T>(name);
        }

添加json配置文件

{
    "defaultAssembly": "ConsoleApp1",
    "components": [
        {
            "type": "ConsoleApp1.DataFromDB, ConsoleApp1",
            "services": [
                {
                    "type": "ConsoleApp1.IData,ConsoleApp1"
                }
            ],
            "instanceScope": "single-instance",
            "injectProperties": true
        }
    ]
}

到此autofac配置完成

前端调用

            AutofacEx.InitAutofac();//注册接口
            data= AutofacEx.GetFromFac<IData>();//从容器中获取配置的具体接口实现类
            var dataTable= data.GetData();