[Draft] Idea for detection of synchronous completions for APM over Task in sockets

src/libraries/Common/src/System/Threading/Tasks/TaskToApm.cs

@@ -32,6 +32,22 @@ internal static class TaskToApm
         public static IAsyncResult Begin(Task task, AsyncCallback? callback, object? state) =>
             new TaskAsyncResult(task, state, callback);
 
+        public static Task GetSynchronousExceptionTask(Exception ex) => new FailedSynchronouslyCompletionSource(ex).Task;
+
+        public static Task<T> GetSynchronousExceptionTask<T>(Exception ex) => new FailedSynchronouslyCompletionSource<T>(ex).Task;
+
+        public static ValueTask<T> GetSynchronousExceptionValueTask<T>(Exception ex) => new ValueTask<T>(new FailedSynchronouslyCompletionSource<T>(ex).Task);
+
+        public static bool FailedSynchronously(this Task task) => task.IsFaulted && task.AsyncState is Exception;
+
+        public static void ThrowIfFailedSynchronously(this Task task)
+        {
+            if (task.IsFaulted && task.AsyncState is Exception ex)
+            {
+                throw ex;
+            }
+        }
+
         /// <summary>Processes an IAsyncResult returned by Begin.</summary>
         /// <param name="asyncResult">The IAsyncResult to unwrap.</param>
         public static void End(IAsyncResult asyncResult)
@@ -68,6 +84,22 @@ private static void ThrowArgumentException(IAsyncResult asyncResult) =>
                 new ArgumentNullException(nameof(asyncResult)) :
                 new ArgumentException(null, nameof(asyncResult)));
 
+        private sealed class FailedSynchronouslyCompletionSource : TaskCompletionSource
+        {
+            public FailedSynchronouslyCompletionSource(Exception exception) : base(exception)
+            {
+                SetException(exception);
+            }
+        }
+
+        private sealed class FailedSynchronouslyCompletionSource<T> : TaskCompletionSource<T>
+        {
+            public FailedSynchronouslyCompletionSource(Exception exception) : base(exception)
+            {
+                SetException(exception);
+            }
+        }
+
         /// <summary>Provides a simple IAsyncResult that wraps a Task.</summary>
         /// <remarks>
         /// We could use the Task as the IAsyncResult if the Task's AsyncState is the same as the object state,

src/libraries/System.Net.Sockets/src/System.Net.Sockets.csproj

@@ -43,7 +43,6 @@
     <Compile Include="System\Net\Sockets\TransmitFileOptions.cs" />
     <Compile Include="System\Net\Sockets\UDPClient.cs" />
     <Compile Include="System\Net\Sockets\UdpReceiveResult.cs" />
-    <Compile Include="System\Net\Sockets\AcceptOverlappedAsyncResult.cs" />
     <Compile Include="System\Net\Sockets\BaseOverlappedAsyncResult.cs" />
     <Compile Include="System\Net\Sockets\DisconnectOverlappedAsyncResult.cs" />
     <Compile Include="System\Net\Sockets\UnixDomainSocketEndPoint.cs" />
@@ -90,7 +89,6 @@
   </ItemGroup>
   <ItemGroup Condition="'$(TargetsWindows)' == 'true'">
     <!-- Windows: CoreCLR -->
-    <Compile Include="System\Net\Sockets\AcceptOverlappedAsyncResult.Windows.cs" />
     <Compile Include="System\Net\Sockets\BaseOverlappedAsyncResult.Windows.cs" />
     <Compile Include="System\Net\Sockets\DynamicWinsockMethods.cs" />
     <Compile Include="System\Net\Sockets\SafeSocketHandle.Windows.cs" />
@@ -185,7 +183,6 @@
              Link="Common\System\Net\CompletionPortHelper.Windows.cs" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetsUnix)' == 'true'">
-    <Compile Include="System\Net\Sockets\AcceptOverlappedAsyncResult.Unix.cs" />
     <Compile Include="System\Net\Sockets\BaseOverlappedAsyncResult.Unix.cs" />
     <Compile Include="System\Net\Sockets\DisconnectOverlappedAsyncResult.Unix.cs" />
     <Compile Include="System\Net\Sockets\SafeSocketHandle.Unix.cs" />

src/libraries/System.Net.Sockets/src/System/Net/Sockets/Socket.Tasks.cs

@@ -72,8 +72,7 @@ public Task<Socket> AcceptAsync(Socket? acceptSocket)
             {
                 // The operation completed synchronously.  Get a task for it.
                 t = saea.SocketError == SocketError.Success ?
-                    Task.FromResult(saea.AcceptSocket!) :
-                    Task.FromException<Socket>(GetException(saea.SocketError));
+                    Task.FromResult(saea.AcceptSocket!) : TaskToApm.GetSynchronousExceptionTask<Socket>(GetException(saea.SocketError));
 
                 // There won't be a callback, and we're done with the SAEA, so return it to the pool.
                 ReturnSocketAsyncEventArgs(saea);
@@ -959,8 +958,7 @@ public ValueTask<int> SendAsync(Socket socket, CancellationToken cancellationTok
                 Release();
 
                 return error == SocketError.Success ?
-                    new ValueTask<int>(bytesTransferred) :
-                    ValueTask.FromException<int>(CreateException(error));
+                    new ValueTask<int>(bytesTransferred) : TaskToApm.GetSynchronousExceptionValueTask<int>(CreateException(error));
             }
 
             public ValueTask SendAsyncForNetworkStream(Socket socket, CancellationToken cancellationToken)

src/libraries/System.Net.Sockets/src/System/Net/Sockets/Socket.Unix.cs

@@ -27,26 +27,6 @@ public SocketInformation DuplicateAndClose(int targetProcessId)
             throw new PlatformNotSupportedException(SR.net_sockets_duplicateandclose_notsupported);
         }
 
-        public IAsyncResult BeginAccept(int receiveSize, AsyncCallback? callback, object? state)
-        {
-            throw new PlatformNotSupportedException(SR.net_sockets_accept_receive_apm_notsupported);
-        }
-
-        public IAsyncResult BeginAccept(Socket? acceptSocket, int receiveSize, AsyncCallback? callback, object? state)
-        {
-            throw new PlatformNotSupportedException(SR.net_sockets_accept_receive_apm_notsupported);
-        }
-
-        public Socket EndAccept(out byte[] buffer, IAsyncResult asyncResult)
-        {
-            throw new PlatformNotSupportedException(SR.net_sockets_accept_receive_apm_notsupported);
-        }
-
-        public Socket EndAccept(out byte[] buffer, out int bytesTransferred, IAsyncResult asyncResult)
-        {
-            throw new PlatformNotSupportedException(SR.net_sockets_accept_receive_apm_notsupported);
-        }
-
         internal bool PreferInlineCompletions
         {
             get => _handle.PreferInlineCompletions;

src/libraries/System.Net.Sockets/src/System/Net/Sockets/Socket.Windows.cs

@@ -7,6 +7,7 @@
 using System.IO;
 using System.Runtime.CompilerServices;
 using System.Threading;
+using System.Threading.Tasks;
 using System.Runtime.Versioning;
 
 namespace System.Net.Sockets
@@ -145,30 +146,6 @@ public SocketInformation DuplicateAndClose(int targetProcessId)
             return info;
         }
 
-        public IAsyncResult BeginAccept(int receiveSize, AsyncCallback? callback, object? state)
-        {
-            return BeginAccept(acceptSocket: null, receiveSize, callback, state);
-        }
-
-        // This is the truly async version that uses AcceptEx.
-        public IAsyncResult BeginAccept(Socket? acceptSocket, int receiveSize, AsyncCallback? callback, object? state)
-        {
-            return BeginAcceptCommon(acceptSocket, receiveSize, callback, state);
-        }
-
-        public Socket EndAccept(out byte[] buffer, IAsyncResult asyncResult)
-        {
-            Socket socket = EndAccept(out byte[] innerBuffer, out int bytesTransferred, asyncResult);
-            buffer = new byte[bytesTransferred];
-            Buffer.BlockCopy(innerBuffer, 0, buffer, 0, bytesTransferred);
-            return socket;
-        }
-
-        public Socket EndAccept(out byte[] buffer, out int bytesTransferred, IAsyncResult asyncResult)
-        {
-            return EndAcceptCommon(out buffer!, out bytesTransferred, asyncResult);
-        }
-
         private DynamicWinsockMethods GetDynamicWinsockMethods()
         {
             return _dynamicWinsockMethods ??= DynamicWinsockMethods.GetMethods(_addressFamily, _socketType, _protocolType);