.NET本身就是一个基于中间件（middleware）的框架，它通过一系列的中间件组件来处理HTTP请求和响应。因此，本篇文章主要描述从用户键入请求到服务器响应的大致流程，并深入探讨.NET通过kestrel将HTTP报文转换为HttpContext对象。

通过本文，您可以了解以下内容：

• http的数据流转流程
• 源码解读kestrel服务器的运作流程及生成HttpContext对象

一、HTTP请求的数据流转过程

HTTP 请求的数据流转过程非常复杂，涉及多个协议层次和网络设备。通过数据流转示意图可以简要了解该流程：

1. DNS 解析

客户端浏览器会首先尝试从本地缓存中查找目标服务器的 IP 地址。如果缓存中没有该域名对应的 IP 地址，则会向本地 DNS 服务器发起 DNS 查询请求。

DNS 服务器会根据域名信息向上级 DNS 服务器发送递归查询请求，直到找到能够返回该域名对应 IP 地址的 DNS 服务器为止。最终，DNS 服务器将目标服务器的 IP 地址返回给客户端浏览器。

2.TCP 连接

TCP 连接需要经过三次握手的过程：

• 第一次握手：客户端发送 SYN 包，表示请求建立连接。
• 第二次握手：服务器返回 SYN+ACK 包，表示同意建立连接。
• 第三次握手：客户端发送 ACK 包，表示确认连接已建立。

当客户端和服务器完成三次握手后，TCP 连接就建立成功了。

1. 应用层发送HTTP请求

用户在浏览器中输入URL后，浏览器会向应用层发送HTTP请求。请求报文包含请求方法、URI、协议版本和请求头信息等。

1. 传输层封装TCP协议数据段

传输层负责将HTTP请求报文分成若干个数据段进行传输，并使用TCP协议对这些数据段进行封装。

1. 网络层路由选择和寻址

网络层负责对TCP数据段进行分组，并通过IP协议进行路由选择和寻址，以便将数据包从本地网络送到目标服务器。

1. 数据链路层封装数据帧

数据链路层将IP数据包封装为数据帧，并添加源和目标MAC地址，以便在物理层上进行传输。

1. 物理层传输比特流

物理层将数据帧转换为比特流，并通过物理介质（如网线、无线电波等）将数据发送到目标服务器。

1. 服务器接收HTTP请求

当数据包到达目标服务器后，网络协议栈会解析数据包，并将HTTP请求报文交给Web服务器处理。

1. .NET服务器处理HTTP请求

Web服务器处理HTTP请求，包括解析HTTP请求报文、映射URL到相应的处理器、执行请求处理程序，并生成HTTP响应报文等。

1. 传输层封装TCP协议数据段

Web服务器生成HTTP响应报文之后，通过TCP协议将响应数据分成若干个数据段进行封装。

1. 数据链路层封装数据帧

数据链路层将TCP数据段封装为数据帧，并添加源和目标MAC地址。

1. 物理层传输比特流

物理层将数据帧转换为比特流，并通过物理介质（如网线、无线电波等）将数据发送回客户端浏览器。

1. 应用层接收HTTP响应

客户端浏览器收到HTTP响应报文后，会交给应用层进行解析和处理。响应报文包含状态行、响应头和响应体等信息。

通过上文，我们已经了解了 HTTP 请求数据流转的基本过程。下图展示了数据从 HTTP 数据开始，逐层添加 TCP、IP、以太网头部，然后在每个层次进行解析，最终抵达目标服务器。

下边贴一张网络包的报文数据格式图：

想深入了解更多计算机网络知识的同学，可以自行查阅书籍和资料，这里有位博主总结的很好，地址：小林coding

二、认识kestrel和HttpContext

Kestrel 是一个基于libuv的跨平台Web 服务器，是.NET中默认启用的 Web 服务器，可以处理来自客户端的 HTTP 请求和响应。

图一 内网访问程序

图二 反向代理访问程序

HttpContext保存有关 Http 请求的当前信息。它包含授权，身份验证，请求，响应，会话，项目，用户，表单选项等信息。收到每个 HTTP 请求时，HttpContext都会初始化一个包含当前信息的新对象。

想要了解更多HttpContext对象的属性和方法，请直接参阅官方文档

• 使用 .NET Core 内置依赖项注入容器注册依赖项，如下所示的 Startup.cs配置服务类方法：

  // 注入IHttpContextAccessor服务
  builder.Services.AddHttpContextAccessor();

  // 自定义服务中访问HttpContext
  public 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对象

以下是源代码的部分删减和修改，以便于更好地理解

我们从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();

      services.AddTransient<IConfigureOptions<KestrelServerOptions>, KestrelServerOptionsSetup>();
      services.AddSingleton<IHttpsConfigurationService, HttpsConfigurationService>();
      services.AddSingleton<IServer, KestrelServerImpl>();
      services.AddSingleton<KestrelMetrics>();
  });
  return hostBuilder;

  }

从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处理传入的请求

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,万分感谢_)