ASP.NET Core Web 应用程序系列（一）- 使用ASP.NET Core内置的IoC容器DI进行批量依赖注入（MVC当中应用）

在正式进入主题之前我们来看下几个概念：

一、依赖倒置

依赖倒置是编程五大原则之一，即：

1、上层模块不应该依赖于下层模块，它们共同依赖于一个抽象。

2、抽象不能依赖于具体，具体依赖于抽象。

其中上层就是指使用者，下层就是指被使用者。

二、ioc控制反转

控制反转（ioc，全称inversion of control）是一种思想，所谓“控制反转”，就是反转获得依赖对象的过程。

三、依赖注入（di）

依赖注入设计模式是一种在类及其依赖对象之间实现控制反转（ioc）思想的技术。

所谓依赖注入（di，全称dependency injection），就是由ioc容器在运行期间，动态地将某种依赖关系注入到对象之中。

依赖注入主要分为3种：构造函数注入、属性注入、方法注入。

 

这里就不做过多的描述，如果有机会会通过具体例子再和大家分享，下面我们正式进入本章主题。

ps：asp.net core 内置的ioc容器目前只支持构造函数注入，以下我们也主要讲解构造函数注入的方式。

话不多说，直入主题看我们的解决方案结构：

分别对上面的工程进行简单的说明：

1、tianya.dotnetshare.model：为demo的实体层

2、tianya.dotnetshare.repository：为demo的仓储层即数据访问层

3、tianya.dotnetshare.service：为demo的服务层即业务逻辑层

4、tianya.dotnetshare.commtool：为demo的公共工具类库

5、tianya.dotnetshare.sharpcore：为demo的sharp核心类库

6、tianya.dotnetshare.coremvcdemo：为demo的web层项目，mvc框架

约定：

1、公共的类库，我们选择.net standard 2.0作为目标框架，可与framework进行共享。

2、本demo的web项目为asp.net core web 应用程序（.net core 2.2） mvc框架。

一、实体层

1、新建一个学生实体 student

using system;
using system.collections.generic;
using system.text;

namespace tianya.dotnetshare.model
{
    /// <summary>
    /// 学生类
    /// </summary>
    public class student
    {
        /// <summary>
        /// 学号
        /// </summary>
        public string stuno { get; set; }

        /// <summary>
        /// 姓名
        /// </summary>
        public string name { get; set; }

        /// <summary>
        /// 年龄
        /// </summary>
        public int age { get; set; }

        /// <summary>
        /// 性别
        /// </summary>
        public string sex { get; set; }
    }
}

demo中的实体就这样了

二、仓储层

本demo的仓储层需要引用我们的实体层tianya.dotnetshare.model

为什么选择用仓储，原因很简单，方便我们进行个性化扩展。在数据操作的底层进行其他个性化逻辑处理。

约定：

1、接口的定义放在根目录下，接口的实现类，统一放到impl文件夹，表示实现类目录。

2、每个实体，对应一个仓储的接口和实现类，即有多少个实体，就对应创建多少个接口和实现类。

3、仓储层接口都以“i”开头，以“repository”结尾。仓储层实现都以“repository”结尾。

我们新建一个student的仓储接口istudentrepository.cs

using system;
using system.collections.generic;
using system.text;

using tianya.dotnetshare.model;

namespace tianya.dotnetshare.repository
{
    /// <summary>
    /// 学生类仓储层接口
    /// </summary>
    public interface istudentrepository
    {
        /// <summary>
        /// 根据学号获取学生信息
        /// </summary>
        /// <param name="stuno">学号</param>
        /// <returns>学生信息</returns>
        student getstuinfo(string stuno);
    }
}

接着在impl中新建一个student的仓储实现studentrepository.cs

using system;
using system.collections.generic;
using system.text;

using tianya.dotnetshare.model;

namespace tianya.dotnetshare.repository.impl
{
    /// <summary>
    /// 学生类仓储层
    /// </summary>
    public class studentrepository : istudentrepository
    {
        /// <summary>
        /// 根据学号获取学生信息
        /// </summary>
        /// <param name="stuno">学号</param>
        /// <returns>学生信息</returns>
        public student getstuinfo(string stuno)
        {
            //数据访问逻辑，此处为了演示就简单些
            var student = new student();
            switch (stuno)
            {
                case "10000":
                    student = new student() { stuno = "10000", name = "张三", sex = "男", age = 20 };
                    break;
                case "10001":
                    student = new student() { stuno = "10001", name = "钱七七", sex = "女", age = 18 };
                    break;
                case "10002":
                    student = new student() { stuno = "10002", name = "李四", sex = "男", age = 21 };
                    break;
                default:
                    student = new student() { stuno = "10003", name = "王五", sex = "男", age = 25 };
                    break;
            }

            return student;
        }
    }
}

该类实现了istudentrepository接口

三、服务层

本demo的服务层需要引用我们的实体层tianya.dotnetshare.model和我们的仓储层tianya.dotnetshare.repository

服务层与仓储层类似，它属于仓储层的使用者。定义的方式也与仓储层类似，有接口和impl实现目录。

但服务层不需要一个实体对应一个，服务层更多的是按照功能模块进行划分，比如一个登录模块，创建一个loginservice。

约定：

1、服务层接口都以“i”开头，以“service”结尾。服务层实现都以“service”结尾。

为了演示，我们新建一个student的服务层接口istudentservice.cs

using system;
using system.collections.generic;
using system.text;

using tianya.dotnetshare.model;

namespace tianya.dotnetshare.service
{
    /// <summary>
    /// 学生类服务层接口
    /// </summary>
    public interface istudentservice
    {
        /// <summary>
        /// 根据学号获取学生信息
        /// </summary>
        /// <param name="stuno">学号</param>
        /// <returns>学生信息</returns>
        student getstuinfo(string stuno);
    }
}

接着我们同样在impl中新建一个student的服务层实现studentservice.cs

using system;
using system.collections.generic;
using system.text;

using tianya.dotnetshare.model;
using tianya.dotnetshare.repository;

namespace tianya.dotnetshare.service.impl
{
    /// <summary>
    /// 学生类服务层
    /// </summary>
    public class studentservice : istudentservice
    {
        /// <summary>
        /// 定义仓储层学生抽象类对象
        /// </summary>
        protected istudentrepository sturepository;

        /// <summary>
        /// 空构造函数
        /// </summary>
        public studentservice() { }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="sturepository">仓储层学生抽象类对象</param>
        public studentservice(istudentrepository sturepository)
        {
            this.sturepository = sturepository;
        }

        /// <summary>
        /// 根据学号获取学生信息
        /// </summary>
        /// <param name="stuno">学号</param>
        /// <returns>学生信息</returns>
        public student getstuinfo(string stuno)
        {
            var stu = sturepository.getstuinfo(stuno);
            return stu;
        }
    }
}

该类实现了istudentservice接口

四、公共工具类库

公共工具类库就是将来我们要在里面写各种各样的帮助类以提高程序的可复用性，此处就不做赘述。

五、sharp核心类库

需要从nuget上引用以下几个程序集：

sharp核心类库为公共的基础类，最底层。

其中model文件夹为实体目录，主要存放数据库连接相关的实体。extensions文件夹为扩展目录，主要存放最底层的扩展类，我们底层的批量依赖注入就放在这里面。

在model实体目录中我们新建一个用于数据库连接的接口idatabasesetting.cs

using system;
using system.collections.generic;
using system.text;

namespace tianya.dotnetshare.sharpcore.model
{
    public interface idatabasesetting
    {
        /// <summary>
        /// 访问数据库连接串
        /// </summary>
        string connectionstring { get; set; }

        /// <summary>
        /// 数据库名称，当是关系型数据库时，databasename属性没用到
        /// </summary>
        string databasename { get; set; }
    }
}

接着添加一个用于数据库连接的实现类databasesetting.cs

using system;
using system.collections.generic;
using system.text;

namespace tianya.dotnetshare.sharpcore.model
{
    public class databasesetting : idatabasesetting
    {
        /// <summary>
        /// 访问数据库连接串
        /// </summary>
        public string connectionstring { get; set; }

        /// <summary>
        /// 数据库名称，当是关系型数据库时，databasename属性没用到
        /// </summary>
        public string databasename { get; set; }
    }
}

该类实现了idatabasesetting.cs接口

model实体目录主要用于以后涉及到数据库访问的时候使用，本demo主要为了简单介绍下如何使用asp.net core内置的ioc容器di进行批量依赖注入，故没有对该实体目录进行详细的讲解。

接下来就是重头戏了，我们在extensions扩展目录中添加一个用于批量依赖注入的扩展类servicecollectionextensions.cs

using system;
using system.collections.generic;
using system.linq;
using system.reflection;
using system.runtime.loader;
using microsoft.extensions.configuration;
using microsoft.extensions.dependencyinjection;
using microsoft.extensions.dependencymodel;

using tianya.dotnetshare.sharpcore.model;

namespace tianya.dotnetshare.sharpcore.extensions
{
    /// <summary>
    /// servicecollection扩展
    /// </summary>
    public static class servicecollectionextensions
    {
        #region 通过反射批量注入指定的程序集
        /// <summary>
        /// 通过反射批量注入指定的程序集
        /// </summary>
        /// <param name="services">服务</param>
        /// <param name="assemblynames">程序集数组 如:["tianya.dotnetshare.repository","tianya.dotnetshare.service"]，无需写dll</param>
        public static void registertianyasharpservice(this iservicecollection services, params string[] assemblynames)
        {
            foreach (string assemblyname in assemblynames)
            {
                foreach (var itemclass in getclassinterfacepairs(assemblyname))
                {
                    foreach (var iteminterface in itemclass.value)
                    {
                        if (iteminterface != typeof(databasesetting))
                        {
                            services.addtransient(iteminterface, itemclass.key); //di依赖注入
                        }
                    }
                }
            }
        }
        #endregion

        #region di依赖注入辅助方法

        /// <summary>
        /// 获取类以及类实现的接口键值对
        /// </summary>
        /// <param name="assemblyname">程序集名称</param>
        /// <returns>类以及类实现的接口键值对</returns>
        private static dictionary<type, list<type>> getclassinterfacepairs(string assemblyname)
        {
            //存储 实现类 以及 对应接口
            dictionary<type, list<type>> dic = new dictionary<type, list<type>>();
            assembly assembly = getassembly(assemblyname);
            if (assembly != null)
            {
                type[] types = assembly.gettypes();
                foreach (var item in types.asenumerable().where(x => !x.isabstract && !x.isinterface && !x.isgenerictype))
                {
                    dic.add(item, item.getinterfaces().where(x => !x.isgenerictype).tolist());
                }
            }

            return dic;
        }

        /// <summary>
        /// 获取所有的程序集
        /// </summary>
        /// <returns>程序集集合</returns>
        private static list<assembly> getallassemblies()
        {
            var list = new list<assembly>();
            var deps = dependencycontext.default;
            var libs = deps.compilelibraries.where(lib => !lib.serviceable && lib.type != "package");//排除所有的系统程序集、nuget下载包
            foreach (var lib in libs)
            {
                try
                {
                    var assembly = assemblyloadcontext.default.loadfromassemblyname(new assemblyname(lib.name));
                    list.add(assembly);
                }
                catch (exception)
                {
                    // ignored
                }
            }
            return list;
        }

        /// <summary>
        /// 获取指定的程序集
        /// </summary>
        /// <param name="assemblyname">程序集名称</param>
        /// <returns>程序集</returns>
        private static assembly getassembly(string assemblyname)
        {
            return getallassemblies().firstordefault(assembly => assembly.fullname.contains(assemblyname));
        }

        #endregion
    }
}

并且添加一个dynamic的扩展类dynamicextensions.cs

using system;
using system.collections.generic;
using system.componentmodel;
using system.dynamic;
using system.linq;
using system.xml;

namespace tianya.dotnetshare.sharpcore.extensions
{
    /// <summary>
    /// dynamic的扩展方法
    /// </summary>
    public static class dynamicextensions
    {
        #region 匿名对象处理

        #region 将对象[主要是匿名对象]转换为dynamic
        /// <summary>
        /// 将对象[主要是匿名对象]转换为dynamic
        /// </summary>
        public static dynamic todynamic(this object value)
        {
            idictionary<string, object> expando = new expandoobject();
            var type = value.gettype();
            var properties = typedescriptor.getproperties(type);
            foreach (propertydescriptor property in properties)
            {
                var val = property.getvalue(value);
                if (property.propertytype.fullname.startswith("<>f__anonymoustype"))
                {
                    dynamic dval = val.todynamic();
                    expando.add(property.name, dval);
                }
                else
                {
                    expando.add(property.name, val);
                }
            }
            return expando as expandoobject;
        }
        #endregion

        #region 将对象[主要是匿名对象]转换为list<dynamic>
        /// <summary>
        /// 将对象[主要是匿名对象]转换为list<dynamic>
        /// </summary>
        public static list<dynamic> todynamiclist(this ienumerable<dynamic> values)
        {
            var list = new list<dynamic>();
            if (values != null)
            {
                if (values.any())
                {
                    list.addrange(values.select(v => ((object)v).todynamic()));
                }
            }

            return list;
        }
        #endregion

        #region 将匿名对象集合转换为xml
        /// <summary>
        /// 将匿名对象集合转换为xml
        /// </summary>
        public static xmldocument listobjerttoxml(this ienumerable<dynamic> values)
        {
            var xmldoc = new xmldocument();
            var xmlelem = xmldoc.createelement("documentelement");
            xmldoc.appendchild(xmlelem);
            if (values != null)
            {
                if (values.any())
                {
                    var node = xmldoc.selectsinglenode("documentelement");
                    foreach (var item in values)
                    {
                        var xmlrow = xmldoc.createelement("row");
                        objecttoxml(item, xmldoc, xmlrow);
                        node.appendchild(xmlrow);
                    }
                }
            }

            return xmldoc;
        }
        #endregion

        #region 将匿名对象填充xml节点
        /// <summary>
        /// 将匿名对象填充xml节点
        /// </summary>
        private static void objecttoxml(object value, xmldocument xmldoc, xmlelement xmlrow)
        {
            idictionary<string, object> expando = new expandoobject();
            var type = value.gettype();
            var properties = typedescriptor.getproperties(type);
            foreach (propertydescriptor property in properties)
            {
                var val = property.getvalue(value);
                xmlrow.clonenode(false);
                var xmltemp = xmldoc.createelement(property.name);
                xmltext xmltext;
                if (property.propertytype.fullname.startswith("<>f__anonymoustype"))
                {
                    dynamic dval = val.todynamic();
                    xmltext = xmldoc.createtextnode(dval.objecttostring());
                }
                else
                {
                    xmltext = xmldoc.createtextnode(val.tostring());
                }

                xmltemp.appendchild(xmltext);
                xmlrow.appendchild(xmltemp);
            }
        }
        #endregion

        #endregion
    }
}

该扩展类主要在我们的action向视图传递匿名类型值的时候使用

六、web层

本demo的web项目需要引用以下几个程序集：

1、tianya.dotnetshare.model 我们的实体层

2、tianya.dotnetshare.service 我们的服务层

3、tianya.dotnetshare.repository 我们的仓储层，正常我们的web项目是不应该使用仓储层的，此处我们引用是为了演示ioc依赖注入

4、tianya.dotnetshare.commtool 我们的公共工具类库

5、tianya.dotnetshare.sharpcore 我们的sharp核心类库

到了这里我们所有的工作都已经准备好了，接下来就是开始做注入工作了。

打开我们的startup.cs文件进行注入工作：

using system;
using system.collections.generic;
using system.linq;
using system.threading.tasks;
using microsoft.aspnetcore.builder;
using microsoft.aspnetcore.hosting;
using microsoft.aspnetcore.http;
using microsoft.aspnetcore.mvc;
using microsoft.extensions.configuration;
using microsoft.extensions.dependencyinjection;

using tianya.dotnetshare.sharpcore.extensions;

namespace tianya.dotnetshare.coremvcdemo
{
    public class startup
    {
        public startup(iconfiguration configuration)
        {
            configuration = configuration;
        }

        public iconfiguration configuration { get; }

        // this method gets called by the runtime. use this method to add services to the container.
        public void configureservices(iservicecollection services)
        {
            services.configure<cookiepolicyoptions>(options =>
            {
                // this lambda determines whether user consent for non-essential cookies is needed for a given request.
                options.checkconsentneeded = context => true;
                options.minimumsamesitepolicy = samesitemode.none;
            });

            services.addmvc().setcompatibilityversion(compatibilityversion.version_2_2);

            //di依赖注入，批量注入指定的程序集
            services.registertianyasharpservice(new string[] { "tianya.dotnetshare.repository", "tianya.dotnetshare.service" });
        }

        // this method gets called by the runtime. use this method to configure the http request pipeline.
        public void configure(iapplicationbuilder app, ihostingenvironment env)
        {
            if (env.isdevelopment())
            {
                app.usedeveloperexceptionpage();
            }
            else
            {
                app.useexceptionhandler("/home/error");
            }

            app.usestaticfiles();
            app.usecookiepolicy();

            app.usemvc(routes =>
            {
                routes.maproute(
                    name: "default",
                    template: "{controller=home}/{action=index}/{id?}");
            });
        }
    }
}

其中用来实现批量依赖注入的只要一句话就搞定了，如下所示：

//di依赖注入，批量注入指定的程序集
services.registertianyasharpservice(new string[] { "tianya.dotnetshare.repository", "tianya.dotnetshare.service" });

sharp核心类库在底层实现了批量注入的逻辑，程序集的注入必须按照先后顺序进行，先进行仓储层注入然后再进行服务层注入。

接下来我们来看看控制器里面怎么弄：

using system;
using system.collections.generic;
using system.diagnostics;
using system.linq;
using system.threading.tasks;
using microsoft.aspnetcore.mvc;

using tianya.dotnetshare.coremvcdemo.models;
using tianya.dotnetshare.service;
using tianya.dotnetshare.repository;

namespace tianya.dotnetshare.coremvcdemo.controllers
{
    public class homecontroller : controller
    {
        /// <summary>
        /// 定义仓储层学生抽象类对象
        /// </summary>
        protected istudentrepository sturepository;

        /// <summary>
        /// 定义服务层学生抽象类对象
        /// </summary>
        protected istudentservice stuservice;

        /// <summary>
        /// 通过构造函数进行注入
        /// 注意：参数是抽象类，而非实现类，因为已经在startup.cs中将实现类映射给了抽象类
        /// </summary>
        /// <param name="sturepository">仓储层学生抽象类对象</param>
        /// <param name="stuservice">服务层学生抽象类对象</param>
        public homecontroller(istudentrepository sturepository, istudentservice stuservice)
        {
            this.sturepository = sturepository;
            this.stuservice = stuservice;
        }

        public iactionresult index()
        {
            var stu1 = sturepository.getstuinfo("10000");
            var stu2 = stuservice.getstuinfo("10001");
            string msg = $"学号：10000，姓名：{stu1.name}，性别：{stu1.sex}，年龄：{stu1.age}<br />";
            msg += $"学号：10001，姓名：{stu2.name}，性别：{stu2.sex}，年龄：{stu2.age}";

            return content(msg, "text/html", system.text.encoding.utf8);
        }

        public iactionresult privacy()
        {
            return view();
        }

        [responsecache(duration = 0, location = responsecachelocation.none, nostore = true)]
        public iactionresult error()
        {
            return view(new errorviewmodel { requestid = activity.current?.id ?? httpcontext.traceidentifier });
        }
    }
}

至此，完成处理，接下来就是见证奇迹的时刻了，我们来访问一下/home/index，看看是否能返回学生信息。

我们可以发现，返回了学生的信息，说明我们注入成功了。

另外通过这个例子我们可以发现在注入仓储层对象studentrepository时，不仅控制器中注入成功了，而且在服务层中也注入成功了，说明我们asp.net core内置的ioc容器di依赖注入是全局的。

总结：

1、采用的是构造函数注入的方式，在构造函数中初始化赋值。

2、asp.net core内置的ioc容器di依赖注入是全局的。

3、di批量依赖注入的核心思想就是根据程序集的名称通过反射获取类以及类实现的接口键值对字典，然后通过循环进行批量注入。

 

扩展：di生命周期

生命周期是依赖注入设计原则里一个非常重要的概念，asp.net core 一共有3种生命周期。

1、暂时（transient）：顾名思义，这种生命周期的对象是暂时的，每次请求都会创建一个新的实例。

services.addtransient<istudentrepository, studentrepository>();
services.addtransient<istudentservice, studentservice>();

2、作用域（scoped）：每次请求使用的是同一个实例。

services.addscoped<istudentrepository, studentrepository>();
services.addscoped<istudentservice, studentservice>();

3、单例（singleton）：第一次请求时就创建，以后每次请求都是使用相同的实例。

services.addsingleton<istudentrepository, studentrepository>();
services.addsingleton<istudentservice, studentservice>();

官方文档建议：依赖注入是静态/全局对象访问模式的替代方法，如果将其与静态对象访问混合使用，则可能无法实现依赖关系注入的优点。

至此，本章就介绍完了，如果你觉得这篇文章对你有所帮助请记得点赞哦，谢谢！！！

demo源码：

链接：https://pan.baidu.com/s/17gigvp0jwy8banoe8l6p9a 
提取码：i9hh

 

参考博文：https://www.cnblogs.com/fei686868/p/11077997.html

版权声明：如有雷同纯属巧合，如有侵权请及时联系本人修改，谢谢！！！