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

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

重新访问模块和处理程序

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

模块处理程序

处理程序包括:

  • 实现 IHttpHandler 的类

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

  • Web.config

模块包括:

  • 实现 IHttpModule 的类

  • 针对每个请求调用

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

  • 能够添加到 HTTP 响应,或创建自己的

  • Web.config

模块处理传入请求的顺序取决于:

  1. 由 ASP.NET(如 和 )触发的 BeginRequest 序列事件 AuthenticateRequest 。 有关完整列表,请参见System.Web.HttpApplication。 每个模块都可以为一个或多个事件创建处理程序。

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

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

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

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

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

  • 模块和处理程序的角色已由中间件接管

  • 中间件是使用代码而不是在Web.config

  • 管道分支 使你能够基于 URL 以及请求标头、查询字符串等向特定中间件发送请求。
  • 管道分支 使你能够基于 URL 以及请求标头、查询字符串等向特定中间件发送请求。

中间件与模块非常相似:

  • 针对每个请求原则调用

  • 能够通过不将请求传递到下一个中间件来使请求 短路

  • 能够创建自己的 HTTP 响应

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

授权中间件使未获授权的用户的请求短路。 MVC 中间件允许和处理对"索引"页的请求。 自定义报表中间件允许和处理对销售报表的请求。

请注意上图中的身份验证中间件如何使请求短路。

将模块代码迁移到中间件

现有的 HTTP 模块将类似于:

// 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 。 新的中间件将如下所示:

// 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 帮助程序类,可以更轻松地在类中配置中间 Startup 件。 UseMyMiddleware方法将中间件类添加到请求管道。 中间件所需的服务将注入中间件的构造函数中。

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

// 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 中间件上调用 来处理这一点。 请记住,这不会完全终止请求,因为响应通过管道返回时,仍将调用以前的中间件。

// 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。

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

HTTP 模块通常使用 以下方法添加到请求 Web.config:

<?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 此类型:

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

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

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

如果排序成为问题,可以将模块拆分为多个可以单独排序的中间件组件。

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

HTTP 处理程序如下所示:

// 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项目中,可将其转换为类似于以下的中间件:

// 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 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 件的同一方法中执行此操作:

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。 这意味着可以将其他中间件添加到处理程序中间件前面的 分支。

在所有请求调用分支之前添加到管道的中间件;分支对它们没有影响。

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

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

新的 配置系统 提供了以下选项来解决此问题:

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

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

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

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

    此处的 MyMiddlewareOptionsSection 是一个节名称。 它不必与选项类的名称相同。

  3. 将选项值与 options 类关联

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

    更新 Startup 类:

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

      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. 配置选项服务:

      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. 将选项与选项类关联:

      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. 将选项注入中间件构造函数。 这类似于将选项注入控制器。

    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 对象。 中间件所需的任何其他对象都可以这样注入。

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

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

但是,如果要使用两次同一中间件,但具有不同的选项,则此操作会中断。 例如,在不同分支中使用的授权中间件,允许不同的角色。 不能将两个不同的选项对象与一个选项类关联。

解决方法是获取类中具有实际选项值的选项对象,并直接将这些选项传递给中间 Startup 件的每个实例。

  1. 将第二个密钥添加到 appsettings.json

    若要向文件添加第二组选项, appsettings.json 请使用新密钥唯一标识它:

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

    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 中间件构造函数。

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

    请注意这如何将 options 对象包装在 OptionsWrapper 对象中。 这将按 IOptions 中间件构造函数的预期实现 。

迁移到新的 HttpContext

你之前看到中间 Invoke 件中的 方法采用 类型的参数 HttpContext

public async Task Invoke(HttpContext context)

HttpContext已显著更改了 ASP.NET Core。 本部分演示如何将 System.Web.HttpContext 最常用的属性转换为新的 Microsoft.AspNetCore.Http.HttpContext

HttpContext

HttpContext.Items 转换为:

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

唯一请求 ID (System.Web.HttpContext 对应)

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

string requestId = httpContext.TraceIdentifier;

HttpContext.Request

HttpContext.Request.HttpMethod 转换为:

string httpMethod = httpContext.Request.Method;

HttpContext.Request.QueryString 转换为:

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.Request.UrlHttpContext.Request.RawUrl 转换为:

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

HttpContext.Request.IsSecureConnection 转换为:

var isSecureConnection = httpContext.Request.IsHttps;

HttpContext.Request.UserHostAddress 转换为:

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

HttpContext.Request。 Cookies 转换为:

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

HttpContext.Request.RequestContext.RouteData 转换为:

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

HttpContext.Request.Headers 转换为:

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

HttpContext.Request.UserAgent 转换为:

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

HttpContext.Request.UrlReferrer 转换为:

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

HttpContext.Request.ContentType 转换为:

// 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.Request.Form 转换为:

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"];
}

警告

仅在内容子类型为 x-www-form-urlencodedform-data 时读取窗体值

HttpContext.Request.InputStream 转换为:

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

警告

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

每个请求只能读取上述原始正文一次。 第一次读取后尝试读取正文的中间件将读取空正文。

这不适用于读取前面所示的窗体,因为这从缓冲区完成。

HttpContext.Response

HttpContext.Response.StatusHttpContext.Response.StatusDescription 转换为:

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

HttpContext.Response.ContentEncodingHttpContext.Response.ContentType 转换为:

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

HttpContext.Response.ContentType 本身也转换为:

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

HttpContext.Response.Output 转换为:

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

HttpContext.Response.TransmitFile

中讨论了提供文件 ASP.NET Core 中的请求功能

HttpContext.Response.Headers

发送响应标头很复杂,因为如果在将任何内容写入响应正文后设置了响应标头,将不会发送它们。

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

以下代码设置名为 的回调方法 SetHeaders

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

SetHeaders回调方法如下所示:

// 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.Response。 Cookies

Cookie在 Set-response 标头中浏览 Cookie 到 浏览器。 因此,发送 cookie 需要与用于发送响应标头相同的回调:

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

SetCookies回调方法如下所示:

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

其他资源