.netCore+Vue 搭建的简捷开发框架 (5)

文章目录：.netCore+Vue 搭建的简捷开发框架--目录

上两节的内容介绍了一些关于。netCore 相关的一些基础知识。介绍这些的目的，最主要的还是为了我们的架构搭建服务。

上一节中，我们介绍了有关NetCore DI的一些概念。 整个框架，我们的仓储层、服务层都是通过依赖注入的方式进行加载调用的。

下面就来看一下仓储层和服务层是如何注入的：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using Sincere.Core.IRepository.Base;
using Sincere.Core.IServices.Base;
using Sincere.Core.Model.EFCore;
using Sincere.Core.Model.Models;
using Sincere.Core.Repository.Base;
using Sincere.Core.Services.Base;
using Sincere.Core.WebAPI.ServiceExtension;

namespace Sincere.Core.WebAPI
{
    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.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);

            services.AddDbContextPool<BaseCoreContext>(options =>
                options.UseSqlServer(BaseDBConfig.ConnectionString));
            services.AddScoped<IBaseContext, BaseCoreContext>();
            //泛型引用方式
            services.AddScoped(typeof(IBaseServices<>), typeof(BaseServices<>));

            services.AddScoped(typeof(IBaseRepository<>), typeof(BaseRepository<>));

            services.RegisterAssembly("IServices");
            services.RegisterAssembly("IRepository");
        }

        // 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();
            }

            app.UseMvc();
        }
    }
}

 标记1 的部分，是关于EF，以及DbContext 的相关引用，这里涉及到一个AddDbContextPool的概念，我个人的理解就是可以把他当成我们使用ADO.net 时的数据库连接池。

另外需要说明的一点就是，采用AddScoped 的方式，整个数据库链接的上下文，在整个请求过程中，只会被实例化一次。

标记2的部分，时我们对仓储的基础类，和服务层基础类的引用，注意这些基础类是泛型的方式，所以引用的时候，需要采用泛型的方式来实现。在这个地方，刚开始的时候，不知道AddScoped支持泛型的方式，还写过一个工厂类来进行注入。

剩下的方法，services.RegisterAssembly 其实是一个比较巧妙的方式，为了避免每写一个service、repository就在ConfigureServices中注入一次。所以在这里采用了反射的机制。利用反射和我们的约定，将整个程序集中的Service和Repository进行一个引用。

webAPI工程下新建一个ServiceExtension目录，并添加RuntimeHelper类和ServiceExtension。

如下图：

 代码如下：

using Microsoft.Extensions.DependencyInjection;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Threading.Tasks;

namespace Sincere.Core.WebAPI.ServiceExtension
{
    /// <summary>
    /// IServiceCollection扩展
    /// </summary>
    /// <summary>
    /// IServiceCollection扩展
    /// </summary>
    public static class ServiceExtension
    {
        /// <summary>
        /// 用DI批量注入接口程序集中对应的实现类。
        /// <para>
        /// 需要注意的是，这里有如下约定：
        /// IUserService --> UserService, IUserRepository --> UserRepository.
        /// </para>
        /// </summary>
        /// <param name="service"></param>
        /// <param name="interfaceAssemblyName">接口程序集的名称（不包含文件扩展名）</param>
        /// <returns></returns>
        public static IServiceCollection RegisterAssembly(this IServiceCollection service, string interfaceAssemblyName, ServiceLifetime serviceLifetime = ServiceLifetime.Scoped)
        {
            if (service == null)
                throw new ArgumentNullException(nameof(service));
            if (string.IsNullOrEmpty(interfaceAssemblyName))
                throw new ArgumentNullException(nameof(interfaceAssemblyName));

            var assembly = RuntimeHelper.GetAssembly(interfaceAssemblyName);
            if (assembly == null)
            {
                throw new DllNotFoundException($"the dll "{interfaceAssemblyName}" not be found");
            }

            //过滤掉非接口及泛型接口
            var types = assembly.GetTypes().Where(t => t.GetTypeInfo().IsInterface && !t.GetTypeInfo().IsGenericType);

            foreach (var type in types)
            {
                var implementTypeName = type.Name.Substring(1);
                var implementType = RuntimeHelper.GetImplementType(implementTypeName, type);
                if (implementType != null)
                {
                    switch (serviceLifetime)
                    {
                        //根据条件，选择注册依赖的方法
                        case ServiceLifetime.Scoped:
                            //将获取到的接口和类注册进去
                            service.AddScoped(type, implementType);
                            break;
                        case ServiceLifetime.Singleton:
                            service.AddSingleton(type, implementType);
                            break;
                        case ServiceLifetime.Transient:
                            service.AddTransient(type, implementType);
                            break;
                    }

                }
            }
            return service;
        }

       
    }
}

using Microsoft.Extensions.DependencyModel;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Runtime.Loader;
using System.Threading.Tasks;

namespace Sincere.Core.WebAPI.ServiceExtension
{
    public class RuntimeHelper
    {
        /// <summary>
        /// 获取项目程序集，排除所有的系统程序集(Microsoft.***、System.***等)、Nuget下载包
        /// </summary>
        /// <returns></returns>
        public static IList<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;
        }

        public static Assembly GetAssembly(string assemblyName)
        {
            return GetAllAssemblies().FirstOrDefault(assembly => assembly.FullName.Contains(assemblyName));
        }

        public static IList<Type> GetAllTypes()
        {
            var list = new List<Type>();
            foreach (var assembly in GetAllAssemblies())
            {
                var typeInfos = assembly.DefinedTypes;
                foreach (var typeInfo in typeInfos)
                {
                    list.Add(typeInfo.AsType());
                }
            }
            return list;
        }

        public static IList<Type> GetTypesByAssembly(string assemblyName)
        {
            var list = new List<Type>();
            var assembly = AssemblyLoadContext.Default.LoadFromAssemblyName(new AssemblyName(assemblyName));
            var typeInfos = assembly.DefinedTypes;
            foreach (var typeInfo in typeInfos)
            {
                list.Add(typeInfo.AsType());
            }
            return list;
        }

        public static Type GetImplementType(string typeName, Type baseInterfaceType)
        {
            return GetAllTypes().FirstOrDefault(t =>
            {
                if (t.Name == typeName &&
                    t.GetTypeInfo().GetInterfaces().Any(b => b.Name == baseInterfaceType.Name))
                {
                    var typeInfo = t.GetTypeInfo();
                    return typeInfo.IsClass && !typeInfo.IsAbstract && !typeInfo.IsGenericType;
                }
                return false;
            });
        }
    }
}

 这样类似的代码网上挺多的。大家可以参考借鉴一下。另外这个地方其实不用太过于关心反射带来的性能问题，因为只有在程序启动的时候，加载一次。

仓储层和服务层都注入进来以后，接下来就是怎么去使用了。

来一起看一下我们是怎么在ValuesController里面进行实现的。

  1.定义服务层接口

 2.在ValuesController初始化的时候，将服务层接口注入进来。

 3.使用接口，调用数据。

代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Sincere.Core.IServices;

namespace Sincere.Core.WebAPI.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class ValuesController : ControllerBase
    {
        readonly IAdvertisementServices _advertisementServices;
        public ValuesController(IAdvertisementServices advertisementServices)
        {
            _advertisementServices = advertisementServices;
        }

        // GET api/values
        [Route("")]
        [HttpGet]
        public async Task<ActionResult<IEnumerable<string>>> Get()
        {
            var t = await _advertisementServices.ReadAllAd();

            return new string[] { "value1", "value2" };
        }

        // GET api/values/5
        [HttpGet("{id}")]
        public ActionResult<string> Get(int id)
        {
            return "value";
        }

        // POST api/values
        [HttpPost]
        public void Post([FromBody] string value)
        {
        }

        // PUT api/values/5
        [HttpPut("{id}")]
        public void Put(int id, [FromBody] string value)
        {
        }

        // DELETE api/values/5
        [HttpDelete("{id}")]
        public void Delete(int id)
        {
        }
    }
}

关于ReadAllAd()方法，之前的章节中已经有过描述。

 调用成功，说明框架的整体流程已经跑通了！晚上加个鸡腿，庆祝一下！

按照之前的脑图，不知道大家还记得不？

红框里面的内容，到这一节，基本就结束了。接下来，会逐步的丰富我们的框架。加入日志，异常处理，权限验证。以及其他脑图中列出来的内容。

希望整个过程对于想学习、了解netCore 的同学们有所帮助！

 源码已经更新：https://github.com/xzhencheng/Sincere.Core