vlambda博客
学习文章列表

目录

2.ASP.NET Core比ASP.NE更具优势的地方是什么？

在config services方法中配置这个service。

在controller的构造函数中，添加这个依赖注入。

2.ASP.NET Core 比 ASP.NET 更具优势的地方是什么？

跨平台，ASP.NET Core 可以运行在 Windows 、Linux 和 MAC 系统上；

对框架本安装没有依赖，所有依赖都跟程序本身在一起；

ASP.NET Core 处理请求的效率更高，进而可以处理更多的请求；

ASP.NET Core 具有更多的安装配置方法。

依赖注入。

日志系统架构。

引入了一个跨平台的网络服务器，kestrel。

可以没有iis, apache和nginx就可以单独运行。

可以使用命令行创建应用。

使用AppSettings.json 来配置工程。

使用start up来注册服务。

更好的支持异步编程。

支持web socket和signal IR。

对于跨网站的请求的预防和保护机制。

可以通过全局注册，支持依赖注入

通过TypeFilter(typeof(Filter)) 标记在方法，标记在控制器

通过ServiceType(typeof(Filter))标记在方法，标记在控制器，必须要注册Filter这类；

TypeFilter和ServiceType的本质是实现了一个IFilterFactory接口；

1）.继承Controller，重写OnActionExecuted

默认都会继承一个Controller类，重写OnActionExecuted，添加上异常处理即可。一般情况下我们会新建一个BaseController, 让所有Controller继承BaseController。代码如下

public class BaseController : Controller{ public override void OnActionExecuted(ActionExecutedContext context) { var exception = context.Exception; if (exception != null) { context.ExceptionHandled = true; context.Result = new ContentResult { Content = $"BaseController错误 : { exception.Message }" }; } base.OnActionExecuted(context); }}

2）.使用 ActionFilterAttribute。

ActionFilterAttribute是一个特性，本身实现了 IActionFilter 及 IResultFilter , 所以不管是action里抛错，还是view里抛错，理论上都可以捕获。我们新建一个 ExceptionActionFilterAttribute, 重写 OnActionExecuted及OnResultExecuted，添加上异常处理，完整代码如下:

public class ExceptionActionFilterAttribute:ActionFilterAttribute{ public override void OnActionExecuted(ActionExecutedContext context) { var exception = context.Exception; if (exception != null) { context.ExceptionHandled = true; context.Result = new ContentResult { Content = $"错误 : { exception.Message }" }; } base.OnActionExecuted(context); }
 public override void OnResultExecuted(ResultExecutedContext context) { var exception = context.Exception; if (exception != null) { context.ExceptionHandled = true; context.HttpContext.Response.WriteAsync($"错误 : {exception.Message}"); } base.OnResultExecuted(context); }}

使用方式有两种，

在controller里打上 [TypeFilter(typeof(ExceptionActionFilter)] 标签;

在Startup里以filter方式全局注入。

services.AddControllersWithViews(options =>{ options.Filters.Add<ExceptionActionFilterAttribute>();})

3）.使用 IExceptionFilter
我们知道, Asp.Net Core提供了5类filter, IExceptionFilter是其中之一，顾名思义，这就是用来处理异常的。Asp.net Core中ExceptionFilterAttribute已经实现了IExceptionFilter，所以我们只需继承ExceptionFilterAttribute，重写其中方法即可。同样新建CustomExceptionFilterAttribute继承 ExceptionFilterAttribute，重写 OnException ，添加异常处理，完整代码如下：

public class CustomExceptionFilterAttribute : ExceptionFilterAttribute{ public override void OnException(ExceptionContext context) { context.ExceptionHandled = true; context.HttpContext.Response.WriteAsync($"CustomExceptionFilterAttribute错误:{context.Exception.Message}"); base.OnException(context); }}

4）.使用ExceptionHandler.

在 startup 里，vs新建的项目会默认加上.

if (env.IsDevelopment()){ app.UseDeveloperExceptionPage();}else{ app.UseExceptionHandler("/Home/Error");}

5）.自定义Middleare处理

通过middleware全局处理。

public class ErrorHandlingMiddleware{ private readonly RequestDelegate next;
 public ErrorHandlingMiddleware(RequestDelegate next) { this.next = next; }
 public async Task Invoke(HttpContext context) { try { await next(context); } catch (System.Exception ex) { //处理异常 } }}

ASP.NET Core支持依赖注入软件设计模式，它允许在不同的组件中注入我们的服务，并且控制服务的初始化。有些服务可以在短时间内初始化，并且只能在某个特别的组件，以及请求中才能用到；而还有一些服务，仅仅只用初始化一次，就可以在整个应用程序中使用。

Singleton  --单例模式：

只有一个服务的实例被创建，这个实例，存储在内存中，可以在整个应用程序中使用。我们可以对一些初始化代价比较大的服务，使用Singleton模式。在代码中可以这样：

services.AddSingleton<IProductService, ProductService>();

Scoped  --作用域

这种模式下，将会为每一个请求，都创建一个服务的实例。所有同一个请求中的中间件、MVC控制器，等等，都会得到一个相同的服务实例。Entity Framework Context就是一个Scoped服务最好的参考例子。我们可以通过使用AddScoped方法来使用Scoped模式：

services.AddScoped<IProductService, ProductService>();

Transient  --短暂的、瞬变的　　
Transient模式下，服务每次被请求的时候，都会创建一个服务实例，这种模式特别适合轻量级、无状态的服务。我们可以使用AddTransient方法，来注入服务：

services.AddTransient<IProductService, ProductService>();

依赖注入是一个过程，就是当一个类需要调用另一个类来完成某项任务的时候，在调用类里面不要去new被调用的类的对象，而是通过注入的方式来获取这样一个对象。具体的实现就是在调用类里面有一个被调用类的接口，然后通过调用接口的函数来完成任务。比如A调用B，而B实现了接口C，那么在A里面用C定义一个变量D，这个变量的实例不在A里面创建，而是通过A的上下文来获取。这样做的好处就是将类A和B分开了，他们之间靠接口C来联系，从而实现对接口编程。

setter注入：

就是在类A里面定义一个C接口的属性D，在A的上下文通过B实例化一个对象，然后将这个对象赋值给属性D。主要就是set 与 get

构造函数注入：

就是在创建A的对象的时候，通过参数将B的对象传入到A中。
还有常用的注入方式就是工厂模式的应用了，这些都可以将B的实例化放到A外面，从而让A和B没有关系。还有一个接口注入，就是在客户类（A）的接口中有一个服务类(B)的属性。在实例化了这个接口的子类后，对这个属性赋值，这和setter注入一样。

接口注入：

相比构造函数注入和属性注入，接口注入显得有些复杂，使用也不常见。具体思路是先定义一个接口，包含一个设置依赖的方法。然后依赖类，继承并实现这个接口。

控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。

通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。

Unity、autofac、http://spring.net、MEF、Injection、Asp.Net Core的ServiceCollection。

                                                             
  觉得不错，请点个在看呀