ASP.NET Core 中的请求和响应操作Request and response operations in ASP.NET Core

本文内容

作者：Justin Kotalik

本文介绍如何读取请求正文和写入响应正文。写入中间件时，可能需要这些操作的代码。除写入中间件外，通常不需要自定义代码，因为操作由 MVC 和 Razor Pages 处理。

请求正文和响应正文有两个抽象元素：Stream 和 Pipe。对于请求读取，HttpRequest.Body 是 Stream，HttpRequest.BodyReader 是 PipeReader。对于响应写入，HttpResponse.Body 是 Stream，HttpResponse.BodyWriter 是 PipeWriter。

建议使用管道替代流。在一些简单操作中，使用流会比较简单，但管道具有性能优势，并且在大多数场景中更易于使用。ASP.NET Core 开始在内部使用管道替代流。示例包括：

  • FormReader
  • TextReader
  • TextWriter
  • HttpResponse.WriteAsync

流不会从框架中删除。流将继续在 .NET 中使用，并且许多流类型不具有等效的管道，如 FileStreams 和 ResponseCompression。

流示例Stream examples

假设目标是要创建一个中间件，它将整个请求正文作为一个字符串列表读取，并在新行上进行拆分。一个简单的流实现可能如下例所示：

  1. private async Task<List<string>> GetListOfStringsFromStream(Stream requestBody)
  2. {
  3.     // Build up the request body in a string builder.
  4.     StringBuilder builder = new StringBuilder();
  6.     // Rent a shared buffer to write the request body into.
  7.     byte[] buffer = ArrayPool<byte>.Shared.Rent(4096);
  9.     while (true)
  10.     {
  11.         var bytesRemaining = await requestBody.ReadAsync(buffer, offset: 0, buffer.Length);
  12.         if (bytesRemaining == 0)
  13.         {
  14.             break;
  15.         }
  17.         // Append the encoded string into the string builder.
  18.         var encodedString = Encoding.UTF8.GetString(buffer, 0, bytesRemaining);
  19.         builder.Append(encodedString);
  20.     }
  22.     ArrayPool<byte>.Shared.Return(buffer);
  24.     var entireRequestBody = builder.ToString();
  26.     // Split on \n in the string.
  27.     return new List<string>(entireRequestBody.Split("\n"));
  28. }

若要查看翻译为非英语语言的代码注释，请在 此 GitHub 讨论问题中告诉我们。

此代码有效，但存在一些问题：

  • 在追加到 StringBuilder 之前，示例创建另一个字符串 (encodedString)，该字符串会立即被丢弃。此过程发生在流中的所有字节上，因此结果是为整个请求正文大小分配额外的内存。
  • 该示例在新行上进行拆分之前读取整个字符串。检查字节数组中的新行会更有效。

下面是修复上面其中一些问题的示例：

  1. private async Task<List<string>> GetListOfStringsFromStreamMoreEfficient(Stream requestBody)
  2. {
  3.     StringBuilder builder = new StringBuilder();
  4.     byte[] buffer = ArrayPool<byte>.Shared.Rent(4096);
  5.     List<string> results = new List<string>();
  7.     while (true)
  8.     {
  9.         var bytesRemaining = await requestBody.ReadAsync(buffer, offset: 0, buffer.Length);
  11.         if (bytesRemaining == 0)
  12.         {
  13.             break;
  14.         }
  16.         // Instead of adding the entire buffer into the StringBuilder
  17.         // only add the remainder after the last \n in the array.
  18.         var prevIndex = 0;
  19.         int index;
  20.         while (true)
  21.         {
  22.             index = Array.IndexOf(buffer, (byte)'\n');
  23.             if (index == -1)
  24.             {
  25.                 break;
  26.             }
  28.             var encodedString = Encoding.UTF8.GetString(buffer, prevIndex, index);
  30.             if (builder.Length > 0)
  31.             {
  32.                 // If there was a remainder in the string buffer, include it in the next string.
  33.                 results.Add(builder.Append(encodedString).ToString());
  34.                 builder.Clear();
  35.             }
  36.             else
  37.             {
  38.                 results.Add(encodedString);
  39.             }
  41.             // Skip past last \n
  42.             prevIndex = index + 1;
  43.         }
  45.         var remainingString = Encoding.UTF8.GetString(buffer, index, bytesRemaining - index);
  46.         builder.Append(remainingString);
  47.     }
  49.     ArrayPool<byte>.Shared.Return(buffer);
  51.     return results;
  52. }

上面的此示例：

  • 不在 StringBuilder 中缓冲整个请求正文（除非没有任何换行符）。
  • 不在字符串上调用 Split。

然而，仍然存在一些问题：

  • 如果换行符稀疏，则大部分请求正文都在字符串中进行缓冲。
  • 该代码会继续创建字符串 (remainingString) 并将它们添加到字符串缓冲区，这将导致额外的分配。

这些问题是可修复的，但代码逐渐变得复杂，几乎没有什么改进。管道提供了一种以最低的代码复杂性解决这些问题的方法。

管道Pipelines

下面的示例显示了如何使用 PipeReader 处理相同的场景：

  1. private async Task<List<string>> GetListOfStringFromPipe(PipeReader reader)
  2. {
  3.     List<string> results = new List<string>();
  5.     while (true)
  6.     {
  7.         ReadResult readResult = await reader.ReadAsync();
  8.         var buffer = readResult.Buffer;
  10.         SequencePosition? position = null;
  12.         do
  13.         {
  14.             // Look for a EOL in the buffer
  15.             position = buffer.PositionOf((byte)'\n');
  17.             if (position != null)
  18.             {
  19.                 var readOnlySequence = buffer.Slice(0, position.Value);
  20.                 AddStringToList(ref results, in readOnlySequence);
  22.                 // Skip the line + the \n character (basically position)
  23.                 buffer = buffer.Slice(buffer.GetPosition(1, position.Value));
  24.             }
  25.         }
  26.         while (position != null);
  28.         // At this point, buffer will be updated to point one byte after the last
  29.         // \n character.
  30.         reader.AdvanceTo(buffer.Start, buffer.End);
  32.         if (readResult.IsCompleted)
  33.         {
  34.             break;
  35.         }
  36.     }
  38.     return results;
  39. }
  41. private static void AddStringToList(ref List<string> results, in ReadOnlySequence<byte> readOnlySequence)
  42. {
  43.     // Separate method because Span/ReadOnlySpan cannot be used in async methods
  44.     ReadOnlySpan<byte> span = readOnlySequence.IsSingleSegment ? readOnlySequence.First.Span : readOnlySequence.ToArray().AsSpan();
  45.     results.Add(Encoding.UTF8.GetString(span));
  46. }

此示例解决了流实现中的许多问题：

  • 不需要字符串缓冲区，因为 PipeReader 会处理未使用的字节。
  • 编码后的字符串将直接添加到返回的字符串列表。
  • 除了字符串使用的内存之外，无需再为创建的字符串分配内存（ToArray() 调用除外）。

适配器Adapters

Body 和 BodyReader/BodyWriter 属性均可用于 HttpRequest 和 HttpResponse。将 Body 设置为另一个流时，一组新的适配器会自动使每种类型彼此适应。如果将 HttpRequest.Body 设置为新流，则 HttpRequest.BodyReader 将自动设置为包装 HttpRequest.Body 的新 PipeReader。

StartAsyncStartAsync

HttpResponse.StartAsync 用于指示标头不可修改并运行 OnStarting 回调。使用 Kestrel 作为服务器时，在使用 PipeReader 之前调用 StartAsync 可确保 GetMemory 返回的内存属于 Kestrel 的内部 Pipe 而不是外部缓冲区。

其他资源Additional resources