Enable CA2012 (Use ValueTask Correctly) (#31221)

stephentoub · web-flow · commit d86be87daa42 · 2021-03-26T13:31:10.000+13:00
diff --git a/.editorconfig b/.editorconfig
@@ -72,3 +72,9 @@ charset = utf-8-bom
 [*.{cs,vb}]
 # CA1305: Specify IFormatProvider
 dotnet_diagnostic.CA1305.severity = error
+
+[*.{cs,vb}]
+# CA2012: Use ValueTask correctly
+dotnet_diagnostic.CA2012.severity = warning
+[**/{test,perf}/**.{cs,vb}]
+dotnet_diagnostic.CA2012.severity = suggestion
diff --git a/src/Components/Components/src/Routing/Router.cs b/src/Components/Components/src/Routing/Router.cs
@@ -267,7 +267,7 @@ private void OnLocationChanged(object sender, LocationChangedEventArgs args)
             _locationAbsolute = args.Location;
             if (_renderHandle.IsInitialized && Routes != null)
             {
-                _ = RunOnNavigateAsync(NavigationManager.ToBaseRelativePath(_locationAbsolute), args.IsNavigationIntercepted);
+                _ = RunOnNavigateAsync(NavigationManager.ToBaseRelativePath(_locationAbsolute), args.IsNavigationIntercepted).Preserve();
             }
         }
 
diff --git a/src/Components/Server/src/Circuits/RemoteNavigationManager.cs b/src/Components/Server/src/Circuits/RemoteNavigationManager.cs
@@ -75,7 +75,7 @@ protected override void NavigateToCore(string uri, bool forceLoad)
                 throw new NavigationException(absoluteUriString);
             }
 
-            _jsRuntime.InvokeAsync<object>(Interop.NavigateTo, uri, forceLoad);
+            _jsRuntime.InvokeAsync<object>(Interop.NavigateTo, uri, forceLoad).Preserve();
         }
 
         private static class Log
diff --git a/src/Hosting/Hosting/src/Internal/WebHost.cs b/src/Hosting/Hosting/src/Internal/WebHost.cs
@@ -334,7 +334,7 @@ public async Task StopAsync(CancellationToken cancellationToken = default)
 
         public void Dispose()
         {
-            DisposeAsync().GetAwaiter().GetResult();
+            DisposeAsync().AsTask().GetAwaiter().GetResult();
         }
 
         public async ValueTask DisposeAsync()
diff --git a/src/Http/Http/src/Features/RequestServicesFeature.cs b/src/Http/Http/src/Features/RequestServicesFeature.cs
@@ -87,7 +87,7 @@ static async ValueTask Awaited(RequestServicesFeature servicesFeature, ValueTask
         /// <inheritdoc />
         public void Dispose()
         {
-            DisposeAsync().GetAwaiter().GetResult();
+            DisposeAsync().AsTask().GetAwaiter().GetResult();
         }
     }
 }
diff --git a/src/Servers/Kestrel/Core/src/Internal/Http/Http1OutputProducer.cs b/src/Servers/Kestrel/Core/src/Internal/Http/Http1OutputProducer.cs
@@ -58,9 +58,7 @@ internal class Http1OutputProducer : IHttpOutputProducer, IDisposable
 
         private bool _autoChunk;
 
-        // We rely on the TimingPipeFlusher to give us ValueTasks that can be safely awaited multiple times.
         private bool _writeStreamSuffixCalled;
-        private ValueTask<FlushResult> _writeStreamSuffixValueTask;
 
         private int _advancedBytesForChunk;
         private Memory<byte> _currentChunkMemory;
@@ -118,31 +116,27 @@ public ValueTask<FlushResult> WriteDataToPipeAsync(ReadOnlySpan<byte> buffer, Ca
 
         public ValueTask<FlushResult> WriteStreamSuffixAsync()
         {
+            ValueTask<FlushResult> result = default;
+
             lock (_contextLock)
             {
-                if (_writeStreamSuffixCalled)
+                if (!_writeStreamSuffixCalled)
                 {
-                    // If WriteStreamSuffixAsync has already been called, no-op and return the previously returned ValueTask.
-                    return _writeStreamSuffixValueTask;
-                }
+                    if (_autoChunk)
+                    {
+                        var writer = new BufferWriter<PipeWriter>(_pipeWriter);
+                        result = WriteAsyncInternal(ref writer, EndChunkedResponseBytes);
+                    }
+                    else if (_unflushedBytes > 0)
+                    {
+                        result = FlushAsync();
+                    }
 
-                if (_autoChunk)
-                {
-                    var writer = new BufferWriter<PipeWriter>(_pipeWriter);
-                    _writeStreamSuffixValueTask = WriteAsyncInternal(ref writer, EndChunkedResponseBytes);
-                }
-                else if (_unflushedBytes > 0)
-                {
-                    _writeStreamSuffixValueTask = FlushAsync();
-                }
-                else
-                {
-                    _writeStreamSuffixValueTask = default;
+                    _writeStreamSuffixCalled = true;
                 }
-
-                _writeStreamSuffixCalled = true;
-                return _writeStreamSuffixValueTask;
             }
+
+            return result;
         }
 
         public ValueTask<FlushResult> FlushAsync(CancellationToken cancellationToken = default)
@@ -533,7 +527,6 @@ public void Reset()
             _currentMemoryPrefixBytes = 0;
             _autoChunk = false;
             _writeStreamSuffixCalled = false;
-            _writeStreamSuffixValueTask = default;
             _currentChunkMemoryUpdated = false;
             _startCalled = false;
         }
diff --git a/src/Servers/Kestrel/Core/src/Internal/Http/HttpProtocol.cs b/src/Servers/Kestrel/Core/src/Internal/Http/HttpProtocol.cs
@@ -917,7 +917,15 @@ public void ProduceContinue()
                 ((IHeaderDictionary)HttpRequestHeaders).TryGetValue(HeaderNames.Expect, out var expect) &&
                 (expect.FirstOrDefault() ?? "").Equals("100-continue", StringComparison.OrdinalIgnoreCase))
             {
-                Output.Write100ContinueAsync().GetAwaiter().GetResult();
+                ValueTask<FlushResult> vt = Output.Write100ContinueAsync();
+                if (vt.IsCompleted)
+                {
+                    vt.GetAwaiter().GetResult();
+                }
+                else
+                {
+                    vt.AsTask().GetAwaiter().GetResult();
+                }
             }
         }
 
@@ -1050,6 +1058,8 @@ private Task WriteSuffix()
                 return WriteSuffixAwaited(writeTask);
             }
 
+            writeTask.GetAwaiter().GetResult();
+
             _requestProcessingStatus = RequestProcessingStatus.ResponseCompleted;
 
             if (_keepAlive)
diff --git a/src/Servers/Kestrel/Core/src/Internal/Http2/FlowControl/StreamInputFlowControl.cs b/src/Servers/Kestrel/Core/src/Internal/Http2/FlowControl/StreamInputFlowControl.cs
@@ -57,7 +57,7 @@ public void UpdateWindows(int bytes)
             if (streamWindowUpdateSize > 0)
             {
                 // Writing with the FrameWriter should only fail if given a canceled token, so just fire and forget.
-                _ = _frameWriter.WriteWindowUpdateAsync(StreamId, streamWindowUpdateSize);
+                _ = _frameWriter.WriteWindowUpdateAsync(StreamId, streamWindowUpdateSize).Preserve();
             }
 
             UpdateConnectionWindow(bytes);
@@ -90,7 +90,7 @@ private void UpdateConnectionWindow(int bytes)
             if (connectionWindowUpdateSize > 0)
             {
                 // Writing with the FrameWriter should only fail if given a canceled token, so just fire and forget.
-                _ = _frameWriter.WriteWindowUpdateAsync(0, connectionWindowUpdateSize);
+                _ = _frameWriter.WriteWindowUpdateAsync(0, connectionWindowUpdateSize).Preserve();
             }
         }
     }
diff --git a/src/Servers/Kestrel/Core/src/Internal/Http2/Http2Connection.cs b/src/Servers/Kestrel/Core/src/Internal/Http2/Http2Connection.cs
@@ -157,7 +157,7 @@ public void Abort(ConnectionAbortedException ex)
         {
             if (TryClose())
             {
-                _frameWriter.WriteGoAwayAsync(int.MaxValue, Http2ErrorCode.INTERNAL_ERROR);
+                _frameWriter.WriteGoAwayAsync(int.MaxValue, Http2ErrorCode.INTERNAL_ERROR).Preserve();
             }
 
             _frameWriter.Abort(ex);
@@ -1214,7 +1214,7 @@ private void UpdateConnectionState()
 
                 if (_gracefulCloseInitiator == GracefulCloseInitiator.Server && _clientActiveStreamCount > 0)
                 {
-                    _frameWriter.WriteGoAwayAsync(int.MaxValue, Http2ErrorCode.NO_ERROR);
+                    _frameWriter.WriteGoAwayAsync(int.MaxValue, Http2ErrorCode.NO_ERROR).Preserve();
                 }
             }
 
@@ -1224,7 +1224,7 @@ private void UpdateConnectionState()
                 {
                     if (TryClose())
                     {
-                        _frameWriter.WriteGoAwayAsync(_highestOpenedStreamId, Http2ErrorCode.NO_ERROR);
+                        _frameWriter.WriteGoAwayAsync(_highestOpenedStreamId, Http2ErrorCode.NO_ERROR).Preserve();
                     }
                 }
                 else
diff --git a/src/Servers/Kestrel/Core/src/Internal/Http2/Http2OutputProducer.cs b/src/Servers/Kestrel/Core/src/Internal/Http2/Http2OutputProducer.cs
@@ -43,7 +43,7 @@ internal class Http2OutputProducer : IHttpOutputProducer, IHttpOutputAborter, IV
         private bool _writerComplete;
 
         // Internal for testing
-        internal ValueTask _dataWriteProcessingTask;
+        internal Task _dataWriteProcessingTask;
         internal bool _disposed;
 
         /// <summary>The core logic for the IValueTaskSource implementation.</summary>
@@ -394,7 +394,7 @@ public void Reset()
         {
         }
 
-        private async ValueTask ProcessDataWrites()
+        private async Task ProcessDataWrites()
         {
             // ProcessDataWrites runs for the lifetime of the Http2OutputProducer, and is designed to be reused by multiple streams.
             // When Http2OutputProducer is no longer used (e.g. a stream is aborted and will no longer be used, or the connection is closed)
diff --git a/src/Servers/Kestrel/Core/src/Internal/Http2/Http2Stream.cs b/src/Servers/Kestrel/Core/src/Internal/Http2/Http2Stream.cs
@@ -145,7 +145,7 @@ public void CompleteStream(bool errored)
                         if (!errored)
                         {
                             // Don't block on IO. This never faults.
-                            _ = _http2Output.WriteRstStreamAsync(Http2ErrorCode.NO_ERROR);
+                            _ = _http2Output.WriteRstStreamAsync(Http2ErrorCode.NO_ERROR).Preserve();
                         }
                         RequestBodyPipe.Writer.Complete();
                     }
@@ -545,7 +545,7 @@ internal void ResetAndAbort(ConnectionAbortedException abortReason, Http2ErrorCo
 
             DecrementActiveClientStreamCount();
             // Don't block on IO. This never faults.
-            _ = _http2Output.WriteRstStreamAsync(error);
+            _ = _http2Output.WriteRstStreamAsync(error).Preserve();
 
             AbortCore(abortReason);
         }
diff --git a/src/Servers/Kestrel/Core/src/Internal/Http3/Http3Connection.cs b/src/Servers/Kestrel/Core/src/Internal/Http3/Http3Connection.cs
@@ -180,7 +180,7 @@ public void Abort(ConnectionAbortedException ex, Http3ErrorCode errorCode)
             {
                 if (TryClose())
                 {
-                    SendGoAway(_highestOpenedStreamId);
+                    SendGoAway(_highestOpenedStreamId).Preserve();
                 }
 
                 _errorCodeFeature.Error = (long)errorCode;
@@ -213,10 +213,10 @@ public void OnTimeout(TimeoutReason reason)
             switch (reason)
             {
                 case TimeoutReason.KeepAlive:
-                    SendGoAway(_highestOpenedStreamId);
+                    SendGoAway(_highestOpenedStreamId).Preserve();
                     break;
                 case TimeoutReason.TimeoutFeature:
-                    SendGoAway(_highestOpenedStreamId);
+                    SendGoAway(_highestOpenedStreamId).Preserve();
                     break;
                 case TimeoutReason.RequestHeaders:
                 case TimeoutReason.ReadDataRate:
@@ -396,7 +396,7 @@ private void UpdateConnectionState()
                 if (_gracefulCloseInitiator == GracefulCloseInitiator.Server && activeRequestCount > 0)
                 {
                     // Go away with largest streamid to initiate graceful shutdown.
-                    SendGoAway(VariableLengthIntegerHelper.EightByteLimit);
+                    SendGoAway(VariableLengthIntegerHelper.EightByteLimit).Preserve();
                 }
             }
 
@@ -406,7 +406,7 @@ private void UpdateConnectionState()
                 {
                     if (TryClose())
                     {
-                        SendGoAway(_highestOpenedStreamId);
+                        SendGoAway(_highestOpenedStreamId).Preserve();
                     }
                 }
                 else
diff --git a/src/Servers/Kestrel/Core/src/Internal/Http3/Http3OutputProducer.cs b/src/Servers/Kestrel/Core/src/Internal/Http3/Http3OutputProducer.cs
@@ -51,7 +51,7 @@ public Http3OutputProducer(
             _pipeReader = pipe.Reader;
 
             _flusher = new TimingPipeFlusher(_pipeWriter, timeoutControl: null, log);
-            _dataWriteProcessingTask = ProcessDataWrites();
+            _dataWriteProcessingTask = ProcessDataWrites().Preserve();
         }
 
         public void Dispose()
diff --git a/src/Servers/Kestrel/Transport.Quic/src/Internal/QuicConnectionContext.cs b/src/Servers/Kestrel/Transport.Quic/src/Internal/QuicConnectionContext.cs
@@ -19,7 +19,7 @@ internal class QuicConnectionContext : TransportMultiplexedConnection, IProtocol
         private readonly IQuicTrace _log;
         private readonly CancellationTokenSource _connectionClosedTokenSource = new CancellationTokenSource();
 
-        private ValueTask _closeTask;
+        private Task? _closeTask;
 
         public long Error { get; set; }
 
@@ -55,15 +55,8 @@ public override async ValueTask DisposeAsync()
         {
             try
             {
-                if (_closeTask != default)
-                {
-                    _closeTask  = _connection.CloseAsync(errorCode: 0);
-                    await _closeTask;
-                }
-                else
-                {
-                    await _closeTask;
-                }
+                _closeTask ??= _connection.CloseAsync(errorCode: 0).AsTask();
+                await _closeTask;
             }
             catch (Exception ex)
             {
@@ -78,7 +71,7 @@ public override async ValueTask DisposeAsync()
         public override void Abort(ConnectionAbortedException abortReason)
         {
             // dedup calls to abort here.
-            _closeTask = _connection.CloseAsync(errorCode: Error);
+            _closeTask = _connection.CloseAsync(errorCode: Error).AsTask();
         }
 
         public override async ValueTask<ConnectionContext?> AcceptAsync(CancellationToken cancellationToken = default)
diff --git a/src/Shared/ServerInfrastructure/DuplexPipeStream.cs b/src/Shared/ServerInfrastructure/DuplexPipeStream.cs
@@ -71,9 +71,10 @@ public override void SetLength(long value)
 
         public override int Read(byte[] buffer, int offset, int count)
         {
-            // ValueTask uses .GetAwaiter().GetResult() if necessary
-            // https://github.com/dotnet/corefx/blob/f9da3b4af08214764a51b2331f3595ffaf162abe/src/System.Threading.Tasks.Extensions/src/System/Threading/Tasks/ValueTask.cs#L156
-            return ReadAsyncInternal(new Memory<byte>(buffer, offset, count), default).Result;
+            ValueTask<int> vt = ReadAsyncInternal(new Memory<byte>(buffer, offset, count), default);
+            return vt.IsCompleted ?
+                vt.Result :
+                vt.AsTask().GetAwaiter().GetResult();
         }
 
         public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken = default)
diff --git a/src/SignalR/samples/ClientSample/Tcp/TcpConnection.cs b/src/SignalR/samples/ClientSample/Tcp/TcpConnection.cs
@@ -168,14 +168,7 @@ private async Task ProcessReceives()
 
                 _application.Output.Advance(bytesReceived);
 
-                var flushTask = _application.Output.FlushAsync();
-
-                if (!flushTask.IsCompleted)
-                {
-                    await flushTask;
-                }
-
-                var result = flushTask.GetAwaiter().GetResult();
+                var result = await _application.Output.FlushAsync();
                 if (result.IsCompleted)
                 {
                     // Pipe consumer is shut down, do we stop writing
diff --git a/src/SignalR/server/Core/src/HubConnectionContext.cs b/src/SignalR/server/Core/src/HubConnectionContext.cs
@@ -625,7 +625,7 @@ private void KeepAliveTick()
                 // If the transport channel is full, this will fail, but that's OK because
                 // adding a Ping message when the transport is full is unnecessary since the
                 // transport is still in the process of sending frames.
-                _ = TryWritePingAsync();
+                _ = TryWritePingAsync().Preserve();
 
                 // We only update the timestamp here, because updating on each sent message is bad for performance
                 // There can be a lot of sent messages per 15 seconds

Original file line number	Diff line number	Diff line change
`@@ -267,7 +267,7 @@ private void OnLocationChanged(object sender, LocationChangedEventArgs args)`
`267`	`267`	`_locationAbsolute = args.Location;`
`268`	`268`	`if (_renderHandle.IsInitialized && Routes != null)`
`269`	`269`	`{`
`270`		`- _ = RunOnNavigateAsync(NavigationManager.ToBaseRelativePath(_locationAbsolute), args.IsNavigationIntercepted);`
	`270`	`+ _ = RunOnNavigateAsync(NavigationManager.ToBaseRelativePath(_locationAbsolute), args.IsNavigationIntercepted).Preserve();`
`271`	`271`	`}`
`272`	`272`	`}`
`273`	`273`
Original file line number	Diff line number	Diff line change
`@@ -75,7 +75,7 @@ protected override void NavigateToCore(string uri, bool forceLoad)`
`75`	`75`	`throw new NavigationException(absoluteUriString);`
`76`	`76`	`}`
`77`	`77`
`78`		`- _jsRuntime.InvokeAsync<object>(Interop.NavigateTo, uri, forceLoad);`
	`78`	`+ _jsRuntime.InvokeAsync<object>(Interop.NavigateTo, uri, forceLoad).Preserve();`
`79`	`79`	`}`
`80`	`80`
`81`	`81`	`private static class Log`
Original file line number	Diff line number	Diff line change
`@@ -334,7 +334,7 @@ public async Task StopAsync(CancellationToken cancellationToken = default)`
`334`	`334`
`335`	`335`	`public void Dispose()`
`336`	`336`	`{`
`337`		`- DisposeAsync().GetAwaiter().GetResult();`
	`337`	`+ DisposeAsync().AsTask().GetAwaiter().GetResult();`
`338`	`338`	`}`
`339`	`339`
`340`	`340`	`public async ValueTask DisposeAsync()`
Original file line number	Diff line number	Diff line change
`@@ -87,7 +87,7 @@ static async ValueTask Awaited(RequestServicesFeature servicesFeature, ValueTask`
`87`	`87`	`/// <inheritdoc />`
`88`	`88`	`public void Dispose()`
`89`	`89`	`{`
`90`		`- DisposeAsync().GetAwaiter().GetResult();`
	`90`	`+ DisposeAsync().AsTask().GetAwaiter().GetResult();`
`91`	`91`	`}`
`92`	`92`	`}`
`93`	`93`	`}`
Original file line number	Diff line number	Diff line change
`@@ -917,7 +917,15 @@ public void ProduceContinue()`
`917`	`917`	`((IHeaderDictionary)HttpRequestHeaders).TryGetValue(HeaderNames.Expect, out var expect) &&`
`918`	`918`	`(expect.FirstOrDefault() ?? "").Equals("100-continue", StringComparison.OrdinalIgnoreCase))`
`919`	`919`	`{`
`920`		`- Output.Write100ContinueAsync().GetAwaiter().GetResult();`
	`920`	`+ ValueTask<FlushResult> vt = Output.Write100ContinueAsync();`
	`921`	`+ if (vt.IsCompleted)`
	`922`	`+ {`
	`923`	`+ vt.GetAwaiter().GetResult();`
	`924`	`+ }`
	`925`	`+ else`
	`926`	`+ {`
	`927`	`+ vt.AsTask().GetAwaiter().GetResult();`
	`928`	`+ }`
`921`	`929`	`}`
`922`	`930`	`}`
`923`	`931`
`@@ -1050,6 +1058,8 @@ private Task WriteSuffix()`
`1050`	`1058`	`return WriteSuffixAwaited(writeTask);`
`1051`	`1059`	`}`
`1052`	`1060`
	`1061`	`+ writeTask.GetAwaiter().GetResult();`
	`1062`	`+`
`1053`	`1063`	`_requestProcessingStatus = RequestProcessingStatus.ResponseCompleted;`
`1054`	`1064`
`1055`	`1065`	`if (_keepAlive)`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ public void UpdateWindows(int bytes)`
`57`	`57`	`if (streamWindowUpdateSize > 0)`
`58`	`58`	`{`
`59`	`59`	`// Writing with the FrameWriter should only fail if given a canceled token, so just fire and forget.`
`60`		`- _ = _frameWriter.WriteWindowUpdateAsync(StreamId, streamWindowUpdateSize);`
	`60`	`+ _ = _frameWriter.WriteWindowUpdateAsync(StreamId, streamWindowUpdateSize).Preserve();`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`UpdateConnectionWindow(bytes);`
`@@ -90,7 +90,7 @@ private void UpdateConnectionWindow(int bytes)`
`90`	`90`	`if (connectionWindowUpdateSize > 0)`
`91`	`91`	`{`
`92`	`92`	`// Writing with the FrameWriter should only fail if given a canceled token, so just fire and forget.`
`93`		`- _ = _frameWriter.WriteWindowUpdateAsync(0, connectionWindowUpdateSize);`
	`93`	`+ _ = _frameWriter.WriteWindowUpdateAsync(0, connectionWindowUpdateSize).Preserve();`
`94`	`94`	`}`
`95`	`95`	`}`
`96`	`96`	`}`
Original file line number	Diff line number	Diff line change
`@@ -157,7 +157,7 @@ public void Abort(ConnectionAbortedException ex)`
`157`	`157`	`{`
`158`	`158`	`if (TryClose())`
`159`	`159`	`{`
`160`		`- _frameWriter.WriteGoAwayAsync(int.MaxValue, Http2ErrorCode.INTERNAL_ERROR);`
	`160`	`+ _frameWriter.WriteGoAwayAsync(int.MaxValue, Http2ErrorCode.INTERNAL_ERROR).Preserve();`
`161`	`161`	`}`
`162`	`162`
`163`	`163`	`_frameWriter.Abort(ex);`
`@@ -1214,7 +1214,7 @@ private void UpdateConnectionState()`
`1214`	`1214`
`1215`	`1215`	`if (_gracefulCloseInitiator == GracefulCloseInitiator.Server && _clientActiveStreamCount > 0)`
`1216`	`1216`	`{`
`1217`		`- _frameWriter.WriteGoAwayAsync(int.MaxValue, Http2ErrorCode.NO_ERROR);`
	`1217`	`+ _frameWriter.WriteGoAwayAsync(int.MaxValue, Http2ErrorCode.NO_ERROR).Preserve();`
`1218`	`1218`	`}`
`1219`	`1219`	`}`
`1220`	`1220`
`@@ -1224,7 +1224,7 @@ private void UpdateConnectionState()`
`1224`	`1224`	`{`
`1225`	`1225`	`if (TryClose())`
`1226`	`1226`	`{`
`1227`		`- _frameWriter.WriteGoAwayAsync(_highestOpenedStreamId, Http2ErrorCode.NO_ERROR);`
	`1227`	`+ _frameWriter.WriteGoAwayAsync(_highestOpenedStreamId, Http2ErrorCode.NO_ERROR).Preserve();`
`1228`	`1228`	`}`
`1229`	`1229`	`}`
`1230`	`1230`	`else`
Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ internal class Http2OutputProducer : IHttpOutputProducer, IHttpOutputAborter, IV`
`43`	`43`	`private bool _writerComplete;`
`44`	`44`
`45`	`45`	`// Internal for testing`
`46`		`- internal ValueTask _dataWriteProcessingTask;`
	`46`	`+ internal Task _dataWriteProcessingTask;`
`47`	`47`	`internal bool _disposed;`
`48`	`48`
`49`	`49`	`/// <summary>The core logic for the IValueTaskSource implementation.</summary>`
`@@ -394,7 +394,7 @@ public void Reset()`
`394`	`394`	`{`
`395`	`395`	`}`
`396`	`396`
`397`		`- private async ValueTask ProcessDataWrites()`
	`397`	`+ private async Task ProcessDataWrites()`
`398`	`398`	`{`
`399`	`399`	`// ProcessDataWrites runs for the lifetime of the Http2OutputProducer, and is designed to be reused by multiple streams.`
`400`	`400`	`// When Http2OutputProducer is no longer used (e.g. a stream is aborted and will no longer be used, or the connection is closed)`
Original file line number	Diff line number	Diff line change
`@@ -145,7 +145,7 @@ public void CompleteStream(bool errored)`
`145`	`145`	`if (!errored)`
`146`	`146`	`{`
`147`	`147`	`// Don't block on IO. This never faults.`
`148`		`- _ = _http2Output.WriteRstStreamAsync(Http2ErrorCode.NO_ERROR);`
	`148`	`+ _ = _http2Output.WriteRstStreamAsync(Http2ErrorCode.NO_ERROR).Preserve();`
`149`	`149`	`}`
`150`	`150`	`RequestBodyPipe.Writer.Complete();`
`151`	`151`	`}`
`@@ -545,7 +545,7 @@ internal void ResetAndAbort(ConnectionAbortedException abortReason, Http2ErrorCo`
`545`	`545`
`546`	`546`	`DecrementActiveClientStreamCount();`
`547`	`547`	`// Don't block on IO. This never faults.`
`548`		`- _ = _http2Output.WriteRstStreamAsync(error);`
	`548`	`+ _ = _http2Output.WriteRstStreamAsync(error).Preserve();`
`549`	`549`
`550`	`550`	`AbortCore(abortReason);`
`551`	`551`	`}`
Original file line number	Diff line number	Diff line change
`@@ -180,7 +180,7 @@ public void Abort(ConnectionAbortedException ex, Http3ErrorCode errorCode)`
`180`	`180`	`{`
`181`	`181`	`if (TryClose())`
`182`	`182`	`{`
`183`		`- SendGoAway(_highestOpenedStreamId);`
	`183`	`+ SendGoAway(_highestOpenedStreamId).Preserve();`
`184`	`184`	`}`
`185`	`185`
`186`	`186`	`_errorCodeFeature.Error = (long)errorCode;`
`@@ -213,10 +213,10 @@ public void OnTimeout(TimeoutReason reason)`
`213`	`213`	`switch (reason)`
`214`	`214`	`{`
`215`	`215`	`case TimeoutReason.KeepAlive:`
`216`		`- SendGoAway(_highestOpenedStreamId);`
	`216`	`+ SendGoAway(_highestOpenedStreamId).Preserve();`
`217`	`217`	`break;`
`218`	`218`	`case TimeoutReason.TimeoutFeature:`
`219`		`- SendGoAway(_highestOpenedStreamId);`
	`219`	`+ SendGoAway(_highestOpenedStreamId).Preserve();`
`220`	`220`	`break;`
`221`	`221`	`case TimeoutReason.RequestHeaders:`
`222`	`222`	`case TimeoutReason.ReadDataRate:`
`@@ -396,7 +396,7 @@ private void UpdateConnectionState()`
`396`	`396`	`if (_gracefulCloseInitiator == GracefulCloseInitiator.Server && activeRequestCount > 0)`
`397`	`397`	`{`
`398`	`398`	`// Go away with largest streamid to initiate graceful shutdown.`
`399`		`- SendGoAway(VariableLengthIntegerHelper.EightByteLimit);`
	`399`	`+ SendGoAway(VariableLengthIntegerHelper.EightByteLimit).Preserve();`
`400`	`400`	`}`
`401`	`401`	`}`
`402`	`402`
`@@ -406,7 +406,7 @@ private void UpdateConnectionState()`
`406`	`406`	`{`
`407`	`407`	`if (TryClose())`
`408`	`408`	`{`
`409`		`- SendGoAway(_highestOpenedStreamId);`
	`409`	`+ SendGoAway(_highestOpenedStreamId).Preserve();`
`410`	`410`	`}`
`411`	`411`	`}`
`412`	`412`	`else`