😊 改进 带应用速率限制的流，尽可能减少误差

Author: monksoul

src/HttpAgent/src/HttpAgent.xml

@@ -6934,14 +6934,14 @@
         <member name="F:HttpAgent.RateLimitedStream._innerStream">
             <inheritdoc cref="T:System.IO.Stream" />
         </member>
-        <member name="F:HttpAgent.RateLimitedStream._startTime">
+        <member name="F:HttpAgent.RateLimitedStream._stopwatch">
             <summary>
-                流开始读取的时间点
+                用于精确计时的 <see cref="T:System.Diagnostics.Stopwatch" /> 实例
             </summary>
         </member>
-        <member name="F:HttpAgent.RateLimitedStream._totalBytesRead">
+        <member name="F:HttpAgent.RateLimitedStream._totalBytesProcessed">
             <summary>
-                到目前为止已读取的总字节数
+                到目前为止已读取或写入的总字节数
             </summary>
         </member>
         <member name="M:HttpAgent.RateLimitedStream.#ctor(System.IO.Stream,System.Int32)">
@@ -6993,7 +6993,7 @@
             <summary>
                 根据设定的速率限制调整读写操作的速度
             </summary>
-            <param name="bytesToRead">本次操作将处理的字节数。</param>
+            <param name="bytesToProcess">本次操作将处理的字节数</param>
         </member>
         <member name="T:HttpAgent.ServerSentEventsData">
             <summary>

src/HttpAgent/src/Models/RateLimitedStream.cs

@@ -18,14 +18,14 @@ public sealed class RateLimitedStream : Stream
     internal readonly Stream _innerStream;
 
     /// <summary>
-    ///     流开始读取的时间点
+    ///     用于精确计时的 <see cref="Stopwatch" /> 实例
     /// </summary>
-    internal readonly DateTime _startTime;
+    internal readonly Stopwatch _stopwatch = new();
 
     /// <summary>
-    ///     到目前为止已读取的总字节数
+    ///     到目前为止已读取或写入的总字节数
     /// </summary>
-    internal long _totalBytesRead;
+    internal long _totalBytesProcessed;
 
     /// <summary>
     ///     <inheritdoc cref="RateLimitedStream" />
@@ -49,8 +49,8 @@ public RateLimitedStream(Stream innerStream, int bytesPerSecond)
         _innerStream = innerStream;
         _bytesPerSecond = bytesPerSecond;
 
-        // 记录当前时间作为开始时间
-        _startTime = DateTime.UtcNow;
+        // 启动 Stopwatch 来开始计时
+        _stopwatch.Start();
     }
 
     /// <inheritdoc />
@@ -119,17 +119,17 @@ protected override void Dispose(bool disposing)
     /// <summary>
     ///     根据设定的速率限制调整读写操作的速度
     /// </summary>
-    /// <param name="bytesToRead">本次操作将处理的字节数。</param>
-    internal async Task ApplyRateLimitAsync(int bytesToRead)
+    /// <param name="bytesToProcess">本次操作将处理的字节数</param>
+    internal async Task ApplyRateLimitAsync(int bytesToProcess)
     {
         // 自开始以来经过的时间（秒）
-        var elapsedSeconds = (DateTime.UtcNow - _startTime).TotalSeconds;
+        var elapsedSeconds = _stopwatch.ElapsedMilliseconds / 1000.0;
 
         // 根据速率预期应读取的字节数
         var totalBytesExpected = elapsedSeconds * _bytesPerSecond;
 
         // 计算实际与预期之差
-        var bytesOverLimit = _totalBytesRead + bytesToRead - totalBytesExpected;
+        var bytesOverLimit = _totalBytesProcessed + bytesToProcess - totalBytesExpected;
 
         if (bytesOverLimit > 0)
         {
@@ -139,7 +139,7 @@ internal async Task ApplyRateLimitAsync(int bytesToRead)
             await Task.Delay(delayMilliseconds).ConfigureAwait(false);
         }
 
-        // 更新已读取的总字节数
-        _totalBytesRead += bytesToRead;
+        // 更新已处理的总字节数
+        _totalBytesProcessed += bytesToProcess;
     }
 }

src/HttpAgent/test/RateLimitedStreamTests.cs

@@ -25,13 +25,15 @@ public void New_ReturnOK()
         using var fileStream = File.OpenRead(filePath);
         using var rateLimitedStream = new RateLimitedStream(fileStream, 5);
 
-        Assert.Equal(0, rateLimitedStream._totalBytesRead);
+        Assert.Equal(fileStream, rateLimitedStream._innerStream);
+        Assert.Equal(0, rateLimitedStream._totalBytesProcessed);
         Assert.Equal(fileStream.CanRead, rateLimitedStream.CanRead);
         Assert.Equal(fileStream.CanSeek, rateLimitedStream.CanSeek);
         Assert.Equal(fileStream.CanWrite, rateLimitedStream.CanWrite);
         Assert.Equal(fileStream.CanTimeout, rateLimitedStream.CanTimeout);
         Assert.Equal(21, rateLimitedStream.Length);
         Assert.Equal(fileStream.Position, rateLimitedStream.Position);
+        Assert.NotNull(rateLimitedStream._stopwatch);
     }
 
     [Fact]