Encapsulate the logic of caching the last synchronously completed task.

src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems

@@ -1050,6 +1050,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\SynchronizationContext.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\SynchronizationLockException.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\Tasks\AsyncCausalityTracerConstants.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Threading\Tasks\CachedCompletedInt32Task.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\Tasks\ConcurrentExclusiveSchedulerPair.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\Tasks\Future.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\Tasks\FutureFactory.cs" />
@@ -2338,4 +2339,4 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\IUnaryNegationOperators.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IUnaryPlusOperators.cs" />
   </ItemGroup>
-</Project>
+</Project>

src/libraries/System.Private.CoreLib/src/System/IO/BufferedStream.cs

@@ -48,16 +48,14 @@ public sealed class BufferedStream : Stream
         private const int MaxShadowBufferSize = 81920;  // Make sure not to get to the Large Object Heap.
         private const int DefaultBufferSize = 4096;
 
-        private Stream? _stream;                            // Underlying stream.  Close sets _stream to null.
-        private byte[]? _buffer;                            // Shared read/write buffer.  Alloc on first use.
-        private readonly int _bufferSize;                   // Length of internal buffer (not counting the shadow buffer).
-        private int _readPos;                               // Read pointer within shared buffer.
-        private int _readLen;                               // Number of bytes read in buffer from _stream.
-        private int _writePos;                              // Write pointer within shared buffer.
-        private Task<int>? _lastSyncCompletedReadTask;      // The last successful Task returned from ReadAsync
-                                                            // (perf optimization for successive reads of the same size)
-                                                            // Removing a private default constructor is a breaking change for the DataDebugSerializer.
-                                                            // Because this ctor was here previously we need to keep it around.
+        private Stream? _stream;                                     // Underlying stream.  Close sets _stream to null.
+        private byte[]? _buffer;                                     // Shared read/write buffer.  Alloc on first use.
+        private readonly int _bufferSize;                            // Length of internal buffer (not counting the shadow buffer).
+        private int _readPos;                                        // Read pointer within shared buffer.
+        private int _readLen;                                        // Number of bytes read in buffer from _stream.
+        private int _writePos;                                       // Write pointer within shared buffer.
+        private CachedCompletedInt32Task _lastSyncCompletedReadTask; // The last successful Task returned from ReadAsync
+                                                                     // (perf optimization for successive reads of the same size)
 
         public BufferedStream(Stream stream)
             : this(stream, DefaultBufferSize)
@@ -571,19 +569,6 @@ public override int Read(Span<byte> destination)
             }
         }
 
-        private Task<int> LastSyncCompletedReadTask(int val)
-        {
-            Task<int>? t = _lastSyncCompletedReadTask;
-            Debug.Assert(t == null || t.IsCompletedSuccessfully);
-
-            if (t != null && t.Result == val)
-                return t;
-
-            t = Task.FromResult<int>(val);
-            _lastSyncCompletedReadTask = t;
-            return t;
-        }
-
         public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
         {
             ValidateBufferArguments(buffer, offset, count);
@@ -622,7 +607,7 @@ public override Task<int> ReadAsync(byte[] buffer, int offset, int count, Cancel
                     {
 
                         return (error == null)
-                                    ? LastSyncCompletedReadTask(bytesFromBuffer)
+                                    ? _lastSyncCompletedReadTask.GetTask(bytesFromBuffer)
                                     : Task.FromException<int>(error);
                     }
                 }

src/libraries/System.Private.CoreLib/src/System/IO/MemoryStream.cs

@@ -32,7 +32,7 @@ public class MemoryStream : Stream
         private readonly bool _exposable;   // Whether the array can be returned to the user.
         private bool _isOpen;      // Is this stream open or closed?
 
-        private Task<int>? _lastReadTask; // The last successful task returned from ReadAsync
+        private CachedCompletedInt32Task _lastReadTask; // The last successful task returned from ReadAsync
 
         private const int MemStreamMaxLength = int.MaxValue;
 
@@ -127,7 +127,7 @@ protected override void Dispose(bool disposing)
                     _writable = false;
                     _expandable = false;
                     // Don't set buffer to null - allow TryGetBuffer, GetBuffer & ToArray to work.
-                    _lastReadTask = null;
+                    _lastReadTask = default;
                 }
             }
             finally
@@ -389,10 +389,7 @@ public override Task<int> ReadAsync(byte[] buffer, int offset, int count, Cancel
             try
             {
                 int n = Read(buffer, offset, count);
-                Task<int>? t = _lastReadTask;
-                Debug.Assert(t == null || t.Status == TaskStatus.RanToCompletion,
-                    "Expected that a stored last task completed successfully");
-                return (t != null && t.Result == n) ? t : (_lastReadTask = Task.FromResult<int>(n));
+                return _lastReadTask.GetTask(n);
             }
             catch (OperationCanceledException oce)
             {

src/libraries/System.Private.CoreLib/src/System/IO/Strategies/BufferedFileStreamStrategy.cs

@@ -21,7 +21,7 @@ internal sealed class BufferedFileStreamStrategy : FileStreamStrategy
         private int _readPos;
         private int _readLen;
         // The last successful Task returned from ReadAsync (perf optimization for successive reads of the same size)
-        private Task<int>? _lastSyncCompletedReadTask;
+        private CachedCompletedInt32Task _lastSyncCompletedReadTask;
 
         internal BufferedFileStreamStrategy(FileStreamStrategy strategy, int bufferSize)
         {
@@ -310,21 +310,8 @@ public override Task<int> ReadAsync(byte[] buffer, int offset, int count, Cancel
             ValueTask<int> readResult = ReadAsync(new Memory<byte>(buffer, offset, count), cancellationToken);
 
             return readResult.IsCompletedSuccessfully
-                ? LastSyncCompletedReadTask(readResult.Result)
+                ? _lastSyncCompletedReadTask.GetTask(readResult.Result)
                 : readResult.AsTask();
-
-            Task<int> LastSyncCompletedReadTask(int val)
-            {
-                Task<int>? t = _lastSyncCompletedReadTask;
-                Debug.Assert(t == null || t.IsCompletedSuccessfully);
-
-                if (t != null && t.Result == val)
-                    return t;
-
-                t = Task.FromResult<int>(val);
-                _lastSyncCompletedReadTask = t;
-                return t;
-            }
         }
 
         public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default)

src/libraries/System.Private.CoreLib/src/System/IO/UnmanagedMemoryStream.cs

@@ -46,7 +46,7 @@ public class UnmanagedMemoryStream : Stream
         private long _offset;
         private FileAccess _access;
         private bool _isOpen;
-        private Task<int>? _lastReadTask; // The last successful task returned from ReadAsync
+        private CachedCompletedInt32Task _lastReadTask; // The last successful task returned from ReadAsync
 
         /// <summary>
         /// Creates a closed stream.
@@ -437,12 +437,11 @@ public override Task<int> ReadAsync(byte[] buffer, int offset, int count, Cancel
             try
             {
                 int n = Read(buffer, offset, count);
-                Task<int>? t = _lastReadTask;
-                return (t != null && t.Result == n) ? t : (_lastReadTask = Task.FromResult<int>(n));
+                return _lastReadTask.GetTask(n);
             }
             catch (Exception ex)
             {
-                Debug.Assert(!(ex is OperationCanceledException));
+                Debug.Assert(ex is not OperationCanceledException);
                 return Task.FromException<int>(ex);
             }
         }

src/libraries/System.Private.CoreLib/src/System/Threading/Tasks/CachedCompletedInt32Task.cs

@@ -0,0 +1,43 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Diagnostics;
+using System.IO;
+using System.Runtime.CompilerServices;
+
+namespace System.Threading.Tasks
+{
+    /// <summary>
+    /// Encapsulates the logic of caching the last synchronously completed task of integer.
+    /// Used in classes like <see cref="MemoryStream"/> to reduce allocations.
+    /// </summary>
+    internal struct CachedCompletedInt32Task
+    {
+        private Task<int>? _task;
+
+        /// <summary>
+        /// Gets a completed <see cref="Task{Int32}"/> whose result is <paramref name="result"/>.
+        /// </summary>
+        /// <remarks>
+        /// This method will try to return an already cached task if available.
+        /// </remarks>
+        /// <param name="result">The task's result.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Task<int> GetTask(int result)
+        {
+            Task<int>? task;
+#pragma warning disable CA1849 // Call async methods when in an async method
+            if ((task = _task) is not null && task.Result == result)
+#pragma warning restore CA1849 // Call async methods when in an async method
+            {
+                Debug.Assert(task.IsCompletedSuccessfully,
+                    "Expected that a stored last task completed successfully");
+                return task;
+            }
+            else
+            {
+                return _task = Task.FromResult(result);
+            }
+        }
+    }
+}