Task- and Span-based Socket.SendFile

src/libraries/System.Net.Sockets/ref/System.Net.Sockets.cs

@@ -385,6 +385,9 @@ public static void Select(System.Collections.IList? checkRead, System.Collection
         public bool SendAsync(System.Net.Sockets.SocketAsyncEventArgs e) { throw null; }
         public void SendFile(string? fileName) { }
         public void SendFile(string? fileName, byte[]? preBuffer, byte[]? postBuffer, System.Net.Sockets.TransmitFileOptions flags) { }
+        public void SendFile(string? fileName, System.ReadOnlySpan<byte> preBuffer, System.ReadOnlySpan<byte> postBuffer, System.Net.Sockets.TransmitFileOptions flags) { }
+        public System.Threading.Tasks.ValueTask SendFileAsync(string? fileName, System.ReadOnlyMemory<byte> preBuffer, System.ReadOnlyMemory<byte> postBuffer, System.Net.Sockets.TransmitFileOptions flags, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
+        public System.Threading.Tasks.ValueTask SendFileAsync(string? fileName, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
         public bool SendPacketsAsync(System.Net.Sockets.SocketAsyncEventArgs e) { throw null; }
         public int SendTo(byte[] buffer, int offset, int size, System.Net.Sockets.SocketFlags socketFlags, System.Net.EndPoint remoteEP) { throw null; }
         public int SendTo(byte[] buffer, int size, System.Net.Sockets.SocketFlags socketFlags, System.Net.EndPoint remoteEP) { throw null; }
@@ -443,6 +446,7 @@ public enum SocketAsyncOperation
         Send = 7,
         SendPackets = 8,
         SendTo = 9,
+        SendFile = 10,
     }
     [System.FlagsAttribute]
     public enum SocketFlags

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

@@ -102,7 +102,6 @@
     <Compile Include="System\Net\Sockets\SocketAsyncEventArgs.Windows.cs" />
     <Compile Include="System\Net\Sockets\IOControlKeepAlive.Windows.cs" />
     <Compile Include="System\Net\Sockets\SocketPal.Windows.cs" />
-    <Compile Include="System\Net\Sockets\TransmitFileAsyncResult.Windows.cs" />
     <Compile Include="System\Net\Sockets\UnixDomainSocketEndPoint.Windows.cs" />
     <Compile Include="$(CommonPath)System\Net\ContextAwareResult.Windows.cs"
              Link="Common\System\Net\ContextAwareResult.Windows.cs" />

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

@@ -28,6 +28,9 @@ public partial class Socket
         /// <summary>Cached instance for send operations that return <see cref="Task{Int32}"/>.</summary>
         private TaskSocketAsyncEventArgs<int>? _multiBufferSendEventArgs;
 
+        /// <summary>Cached instance for file send operations that return <see cref="ValueTask"/>.</summary>
+        private FileSendSocketAsyncEventargs? _fileSendEventArgs;
+
         internal Task<Socket> AcceptAsync(Socket? acceptSocket)
         {
             // Get any cached SocketAsyncEventArg we may have.
@@ -356,6 +359,31 @@ internal Task<int> SendToAsync(ArraySegment<byte> buffer, SocketFlags socketFlag
             return tcs.Task;
         }
 
+        public ValueTask SendFileAsync(string? fileName, CancellationToken cancellationToken = default)
+        {
+            return SendFileAsync(fileName, default, default, TransmitFileOptions.UseDefaultWorkerThread, cancellationToken);
+        }
+
+        public ValueTask SendFileAsync(string? fileName, ReadOnlyMemory<byte> preBuffer, ReadOnlyMemory<byte> postBuffer, TransmitFileOptions flags, CancellationToken cancellationToken = default)
+        {
+            ThrowIfDisposed();
+
+            if (!Connected)
+            {
+                throw new NotSupportedException(SR.net_notconnected);
+            }
+
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return ValueTask.FromCanceled(cancellationToken);
+            }
+
+            if (NetEventSource.Log.IsEnabled()) NetEventSource.Info(this, $"::SendFileAsync() SRC:{LocalEndPoint} DST:{RemoteEndPoint} fileName:{fileName}");
+
+            FileStream? fileStream = OpenFile(fileName);
+            return SendFileInternalAsync(fileStream, preBuffer, postBuffer, flags, cancellationToken);
+        }
+
         private static void ValidateBufferArguments(byte[] buffer, int offset, int size)
         {
             if (buffer == null)
@@ -563,6 +591,7 @@ private void DisposeCachedTaskSocketAsyncEventArgs()
             Interlocked.Exchange(ref _multiBufferSendEventArgs, null)?.Dispose();
             Interlocked.Exchange(ref _singleBufferReceiveEventArgs, null)?.Dispose();
             Interlocked.Exchange(ref _singleBufferSendEventArgs, null)?.Dispose();
+            Interlocked.Exchange(ref _fileSendEventArgs, null)?.Dispose();
         }
 
         /// <summary>A TaskCompletionSource that carries an extra field of strongly-typed state.</summary>

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

@@ -5,6 +5,9 @@
 using System.IO;
 using System.Threading.Tasks;
 using System.Runtime.Versioning;
+using System.Threading;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks.Sources;
 
 namespace System.Net.Sockets
 {
@@ -195,7 +198,7 @@ private static void CheckTransmitFileOptions(TransmitFileOptions flags)
             }
         }
 
-        private void SendFileInternal(string? fileName, byte[]? preBuffer, byte[]? postBuffer, TransmitFileOptions flags)
+        private void SendFileInternal(string? fileName, ReadOnlySpan<byte> preBuffer, ReadOnlySpan<byte> postBuffer, TransmitFileOptions flags)
         {
             CheckTransmitFileOptions(flags);
 
@@ -208,7 +211,7 @@ private void SendFileInternal(string? fileName, byte[]? preBuffer, byte[]? postB
             {
                 // Send the preBuffer, if any
                 // This will throw on error
-                if (preBuffer != null && preBuffer.Length > 0)
+                if (!preBuffer.IsEmpty)
                 {
                     Send(preBuffer);
                 }
@@ -224,55 +227,66 @@ private void SendFileInternal(string? fileName, byte[]? preBuffer, byte[]? postB
             if (errorCode != SocketError.Success)
             {
                 UpdateSendSocketErrorForDisposed(ref errorCode);
-
                 UpdateStatusAfterSocketErrorAndThrowException(errorCode);
             }
 
             // Send the postBuffer, if any
             // This will throw on error
-            if (postBuffer != null && postBuffer.Length > 0)
+            if (!postBuffer.IsEmpty)
             {
                 Send(postBuffer);
             }
         }
 
-        private async Task SendFileInternalAsync(FileStream? fileStream, byte[]? preBuffer, byte[]? postBuffer)
+        private async ValueTask SendFileInternalAsync(FileStream? fileStream, ReadOnlyMemory<byte> preBuffer, ReadOnlyMemory<byte> postBuffer, TransmitFileOptions flags = TransmitFileOptions.UseDefaultWorkerThread, CancellationToken cancellationToken = default)
         {
+            CheckTransmitFileOptions(flags);
+
             SocketError errorCode = SocketError.Success;
             using (fileStream)
             {
                 // Send the preBuffer, if any
                 // This will throw on error
-                if (preBuffer != null && preBuffer.Length > 0)
+                if (!preBuffer.IsEmpty)
                 {
                     // Using "this." makes the extension method kick in
-                    await this.SendAsync(new ArraySegment<byte>(preBuffer), SocketFlags.None).ConfigureAwait(false);
+                    await SendAsync(preBuffer, SocketFlags.None, cancellationToken).ConfigureAwait(false);
                 }
 
                 // Send the file, if any
                 if (fileStream != null)
                 {
-                    var tcs = new TaskCompletionSource<SocketError>();
-                    errorCode = SocketPal.SendFileAsync(_handle, fileStream, (_, socketError) => tcs.SetResult(socketError));
+                    AsyncValueTaskMethodBuilder<SocketError> taskBuilder = AsyncValueTaskMethodBuilder<SocketError>.Create();
+                    ValueTask<SocketError> task = taskBuilder.Task;
+                    errorCode = SocketPal.SendFileAsync(_handle, fileStream, taskBuilder, static (state, _, socketError) => state.SetResult(socketError), cancellationToken);
                     if (errorCode == SocketError.IOPending)
                     {
-                        errorCode = await tcs.Task.ConfigureAwait(false);
+                        errorCode = await task.ConfigureAwait(false);
                     }
                 }
             }
 
             if (errorCode != SocketError.Success)
             {
                 UpdateSendSocketErrorForDisposed(ref errorCode);
-                UpdateStatusAfterSocketErrorAndThrowException(errorCode);
+
+                if (errorCode == SocketError.OperationAborted)
+                {
+                    // Don't wrap into a SocketException
+                    throw new OperationCanceledException(cancellationToken);
+                }
+                else
+                {
+                    UpdateStatusAfterSocketErrorAndThrowException(errorCode);
+                }
             }
 
             // Send the postBuffer, if any
             // This will throw on error
-            if (postBuffer != null && postBuffer.Length > 0)
+            if (!postBuffer.IsEmpty)
             {
                 // Using "this." makes the extension method kick in
-                await this.SendAsync(new ArraySegment<byte>(postBuffer), SocketFlags.None).ConfigureAwait(false);
+                await SendAsync(postBuffer, SocketFlags.None, cancellationToken).ConfigureAwait(false);
             }
         }
 
@@ -284,12 +298,15 @@ private IAsyncResult BeginSendFileInternal(string? fileName, byte[]? preBuffer,
             // Open it before we send the preBuffer so that any exception happens first
             FileStream? fileStream = OpenFile(fileName);
 
-            return TaskToApm.Begin(SendFileInternalAsync(fileStream, preBuffer, postBuffer), callback, state);
+            return TaskToApm.Begin(SendFileInternalAsync(fileStream, preBuffer, postBuffer).AsTask(), callback, state);
         }
 
         private void EndSendFileInternal(IAsyncResult asyncResult)
         {
             TaskToApm.End(asyncResult);
         }
+
+        internal sealed class FileSendSocketAsyncEventargs : SocketAsyncEventArgs
+        { }
     }
 }