.NET 本身就是一个基于中间件（middleware）的框架，它通过一系列的中间件组件来处理 HTTP 请求和响应。因此，本篇文章主要描述从用户键入请求到服务器响应的大致流程，并深入探讨.NET 通过 kestrel 将 HTTP 报文转换为 HttpContext 对象。
通过本文，您可以了解以下内容：
一、HTTP 请求的数据流转过程
1、数据流转
HTTP 请求的数据流转过程非常复杂，涉及多个协议层次和网络设备。通过数据流转示意图可以简要了解该流程：
1.DNS 连接
客户端浏览器会首先尝试从本地缓存中查找目标服务器的 IP 地址。如果缓存中没有该域名对应的 IP 地址，则会向本地 DNS 服务器发起 DNS 查询请求。
DNS 服务器会根据域名信息向上级 DNS 服务器发送递归查询请求，直到找到能够返回该域名对应 IP 地址的 DNS 服务器为止。最终，DNS 服务器将目标服务器的 IP 地址返回给客户端浏览器。
2.TCP 连接
TCP 连接需要经过三次握手的过程：
第一次握手：客户端发送 SYN 包，表示请求建立连接。
第二次握手：服务器返回 SYN+ACK 包，表示同意建立连接。
第三次握手：客户端发送 ACK 包，表示确认连接已建立。
当客户端和服务器完成三次握手后，TCP 连接就建立成功了。
3.应用层发送 HTTP 请求
用户在浏览器中输入 URL 后，浏览器会向应用层发送 HTTP 请求。请求报文包含请求方法、URI、协议版本和请求头信息等。
4.传输层封装 TCP 协议数据段
传输层负责将 HTTP 请求报文分成若干个数据段进行传输，并使用 TCP 协议对这些数据段进行封装。
5.网络层路由选择和寻址
网络层负责对 TCP 数据段进行分组，并通过 IP 协议进行路由选择和寻址，以便将数据包从本地网络送到目标服务器。
6.数据链路层封装数据帧
数据链路层将 IP 数据包封装为数据帧，并添加源和目标 MAC 地址，以便在物理层上进行传输。
7.物理层传输比特流
物理层将数据帧转换为比特流，并通过物理介质（如网线、无线电波等）将数据发送到目标服务器。
8.服务器接收 HTTP 请求
当数据包到达目标服务器后，网络协议栈会解析数据包，并将 HTTP 请求报文交给 Web 服务器处理。
9.NET 服务器处理 HTTP 请求
Web 服务器处理 HTTP 请求，包括解析 HTTP 请求报文、映射 URL 到相应的处理器、执行请求处理程序，并生成 HTTP 响应报文等。
10.传输层封装 TCP 协议数据段
Web 服务器生成 HTTP 响应报文之后，通过 TCP 协议将响应数据分成若干个数据段进行封装。
11.数据链路层封装数据帧
数据链路层将 TCP 数据段封装为数据帧，并添加源和目标 MAC 地址。
12.物理层传输比特流
物理层将数据帧转换为比特流，并通过物理介质（如网线、无线电波等）将数据发送回客户端浏览器。
13.应用层接收 HTTP 响应
客户端浏览器收到 HTTP 响应报文后，会交给应用层进行解析和处理。响应报文包含状态行、响应头和响应体等信息。
通过上文，我们已经了解了 HTTP 请求数据流转的基本过程。下图展示了数据从 HTTP 数据开始，逐层添加 TCP、IP、以太网头部，然后在每个层次进行解析，最终抵达目标服务器。
2、报文数据格式
下边贴一张网络包的报文数据格式图：
想深入了解更多计算机网络知识的同学，可以自行查阅书籍和资料，这里有位博主总结的很好，地址：小林coding
二、认识 kestrel 和 HttpContext
1.kestrel 的作用
Kestrel 是一个基于 libuv 的跨平台 Web 服务器，是.NET 中默认启用的 Web 服务器，可以处理来自客户端的 HTTP 请求和响应。
图一 内网访问程序
图二 反向代理访问程序
2.什么是 HttpContext？
HttpContext 保存有关 Http 请求的当前信息。它包含授权，身份验证，请求，响应，会话，项目，用户，表单选项等信息。收到每个 HTTP 请求时，HttpContext 都会初始化一个包含当前信息的新对象。
想要了解更多 HttpContext 对象的属性和方法，请直接参阅官方文档
3..NET 中如何访问 HttpContext 使用
// 注入IHttpContextAccessor服务builder.Services.AddHttpContextAccessor();
// 自定义服务中访问HttpContextpublic class UserRepository : IUserRepository{ private readonly IHttpContextAccessor _httpContextAccessor;
public UserRepository(IHttpContextAccessor httpContextAccessor) => _httpContextAccessor = httpContextAccessor;
public void LogCurrentUser() { var username = _httpContextAccessor.HttpContext.User.Identity.Name;
// ... }}
复制代码
更多的访问方式请自行查阅官方文档
三、源码解读 kestrel 创建 HttpContext 对象
以下是源代码的部分删减和修改，以便于更好地理解
1. 创建主机构建器
我们从 Program 开始，使用 CreateBuilder 方法创建一个默认的主机构建器，配置应用程序的默认设置以及注入基础服务。
// 在Program.cs文件中调用var builder = WebApplication.CreateBuilder(args);
// CreateBuilder方法返回了WebApplicationBuilder实例public static WebApplicationBuilder CreateBuilder(string[] args) => new WebApplicationBuilder(new WebApplicationOptions(){ Args = args });
复制代码
在 WebApplicationBuilder 类的构造函数中，关于配置 Configuration 和 IOC 容器相关的已经在历史文章中做过解读。本文在看下几个主机构建器的关系和作用:
BootstrapHostBuilder 是一个基本的主机构建器，构建默认的主机（Host）和服务容器（Service Container）
IHostBuilder 定义了一组用于配置主机的方法，并返回一个 IHost 实例。使用 IHostBuilder 可以自定义应用程序的配置信息，如应用程序的环境、日志记录、配置文件等
ConfigureHostBuilder 扩展了 IHostBuilder 接口，并添加了一些特定主机的配置选项，例如应用程序名称、配置文件路径、日志、依赖注入等，可以根据需要进行扩展和定制。
ConfigureWebHostBuilder 是 ConfigureHostBuilder 的子类，主要用于处理与 Web 主机相关的配置，例如 Kestrel 服务器选项、HTTPS 配置、Web 根目录等
这几个的关系简单来讲就是通过 BootstrapHostBuilder 和 IHostBuilder 创建主机构建器，然后使用 ConfigureHostBuilder 和 ConfigureWebHostBuilder 扩展方法设置所需的选项，最终创建主机和服务容器实例
internal WebApplicationBuilder(WebApplicationOptions options, Action<IHostBuilder>? configureDefaults = null){ // configuration将在后续的配置中提供应用程序选项和参数 var configuration = new ConfigurationManager(); configuration.AddEnvironmentVariables(prefix: "ASPNETCORE_");
// 创建一个 HostApplicationBuilder 对象，并将其中包含的设置初始化为从 WebApplicationOptions 对象中获取的值 _hostApplicationBuilder = new HostApplicationBuilder(new HostApplicationBuilderSettings { Args = options.Args, ApplicationName = options.ApplicationName, EnvironmentName = options.EnvironmentName, ContentRootPath = options.ContentRootPath, Configuration = configuration, });
// 创建BootstrapHostBuilder实例 var bootstrapHostBuilder = new BootstrapHostBuilder(_hostApplicationBuilder);
// bootstrapHostBuilder 上调用 ConfigureWebHostDefaults 方法，以进行特定于 Web 主机的配置 bootstrapHostBuilder.ConfigureWebHostDefaults(webHostBuilder => { //...... });
var webHostContext = (WebHostBuilderContext)bootstrapHostBuilder.Properties[typeof(WebHostBuilderContext)]; Environment = webHostContext.HostingEnvironment;
Host = new ConfigureHostBuilder(bootstrapHostBuilder.Context, Configuration, Services); WebHost = new ConfigureWebHostBuilder(webHostContext, Configuration, Services);}
复制代码
使用 Kestrel 构建默认主机
internal static void ConfigureWebDefaults(IWebHostBuilder builder){ ConfigureWebDefaultsWorker( builder.UseKestrel(ConfigureKestrel), services => { services.AddRouting(); });}
public static IWebHostBuilder UseKestrel(this IWebHostBuilder hostBuilder, Action<WebHostBuilderContext, KestrelServerOptions> configureOptions){ return hostBuilder.UseKestrel().ConfigureKestrel(configureOptions);}
复制代码
配置 WebHost 在 Kestrel 服务器上运行，并通过 QUIC 协议实现高效数据传输的方式
public static IWebHostBuilder UseKestrel(this IWebHostBuilder hostBuilder){ return hostBuilder .UseKestrelCore() .UseKestrelHttpsConfiguration() .UseQuic(options => { // Configure server defaults to match client defaults. // https://github.com/dotnet/runtime/blob/a5f3676cc71e176084f0f7f1f6beeecd86fbeafc/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/ConnectHelper.cs#L118-L119 options.DefaultStreamErrorCode = (long)Http3ErrorCode.RequestCancelled; options.DefaultCloseErrorCode = (long)Http3ErrorCode.NoError; });}
复制代码
重点看下 UseKestrelCore 方法，该方法将 Kestrel 服务器应用到主机构建器的上下文中，并配置相关的服务
IConnectionListenerFactory：负责创建和管理传输连接
KestrelServerOptions：负责配置 Kestrel 服务器选项，例如端口号、连接数等
IHttpsConfigurationService：负责 HTTPS 支持，例如配置证书、加密算法等
IServer：指定 KestrelServerImpl 作为其实现类。这个服务是 Kestrel 服务器的核心实现，它接收来自客户端的请求并返回响应
KestrelMetrics:收集和报告有关 Kestrel 服务器运行状况的数据
public static IWebHostBuilder UseKestrelCore(this IWebHostBuilder hostBuilder){ hostBuilder.ConfigureServices(services => { // Don't override an already-configured transport services.TryAddSingleton<IConnectionListenerFactory, SocketTransportFactory>();
services.AddTransient<IConfigureOptions<KestrelServerOptions>, KestrelServerOptionsSetup>(); services.AddSingleton<IHttpsConfigurationService, HttpsConfigurationService>(); services.AddSingleton<IServer, KestrelServerImpl>(); services.AddSingleton<KestrelMetrics>(); }); return hostBuilder;}
复制代码
2. 启动主机，并侦听 HTTP 请求
从 Program 中 app.Run()开始，启动主机，最终会调用 IHost 的 StartAsync 方法。
app.Run();
public void Run([StringSyntax(StringSyntaxAttribute.Uri)] string? url = null){ Listen(url); HostingAbstractionsHostExtensions.Run(this);}
public static async Task RunAsync(this IHost host, CancellationToken token = default){ try { await host.StartAsync(token).ConfigureAwait(false);
await host.WaitForShutdownAsync(token).ConfigureAwait(false); } finally { if (host is IAsyncDisposable asyncDisposable) { await asyncDisposable.DisposeAsync().ConfigureAwait(false); } else { host.Dispose(); } }}
复制代码
将中间件和 StartupFilters 扩展传入 HostingApplication 主机，并进行启动
public async Task StartAsync(CancellationToken cancellationToken){ // ...省略了从配置中获取服务器监听地址和端口...
// 这个东西就是中间件，下篇文章再重点解读 RequestDelegate? application = null; try { IApplicationBuilder builder = ApplicationBuilderFactory.CreateBuilder(Server.Features);
foreach (var filter in StartupFilters.Reverse()) { configure = filter.Configure(configure); } configure(builder); // Build the request pipeline application = builder.Build(); } catch (Exception ex) { Logger.ApplicationError(ex); }
/* * application:中间件 * DiagnosticListener:事件监听器 * HttpContextFactory：HttpContext对象的工厂 */ HostingApplication httpApplication = new HostingApplication(application, Logger, DiagnosticListener, ActivitySource, Propagator, HttpContextFactory, HostingEventSource.Log, HostingMetrics);
await Server.StartAsync(httpApplication, cancellationToken);
}
复制代码
KestrelServerImpl 类中实现 Server.StartAsync 方法，用于在指定地址和端口上开启 HTTP 服务。本篇文章只会解读 http2 的实现流程，http3 的如果您感兴趣，请自行查阅源码。
public async Task StartAsync<TContext>(IHttpApplication<TContext> application, CancellationToken cancellationToken) where TContext : notnull{ // 用于处理与绑定事件相关的逻辑 async Task OnBind(ListenOptions options, CancellationToken onBindCancellationToken) { // ...省略 获取是否支持Http1/2/3/协议及TLS加密，及判断至少支持一种协议...
if (hasHttp1 || hasHttp2 || options.Protocols == HttpProtocols.None) { // 调用UseHttpServer方法，为HTTP连接配置中间件、应用程序请求处理成中间件 options.UseHttpServer(ServiceContext, application, options.Protocols, addAltSvcHeader); ConnectionDelegate connectionDelegate = options.Build();
// 添加连接限制中间件 connectionDelegate = EnforceConnectionLimit(connectionDelegate, Options.Limits.MaxConcurrentConnections, Trace, ServiceContext.Metrics);
// 开始监听指定地址和端口上的HTTP请求 options.EndPoint = await _transportManager.BindAsync(configuredEndpoint, connectionDelegate, options.EndpointConfig, onBindCancellationToken).ConfigureAwait(false); }
//...省略http3... }
AddressBindContext = new AddressBindContext(_serverAddresses, Options, Trace, OnBind);
await BindAsync(cancellationToken).ConfigureAwait(false);}
复制代码
UseHttpServer 方法是将创建连接，解析等功能创建成委托中间件。在_transportManager.BindAsync 方法中，启动监听后执行。我们先跳过 UseHttpServer 方法，先看下启动监听的方法。
public async Task<EndPoint> BindAsync(EndPoint endPoint, ConnectionDelegate connectionDelegate, EndpointConfig? endpointConfig, CancellationToken cancellationToken){ // 遍历所有的ITransportFactory对象，并查找可以对指定地址和端口进行绑定的工厂对象 foreach (var transportFactory in _transportFactories) { var selector = transportFactory as IConnectionListenerFactorySelector; if (CanBindFactory(endPoint, selector)) { // 调用其BindAsync方法，在指定地址和端口上启动传输通道（Transport） var transport = await transportFactory.BindAsync(endPoint, cancellationToken).ConfigureAwait(false);
// 启动循环接收传入连接。对于每个新连接请求，ConnectionListener都会创建一个新的ConnectionContext对象，并将其传递给连接处理委托（ConnectionDelegate）进行处理 StartAcceptLoop(new GenericConnectionListener(transport), c => connectionDelegate(c), endpointConfig); return transport.EndPoint; } }}
复制代码
该方法使用 IConnectionListener 接口创建一个新的连接监听器（ConnectionListener），并启动一个循环以便不断接收传入的连接请求。对于每个新连接请求，它都会创建一个新的 BaseConnectionContext 对象，并将其传递给连接处理委托进行相应的操作
private void StartAcceptLoop<T>(IConnectionListener<T> connectionListener, Func<T, Task> connectionDelegate, EndpointConfig? endpointConfig) where T : BaseConnectionContext{ var transportConnectionManager = new TransportConnectionManager(_serviceContext.ConnectionManager);
var connectionDispatcher = new ConnectionDispatcher<T>(_serviceContext, connectionDelegate, transportConnectionManager);
var acceptLoopTask = connectionDispatcher.StartAcceptingConnections(connectionListener);
_transports.Add(new ActiveTransport(connectionListener, acceptLoopTask, transportConnectionManager, endpointConfig));}
复制代码
线程池中通过 while 循环不断监听连接请求
public Task StartAcceptingConnections(IConnectionListener<T> listener){ ThreadPool.UnsafeQueueUserWorkItem(StartAcceptingConnectionsCore, listener, preferLocal: false); return _acceptLoopTcs.Task;}private void StartAcceptingConnectionsCore(IConnectionListener<T> listener){ // REVIEW: Multiple accept loops in parallel? _ = AcceptConnectionsAsync();
async Task AcceptConnectionsAsync() { try { while (true) { var connection = await listener.AcceptAsync(); if (connection == null) { // We're done listening break; } // 创建一个新的连接Id var id = _transportConnectionManager.GetNewConnectionId();
var metricsContext = Metrics.CreateContext(connection);
var kestrelConnection = new KestrelConnection<T>( id, _serviceContext, _transportConnectionManager, _connectionDelegate, connection, Log, metricsContext);
_transportConnectionManager.AddConnection(id, kestrelConnection); Metrics.ConnectionQueuedStart(metricsContext);
ThreadPool.UnsafeQueueUserWorkItem(kestrelConnection, preferLocal: false); } } }}
复制代码
IThreadPoolWorkItem 执行方法就是调用了我们上文中，先跳过的委托部分
void IThreadPoolWorkItem.Execute(){ using (BeginConnectionScope(connectionContext)) { try { await _connectionDelegate(connectionContext); } catch (Exception ex) { } }}
复制代码
回到上文中的 UseHttpServer 方法，该方法中创建 HttpConnectionMiddleware 对象，用于封装处理 HTTP 连接和请求的中间件
public static IConnectionBuilder UseHttpServer<TContext>(this IConnectionBuilder builder, ServiceContext serviceContext, IHttpApplication<TContext> application, HttpProtocols protocols, bool addAltSvcHeader) where TContext : notnull{ var middleware = new HttpConnectionMiddleware<TContext>(serviceContext, application, protocols, addAltSvcHeader); return builder.Use(next => { // 实际的请求处理 return middleware.OnConnectionAsync; });}创建HttpConnection对象，并调用ProcessRequestsAsync处理传入的请求
C#
public Task OnConnectionAsync(ConnectionContext connectionContext){ var httpConnectionContext = new HttpConnectionContext();
var connection = new HttpConnection(httpConnectionContext);
return connection.ProcessRequestsAsync(_application);}
复制代码
创建 Http2Connection 连接对象，并注册停止清理事件，调用 ProcessRequestsAsync 方法处理请求
public async Task ProcessRequestsAsync<TContext>(IHttpApplication<TContext> httpApplication) where TContext : notnull{ IRequestProcessor? requestProcessor = new Http2Connection((HttpConnectionContext)_context);
if (requestProcessor != null) { // 注册停止处理请求事件 using var shutdownRegistration = connectionLifetimeNotificationFeature?.ConnectionClosedRequested.Register(state => ((HttpConnection)state!).StopProcessingNextRequest(), this);
// 注册执行清理操作事件 using var closedRegistration = _context.ConnectionContext.ConnectionClosed.Register(state => ((HttpConnection)state!).OnConnectionClosed(), this);
await requestProcessor.ProcessRequestsAsync(httpApplication); } }
复制代码
从 ProcessRequestsAsync 方法就进入核心解析环节了，该方法负责读取和解析传入的 HTTP/2 帧，并执行相应的操作来处理请求。为了保证性能和可靠性，该方法中还使用了心跳检测、流量控制和超时控制等技巧。
通过循环读取数据并使用 ProcessFrameAsync 方法处理传入的 HTTP/2 帧，直到收到终止连接的帧或者出现错误。
private Task ProcessFrameAsync<TContext>(IHttpApplication<TContext> application, in ReadOnlySequence<byte> payload) where TContext : notnull{ // 请求流标识符必须是奇数 if (_incomingFrame.StreamId != 0 && (_incomingFrame.StreamId & 1) == 0) { throw new Http2ConnectionErrorException(CoreStrings.FormatHttp2ErrorStreamIdEven(_incomingFrame.Type, _incomingFrame.StreamId), Http2ErrorCode.PROTOCOL_ERROR); } // 根据帧类型分发到不同的处理方法中 return _incomingFrame.Type switch { Http2FrameType.DATA => ProcessDataFrameAsync(payload), Http2FrameType.HEADERS => ProcessHeadersFrameAsync(application, payload), Http2FrameType.PRIORITY => ProcessPriorityFrameAsync(), Http2FrameType.RST_STREAM => ProcessRstStreamFrameAsync(), Http2FrameType.SETTINGS => ProcessSettingsFrameAsync(payload), Http2FrameType.PUSH_PROMISE => throw new Http2ConnectionErrorException(CoreStrings.Http2ErrorPushPromiseReceived, Http2ErrorCode.PROTOCOL_ERROR), Http2FrameType.PING => ProcessPingFrameAsync(payload), Http2FrameType.GOAWAY => ProcessGoAwayFrameAsync(), Http2FrameType.WINDOW_UPDATE => ProcessWindowUpdateFrameAsync(), Http2FrameType.CONTINUATION => ProcessContinuationFrameAsync(payload), _ => ProcessUnknownFrameAsync(), };}
复制代码
读取 ProcessHeadersFrameAsync 头部数据时，如果是新的数据，就开启新的数据流
private Task ProcessHeadersFrameAsync<TContext>(IHttpApplication<TContext> application, in ReadOnlySequence<byte> payload) where TContext : notnull{ // ......
// 开始一个新的Stream _currentHeadersStream = GetStream(application);
_headerFlags = _incomingFrame.HeadersFlags; // 荷载数据 var headersPayload = payload.Slice(0, _incomingFrame.HeadersPayloadLength);
// 解析请求头部数据 return DecodeHeadersAsync(_incomingFrame.HeadersEndHeaders, headersPayload); }
private Task DecodeHeadersAsync(bool endHeaders, in ReadOnlySequence<byte> payload){ _highestOpenedStreamId = _currentHeadersStream.StreamId; // 解码数据 _hpackDecoder.Decode(payload, endHeaders, handler: this); // 当头部信息解码完成，开启新的数据流并重置处理状态，迎接下一个请求 if (endHeaders) { _currentHeadersStream.OnHeadersComplete(); StartStream(); ResetRequestHeaderParsingState(); }
return Task.CompletedTask;}
复制代码
Decode 解码方法中使用 HPACK 算法和状态机算法对 HTTP/2 请求头部进行解码。本篇文章中就不继续深究了......
StartStream 方法用于处理 HTTP/2 的流开始，并进行一些相关的检查和操作，如添加到流字典、计数增加、验证标头等。在做了诸多校验工作后，进行执行。
private void StartStream(){ // _scheduleInline 仅在测试中为 true if (!_scheduleInline) { // 不能让应用程序代码阻塞连接处理循环。 ThreadPool.UnsafeQueueUserWorkItem(_currentHeadersStream, preferLocal: false); } else { _currentHeadersStream.Execute(); }}
复制代码
Execute 方法在处理请求之前进行一些日志记录和度量统计操作，并调用异步方法 ProcessRequestsAsync() 来处理请求
public override void Execute(){ KestrelEventSource.Log.RequestQueuedStop(this, AspNetCore.Http.HttpProtocol.Http2); ServiceContext.Metrics.RequestQueuedStop(MetricsContext, AspNetCore.Http.HttpProtocol.Http2);
// REVIEW: Should we store this in a field for easy debugging? _ = ProcessRequestsAsync(_application);}
复制代码
ProcessRequests 是异步处理请求的方法。使用循环来处理多个请求，并在每个请求处理的不同阶段执行相应的操作，如解析请求、运行应用程序代码、发送响应等。同时，它还处理了各种异常情况，并记录日志。循环会一直执行，直到保持连接的标志 _keepAlive 被设置为 false 或需要结束连接。并在此处创建了 HttpContext 对象
private async Task ProcessRequests<TContext>(IHttpApplication<TContext> application) where TContext : notnull{ while (_keepAlive) { BeginRequestProcessing();
// 尝试解析请求，直到成功解析请求或者需要结束连接 var result = default(ReadResult); bool endConnection; do { if (BeginRead(out var awaitable)) { result = await awaitable; } } while (!TryParseRequest(result, out endConnection));
if (endConnection) { // 连接已经结束，停止处理请求 return; }
// 创建消息体 var messageBody = CreateMessageBody(); if (!messageBody.RequestKeepAlive) { _keepAlive = false; }
// 初始化请求体控制器 InitializeBodyControl(messageBody);
// 创建上下文对象 var context = application.CreateContext(this);
// 运行应用程序对该请求的处理代码 await application.ProcessRequestAsync(context);
// 方法停止请求体控制器 await _bodyControl.StopAsync();
// 释放上下文对象 application.DisposeContext(context, _applicationException);
// 回到 while 循环的开头，继续处理下一个请求
}}
复制代码
该方法接受一个 IFeatureCollection 类型的参数，并返回一个 HttpContext 对象
public HttpContext CreateContext(IFeatureCollection contextFeatures){ return _httpContextFactory?.Create(contextFeatures) ?? new DefaultHttpContext(contextFeatures);}
复制代码
初始化 DefaultHttpContext 对象的 _features、_request 和 _response 成员变量，并创建与当前上下文相关联的默认的请求和响应对象
public DefaultHttpContext(IFeatureCollection features){ _features.Initalize(features); _request = new DefaultHttpRequest(this); _response = new DefaultHttpResponse(this);}
复制代码
四、小结
通过本篇文章可以深入了解了 HTTP 请求的数据流转过程。了解了数据在客户端和服务器之间的流动方式，以及 HTTP 报文的结构。
此外，我们还对 Kestrel 进行了源码解读，并了解了如何创建和管理 HttpContext。Kestrel 作为高性能的 Web 服务器，扮演着连接客户端和应用程序的桥梁，而 HttpContext 则提供了对请求和响应的上下文信息和处理能力。
通过深入研究和理解 HTTP 请求的数据流转过程以及 Kestrel 和 HttpContext 的工作原理，我们可以清晰的认知到整个运作流程。当然还有很多细节没有表述，在以后遇见问题的时候，可以快速定位问题或者查阅相关模块代码。以及了解如何去定制想要的扩展功能。
题外话：
由于我阅读时喜欢一次性阅读完整篇文章，因此我写文章时常常会花费很长时间，这也导致我的文章变得相对较长。我也会考虑你是否有足够的耐心和时间来阅读整篇文章，如果你有好写作技巧，请指教。总之，完成一篇长文后，我会感到非常舒适和满足，很有成就感！
如果您觉得这篇文章有所收获，还请点个赞并关注。如果您有宝贵建议，欢迎在评论区留言，非常感谢您的支持！
文章转载自：Broder
原文链接：https://www.cnblogs.com/Z7TS/p/17459777.html
评论