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

     }
 }

ServiceExtension.cs

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

RuntimeHelper.cs

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

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

来一起看一下我们是怎么在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