将 HTTP 处理程序和模块迁移到 ASP.NET Core 中间件

本文摘自Asp.Net Core的官方文档,介绍了 ASP.NET Core 和 ASP.NET 4.x 中请求管道之间的差异,是很好的了解HttpModule、HttpHandler、中间件MiddleWare、IOptions 的渠道。

https://docs.microsoft.com/zh-cn/aspnet/core/migration/http-modules?view=aspnetcore-5.0

 

本文介绍如何将现有 的 ASP.NET HTTP 模块和处理程序从 system.webserver 迁移到 ASP.NET Core 中间件

模块和处理程序被

在继续 ASP.NET Core 中间件之前,让我们先回顾一下 HTTP 模块和处理程序的工作原理:

模块处理程序

处理程序是:

  • 实现IHttpHandler的类

  • 用于处理具有给定文件名或扩展名的请求,如 . report

  • Web.config配置

模块为:

  • 实现IHttpModule的类

  • 为每个请求调用

  • 能够短路 (停止进一步处理请求)

  • 可以添加到 HTTP 响应,或创建自己的响应

  • Web.config配置

模块处理传入请求的顺序由确定:

  1. /previous-versions/ms227673(v=vs.140),它是 ASP.NET: BeginRequest、 AuthenticateRequest等引发的序列事件。每个模块都可以为一个或多个事件创建处理程序。

  2. 对于同一事件,在 Web.config中配置它们的顺序。

除了模块外,还可以将生命周期事件的处理程序添加到 Global.asax.cs 文件。 这些处理程序在配置的模块中的处理程序之后运行。

从处理程序和模块到中间件

中间件比 HTTP 模块和处理程序更简单:

  • 除 IIS 配置) 和应用程序生命周期外,模块、处理程序、 Global.asax.cs、 Web.config (

  • 中间件已使用模块和处理程序的角色

  • 中间件使用代码而不是Web.config来配置

  • 通过管道分支,你可以将请求发送到特定的中间件,不仅可以基于 URL,还可以发送到请求标头、查询字符串等。

中间件非常类似于模块:

中间件和模块按不同的顺序进行处理:

中间件

请注意,在上图中,身份验证中间件与请求短路。

将模块代码迁移到中间件

现有 HTTP 模块如下所示:

C#复制

// ASP.NET 4 module

using System;
using System.Web;

namespace MyApp.Modules
{
    public class MyModule : IHttpModule
    {
        public void Dispose()
        {
        }

        public void Init(HttpApplication application)
        {
            application.BeginRequest += (new EventHandler(this.Application_BeginRequest));
            application.EndRequest += (new EventHandler(this.Application_EndRequest));
        }

        private void Application_BeginRequest(Object source, EventArgs e)
        {
            HttpContext context = ((HttpApplication)source).Context;

            // Do something with context near the beginning of request processing.
        }

        private void Application_EndRequest(Object source, EventArgs e)
        {
            HttpContext context = ((HttpApplication)source).Context;

            // Do something with context near the end of request processing.
        }
    }
}

如 中间件 页中所示,ASP.NET Core 中间件是一个类,该类公开 Invoke 采用 HttpContext 并返回的方法 Task 。 新的中间件将如下所示:

C#复制

// ASP.NET Core middleware

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
using System.Threading.Tasks;

namespace MyApp.Middleware
{
    public class MyMiddleware
    {
        private readonly RequestDelegate _next;

        public MyMiddleware(RequestDelegate next)
        {
            _next = next;
        }

        public async Task Invoke(HttpContext context)
        {
            // Do something with context near the beginning of request processing.

            await _next.Invoke(context);

            // Clean up.
        }
    }

    public static class MyMiddlewareExtensions
    {
        public static IApplicationBuilder UseMyMiddleware(this IApplicationBuilder builder)
        {
            return builder.UseMiddleware<MyMiddleware>();
        }
    }
}

前面的中间件模板取自 编写中间件的部分。

MyMiddlewareExtensions helper 类使你可以更轻松地在类中配置中间件 Startup 。 UseMyMiddleware方法将中间件类添加到请求管道。 中间件的构造函数中插入了中间件所需的服务。

如果用户未获得授权,则模块可能会终止请求:

C#复制

// ASP.NET 4 module that may terminate the request

private void Application_BeginRequest(Object source, EventArgs e)
{
    HttpContext context = ((HttpApplication)source).Context;

    // Do something with context near the beginning of request processing.

    if (TerminateRequest())
    {
        context.Response.End();
        return;
    }
}

中间件通过不调用 Invoke 管道中的下一个中间件来处理这种情况。 请记住,这并不完全终止请求,因为当响应通过管道返回以前的中间件时,仍然会调用以前的。

C#复制

// ASP.NET Core middleware that may terminate the request

public async Task Invoke(HttpContext context)
{
    // Do something with context near the beginning of request processing.

    if (!TerminateRequest())
        await _next.Invoke(context);

    // Clean up.
}

当您将模块的功能迁移到新的中间件时,您可能会发现您的代码不会进行编译,因为 HttpContext 在 ASP.NET Core 中,类发生了重大更改。 稍后,你将了解如何迁移到新的 ASP.NET Core HttpContext。

将模块插入迁移到请求管道中

通常使用 Web.config将 HTTP 模块添加到请求管道:

XML复制

<?xml version="1.0" encoding="utf-8"?>
<!--ASP.NET 4 web.config-->
<configuration>
  <system.webServer>
    <modules>
      <add name="MyModule" type="MyApp.Modules.MyModule"/>
    </modules>
  </system.webServer>
</configuration>

通过在类中将 新的中间件添加 到请求管道来转换此项 Startup :

C#复制

public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
    loggerFactory.AddConsole(Configuration.GetSection("Logging"));
    loggerFactory.AddDebug();

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

    app.UseMyMiddleware();

    app.UseMyMiddlewareWithParams();

    var myMiddlewareOptions = Configuration.GetSection("MyMiddlewareOptionsSection").Get<MyMiddlewareOptions>();
    var myMiddlewareOptions2 = Configuration.GetSection("MyMiddlewareOptionsSection2").Get<MyMiddlewareOptions>();
    app.UseMyMiddlewareWithParams(myMiddlewareOptions);
    app.UseMyMiddlewareWithParams(myMiddlewareOptions2);

    app.UseMyTerminatingMiddleware();

    // Create branch to the MyHandlerMiddleware. 
    // All requests ending in .report will follow this branch.
    app.MapWhen(
        context => context.Request.Path.ToString().EndsWith(".report"),
        appBranch => {
            // ... optionally add more middleware to this branch
            appBranch.UseMyHandler();
        });

    app.MapWhen(
        context => context.Request.Path.ToString().EndsWith(".context"),
        appBranch => {
            appBranch.UseHttpContextDemoMiddleware();
        });

    app.UseStaticFiles();

    app.UseMvc(routes =>
    {
        routes.MapRoute(
            name: "default",
            template: "{controller=Home}/{action=Index}/{id?}");
    });
}

插入新中间件的管道中的确切位置取决于它作为模块处理的事件 BeginRequest , (、等 EndRequest ) 及其在 Web.config的模块列表中的顺序。

如前所述,ASP.NET Core 中没有应用程序生命周期,中间件的处理响应顺序与模块使用的顺序不同。 这可能会使你的排序决策更具挑战性。

如果排序会成为一个问题,则可以将模块拆分为多个中间件组件,这些组件可以独立排序。

将处理程序代码迁移到中间件

HTTP 处理程序如下所示:

C#复制

// ASP.NET 4 handler

using System.Web;

namespace MyApp.HttpHandlers
{
    public class MyHandler : IHttpHandler
    {
        public bool IsReusable { get { return true; } }

        public void ProcessRequest(HttpContext context)
        {
            string response = GenerateResponse(context);

            context.Response.ContentType = GetContentType();
            context.Response.Output.Write(response);
        }

        // ...

        private string GenerateResponse(HttpContext context)
        {
            string title = context.Request.QueryString["title"];
            return string.Format("Title of the report: {0}", title);
        }

        private string GetContentType()
        {
            return "text/plain";
        }
    }
}

在 ASP.NET Core 项目中,将其转换为类似于下面的中间件:

C#复制

// ASP.NET Core middleware migrated from a handler

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
using System.Threading.Tasks;

namespace MyApp.Middleware
{
    public class MyHandlerMiddleware
    {

        // Must have constructor with this signature, otherwise exception at run time
        public MyHandlerMiddleware(RequestDelegate next)
        {
            // This is an HTTP Handler, so no need to store next
        }

        public async Task Invoke(HttpContext context)
        {
            string response = GenerateResponse(context);

            context.Response.ContentType = GetContentType();
            await context.Response.WriteAsync(response);
        }

        // ...

        private string GenerateResponse(HttpContext context)
        {
            string title = context.Request.Query["title"];
            return string.Format("Title of the report: {0}", title);
        }

        private string GetContentType()
        {
            return "text/plain";
        }
    }

    public static class MyHandlerExtensions
    {
        public static IApplicationBuilder UseMyHandler(this IApplicationBuilder builder)
        {
            return builder.UseMiddleware<MyHandlerMiddleware>();
        }
    }
}

此中间件与与模块对应的中间件非常类似。 唯一的区别在于,这里不会调用 _next.Invoke(context) 。 这样做很有意义,因为处理程序位于请求管道的末尾,因此没有要调用的下一个中间件。

将处理程序插入迁移到请求管道中

配置 HTTP 处理程序是在 Web.config 中完成的,如下所示:

XML复制

<?xml version="1.0" encoding="utf-8"?>
<!--ASP.NET 4 web.config-->
<configuration>
  <system.webServer>
    <handlers>
      <add name="MyHandler" verb="*" path="*.report" type="MyApp.HttpHandlers.MyHandler" resourceType="Unspecified" preCondition="integratedMode"/>
    </handlers>
  </system.webServer>
</configuration>

可以通过将新的处理程序中间件添加到类中的请求管道来转换此转换 Startup ,类似于从模块转换的中间件。 此方法的问题是,它会将所有请求发送到新的处理程序中间件。 但是,只需要具有给定扩展的请求来访问中间件。 这将为你提供与 HTTP 处理程序相同的功能。

一种解决方法是使用扩展方法分支具有给定扩展的请求的管道 MapWhen 。 可在 Configure 添加其他中间件的相同方法中执行此操作:

C#复制

public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
    loggerFactory.AddConsole(Configuration.GetSection("Logging"));
    loggerFactory.AddDebug();

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

    app.UseMyMiddleware();

    app.UseMyMiddlewareWithParams();

    var myMiddlewareOptions = Configuration.GetSection("MyMiddlewareOptionsSection").Get<MyMiddlewareOptions>();
    var myMiddlewareOptions2 = Configuration.GetSection("MyMiddlewareOptionsSection2").Get<MyMiddlewareOptions>();
    app.UseMyMiddlewareWithParams(myMiddlewareOptions);
    app.UseMyMiddlewareWithParams(myMiddlewareOptions2);

    app.UseMyTerminatingMiddleware();

    // Create branch to the MyHandlerMiddleware. 
    // All requests ending in .report will follow this branch.
    app.MapWhen(
        context => context.Request.Path.ToString().EndsWith(".report"),
        appBranch => {
            // ... optionally add more middleware to this branch
            appBranch.UseMyHandler();
        });

    app.MapWhen(
        context => context.Request.Path.ToString().EndsWith(".context"),
        appBranch => {
            appBranch.UseHttpContextDemoMiddleware();
        });

    app.UseStaticFiles();

    app.UseMvc(routes =>
    {
        routes.MapRoute(
            name: "default",
            template: "{controller=Home}/{action=Index}/{id?}");
    });
}

MapWhen 采用以下参数:

  1. 一个采用的 lambda, HttpContext true 如果请求应向下分支,则返回。 这意味着,不仅可以根据请求的扩展来分支请求,还可以处理请求标头、查询字符串参数等。

  2. 一个采用 IApplicationBuilder 并添加分支的所有中间件的 lambda。 这意味着,可以将其他中间件添加到处理程序中间件前面的分支。

将在所有请求上调用分支之前添加到管道的中间件;该分支不会对它们产生任何影响。

使用 options 模式加载中间件选项

某些模块和处理程序具有存储在 Web.config中的配置选项。但是,在 ASP.NET Core 新的配置模型用于代替 Web.config

新 配置系统 提供以下选项来解决此类情况:

  1. 创建用于保存中间件选项的类,例如:

    C#复制

    public class MyMiddlewareOptions
    {
        public string Param1 { get; set; }
        public string Param2 { get; set; }
    }
    
  2. 存储选项值

    配置系统允许您将选项值存储在任何所需的位置。 但是,大多数站点使用 appsettings.js,因此我们将采取这种方法:

    JSON复制

    {
      "MyMiddlewareOptionsSection": {
        "Param1": "Param1Value",
        "Param2": "Param2Value"
      }
    }
    

    MyMiddlewareOptionsSection 是部分名称。 它不必与 options 类的名称相同。

  3. 将选项值与 options 类相关联

    Options 模式使用 ASP.NET Core 的依赖项注入框架将选项类型 (例如 MyMiddlewareOptions) 与 MyMiddlewareOptions 具有实际选项的对象相关联。

    更新你的 Startup 类:

    1. 如果使用 appsettings.js,请将其添加到构造函数中的配置生成器 Startup :

      C#复制

      public Startup(IHostingEnvironment env)
      {
          var builder = new ConfigurationBuilder()
              .SetBasePath(env.ContentRootPath)
              .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
              .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
              .AddEnvironmentVariables();
          Configuration = builder.Build();
      }
      
    2. 配置 options 服务:

      C#复制

      public void ConfigureServices(IServiceCollection services)
      {
          // Setup options service
          services.AddOptions();
      
          // Load options from section "MyMiddlewareOptionsSection"
          services.Configure<MyMiddlewareOptions>(
              Configuration.GetSection("MyMiddlewareOptionsSection"));
      
          // Add framework services.
          services.AddMvc();
      }
      
    3. 将选项与 options 类相关联:

      C#复制

      public void ConfigureServices(IServiceCollection services)
      {
          // Setup options service
          services.AddOptions();
      
          // Load options from section "MyMiddlewareOptionsSection"
          services.Configure<MyMiddlewareOptions>(
              Configuration.GetSection("MyMiddlewareOptionsSection"));
      
          // Add framework services.
          services.AddMvc();
      }
      
  4. 将选项注入中间件构造函数。 这类似于将选项注入控制器。

    C#复制

    public class MyMiddlewareWithParams
    {
        private readonly RequestDelegate _next;
        private readonly MyMiddlewareOptions _myMiddlewareOptions;
    
        public MyMiddlewareWithParams(RequestDelegate next,
            IOptions<MyMiddlewareOptions> optionsAccessor)
        {
            _next = next;
            _myMiddlewareOptions = optionsAccessor.Value;
        }
    
        public async Task Invoke(HttpContext context)
        {
            // Do something with context near the beginning of request processing
            // using configuration in _myMiddlewareOptions
    
            await _next.Invoke(context);
    
            // Do something with context near the end of request processing
            // using configuration in _myMiddlewareOptions
        }
    }
    

    将中间件添加到中的 UseMiddleware 扩展方法 IApplicationBuilder 会处理依赖关系注入。

    这并不限于 IOptions 对象。 中间件所需的任何其他对象都可以通过这种方式注入。

通过直接注入加载中间件选项

Options 模式的优点在于,它在选项值与其使用者之间产生松散耦合。 将选项类与实际选项值相关联后,任何其他类都可以通过依赖关系注入框架访问这些选项。 无需围绕选项值进行传递。

如果要使用不同的选项两次使用同一中间件,则会出现这种情况。 例如,在不同的分支中使用的授权中间件允许不同角色。 不能将两个不同的选项对象与一个 options 类相关联。

解决方法是在类中获取选项对象,并将其 Startup 直接传递给中间件的每个实例。

  1. 将第二个键添加到 appsettings.js

    若要将第二组选项添加到 appsettings.js 文件,请使用新密钥对其进行唯一标识:

    JSON复制

    {
      "MyMiddlewareOptionsSection2": {
        "Param1": "Param1Value2",
        "Param2": "Param2Value2"
      },
      "MyMiddlewareOptionsSection": {
        "Param1": "Param1Value",
        "Param2": "Param2Value"
      }
    }
    
  2. 检索选项值并将其传递给中间件。 Use...将中间件添加到管道的扩展方法 () 是要传入选项值的逻辑位置:

    C#复制

    public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
    {
        loggerFactory.AddConsole(Configuration.GetSection("Logging"));
        loggerFactory.AddDebug();
    
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
            app.UseBrowserLink();
        }
        else
        {
            app.UseExceptionHandler("/Home/Error");
        }
    
        app.UseMyMiddleware();
    
        app.UseMyMiddlewareWithParams();
    
        var myMiddlewareOptions = Configuration.GetSection("MyMiddlewareOptionsSection").Get<MyMiddlewareOptions>();
        var myMiddlewareOptions2 = Configuration.GetSection("MyMiddlewareOptionsSection2").Get<MyMiddlewareOptions>();
        app.UseMyMiddlewareWithParams(myMiddlewareOptions);
        app.UseMyMiddlewareWithParams(myMiddlewareOptions2);
    
        app.UseMyTerminatingMiddleware();
    
        // Create branch to the MyHandlerMiddleware. 
        // All requests ending in .report will follow this branch.
        app.MapWhen(
            context => context.Request.Path.ToString().EndsWith(".report"),
            appBranch => {
                // ... optionally add more middleware to this branch
                appBranch.UseMyHandler();
            });
    
        app.MapWhen(
            context => context.Request.Path.ToString().EndsWith(".context"),
            appBranch => {
                appBranch.UseHttpContextDemoMiddleware();
            });
    
        app.UseStaticFiles();
    
        app.UseMvc(routes =>
        {
            routes.MapRoute(
                name: "default",
                template: "{controller=Home}/{action=Index}/{id?}");
        });
    }
    
  3. 启用中间件以采用 options 参数。 提供 Use... 扩展方法 (的重载,该重载采用 options 参数,并将其传递给 UseMiddleware) 。 当 UseMiddleware 用参数调用时,它会在实例化中间件对象时将参数传递给中间件构造函数。

    C#复制

    public static class MyMiddlewareWithParamsExtensions
    {
        public static IApplicationBuilder UseMyMiddlewareWithParams(
            this IApplicationBuilder builder)
        {
            return builder.UseMiddleware<MyMiddlewareWithParams>();
        }
    
        public static IApplicationBuilder UseMyMiddlewareWithParams(
            this IApplicationBuilder builder, MyMiddlewareOptions myMiddlewareOptions)
        {
            return builder.UseMiddleware<MyMiddlewareWithParams>(
                new OptionsWrapper<MyMiddlewareOptions>(myMiddlewareOptions));
        }
    }
    

    请注意这如何包装对象中的选项对象 OptionsWrapper 。 这实现 IOptions 了中间件构造函数的预期。

迁移到新的 HttpContext

你以前看到, Invoke 中间件中的方法采用类型为的参数 HttpContext :

C#复制

public async Task Invoke(HttpContext context)

HttpContext 在 ASP.NET Core 中进行了重大更改。 本部分演示如何将 system.servicemodel 最 常用的属性转换为新 的 Microsoft.AspNetCore.Http.HttpContext 。

HttpContext

HttpContext 会转换为:

C#复制

IDictionary<object, object> items = httpContext.Items;

**唯一的请求 ID (不) **

提供每个请求的唯一 id。 在日志中包含非常有用。

C#复制

string requestId = httpContext.TraceIdentifier;

Httpcontext.current 请求

HttpMethod 转换为:

C#复制

string httpMethod = httpContext.Request.Method;

HttpContext 转换为:

C#复制

IQueryCollection queryParameters = httpContext.Request.Query;

// If no query parameter "key" used, values will have 0 items
// If single value used for a key (...?key=v1), values will have 1 item ("v1")
// If key has multiple values (...?key=v1&key=v2), values will have 2 items ("v1" and "v2")
IList<string> values = queryParameters["key"];

// If no query parameter "key" used, value will be ""
// If single value used for a key (...?key=v1), value will be "v1"
// If key has multiple values (...?key=v1&key=v2), value will be "v1,v2"
string value = queryParameters["key"].ToString();

Httpcontext.current 转换为( RawUrl ):

C#复制

// using Microsoft.AspNetCore.Http.Extensions;
var url = httpContext.Request.GetDisplayUrl();

IsSecureConnection 转换为:

C#复制

var isSecureConnection = httpContext.Request.IsHttps;

UserHostAddress 转换为:

C#复制

var userHostAddress = httpContext.Connection.RemoteIpAddress?.ToString();

Httpcontext.current Cookie 。s 转换为:

C#复制

IRequestCookieCollection cookies = httpContext.Request.Cookies;
string unknownCookieValue = cookies["unknownCookie"]; // will be null (no exception)
string knownCookieValue = cookies["cookie1name"];     // will be actual value

RequestContext RouteData 转换为:

C#复制

var routeValue = httpContext.GetRouteValue("key");

Httpcontext.current 转换为:

C#复制

// using Microsoft.AspNetCore.Http.Headers;
// using Microsoft.Net.Http.Headers;

IHeaderDictionary headersDictionary = httpContext.Request.Headers;

// GetTypedHeaders extension method provides strongly typed access to many headers
var requestHeaders = httpContext.Request.GetTypedHeaders();
CacheControlHeaderValue cacheControlHeaderValue = requestHeaders.CacheControl;

// For unknown header, unknownheaderValues has zero items and unknownheaderValue is ""
IList<string> unknownheaderValues = headersDictionary["unknownheader"];
string unknownheaderValue = headersDictionary["unknownheader"].ToString();

// For known header, knownheaderValues has 1 item and knownheaderValue is the value
IList<string> knownheaderValues = headersDictionary[HeaderNames.AcceptLanguage];
string knownheaderValue = headersDictionary[HeaderNames.AcceptLanguage].ToString();

UserAgent 转换为:

C#复制

string userAgent = headersDictionary[HeaderNames.UserAgent].ToString();

UrlReferrer 转换为:

C#复制

string urlReferrer = headersDictionary[HeaderNames.Referer].ToString();

HttpContext 转换为:

C#复制

// using Microsoft.Net.Http.Headers;

MediaTypeHeaderValue mediaHeaderValue = requestHeaders.ContentType;
string contentType = mediaHeaderValue?.MediaType.ToString();   // ex. application/x-www-form-urlencoded
string contentMainType = mediaHeaderValue?.Type.ToString();    // ex. application
string contentSubType = mediaHeaderValue?.SubType.ToString();  // ex. x-www-form-urlencoded

System.Text.Encoding requestEncoding = mediaHeaderValue?.Encoding;

Httpcontext.current 转换为:

C#复制

if (httpContext.Request.HasFormContentType)
{
    IFormCollection form;

    form = httpContext.Request.Form; // sync
    // Or
    form = await httpContext.Request.ReadFormAsync(); // async

    string firstName = form["firstname"];
    string lastName = form["lastname"];
}

 警告

仅当 content 子类型为 x-www-url 编码 或 窗体数据时才读取窗体值。

InputStream 转换为:

C#复制

string inputBody;
using (var reader = new System.IO.StreamReader(
    httpContext.Request.Body, System.Text.Encoding.UTF8))
{
    inputBody = reader.ReadToEnd();
}

 警告

仅在管道末尾的处理程序类型中间件中使用此代码。

对于每个请求,可以读取上面所示的原始主体。 第一次读取后尝试读取正文的中间件将读取空正文。

这并不适用于读取如上所示的窗体,因为这是从缓冲区中完成的。

HttpContext 响应

Httpcontext.current 转换为( StatusDescription ):

C#复制

// using Microsoft.AspNetCore.Http;
httpContext.Response.StatusCode = StatusCodes.Status200OK;

ContentEncoding 和 httpcontext 转换为以下内容:

C#复制

// using Microsoft.Net.Http.Headers;
var mediaType = new MediaTypeHeaderValue("application/json");
mediaType.Encoding = System.Text.Encoding.UTF8;
httpContext.Response.ContentType = mediaType.ToString();

Httpcontext.current 还会转换为:

C#复制

httpContext.Response.ContentType = "text/html";

Httpcontext.current 转换为:

C#复制

string responseContent = GetResponseContent();
await httpContext.Response.WriteAsync(responseContent);

TransmitFile

中间件和请求功能中讨论了如何提供文件。

Httpcontext.current 标头

发送响应标头比较复杂,因为如果在将任何内容写入响应正文后设置这些标头,则不会发送这些标头。

解决方法是设置一个回调方法,该方法将在开始写入响应之前被调用。 最好在中间件中的方法的开头完成此操作 Invoke 。 这是设置响应标头的此回调方法。

下面的代码设置一个名为的回调方法 SetHeaders :

C#复制

public async Task Invoke(HttpContext httpContext)
{
    // ...
    httpContext.Response.OnStarting(SetHeaders, state: httpContext);

SetHeaders回调方法将如下所示:

C#复制

// using Microsoft.AspNet.Http.Headers;
// using Microsoft.Net.Http.Headers;

private Task SetHeaders(object context)
{
    var httpContext = (HttpContext)context;

    // Set header with single value
    httpContext.Response.Headers["ResponseHeaderName"] = "headerValue";

    // Set header with multiple values
    string[] responseHeaderValues = new string[] { "headerValue1", "headerValue1" };
    httpContext.Response.Headers["ResponseHeaderName"] = responseHeaderValues;

    // Translating ASP.NET 4's HttpContext.Response.RedirectLocation  
    httpContext.Response.Headers[HeaderNames.Location] = "http://www.example.com";
    // Or
    httpContext.Response.Redirect("http://www.example.com");

    // GetTypedHeaders extension method provides strongly typed access to many headers
    var responseHeaders = httpContext.Response.GetTypedHeaders();

    // Translating ASP.NET 4's HttpContext.Response.CacheControl 
    responseHeaders.CacheControl = new CacheControlHeaderValue
    {
        MaxAge = new System.TimeSpan(365, 0, 0, 0)
        // Many more properties available 
    };

    // If you use .NET Framework 4.6+, Task.CompletedTask will be a bit faster
    return Task.FromResult(0);
}

HttpContext 响应。 Cookie些

Cookie在*设置 Cookie *响应标头中传递到浏览器。 因此,发送需要与 cookie 用于发送响应标头的回调相同:

C#复制

public async Task Invoke(HttpContext httpContext)
{
    // ...
    httpContext.Response.OnStarting(SetCookies, state: httpContext);
    httpContext.Response.OnStarting(SetHeaders, state: httpContext);

SetCookies回调方法将如下所示:

C#复制

private Task SetCookies(object context)
{
    var httpContext = (HttpContext)context;

    IResponseCookies responseCookies = httpContext.Response.Cookies;

    responseCookies.Append("cookie1name", "cookie1value");
    responseCookies.Append("cookie2name", "cookie2value",
        new CookieOptions { Expires = System.DateTime.Now.AddDays(5), HttpOnly = true });

    // If you use .NET Framework 4.6+, Task.CompletedTask will be a bit faster
    return Task.FromResult(0); 
}

其他资源

 

©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页