Fix: Socket.SendFile throws when Blocking=false (#122831)

Hi, I noticed this issue was unassigned and marked "good first issue" so
I took a crack at it. Note this is a breaking change — happy to discuss
the approach or add breaking change documentation if needed.

---

### Problem

`Socket.SendFile` does not validate that the socket is in blocking mode
before attempting the operation. This leads to undefined,
platform-specific behavior:

- **Windows:** The operation blocks regardless of the `Blocking`
property setting
- **Linux:** May send only partial data with no indication of how much
was actually transmitted

### Solution

Added a validation check at the start of `SendFile` to throw
`InvalidOperationException` when `Blocking == false`. This follows the
same pattern used by other synchronous socket operations that require
blocking mode.

### Testing

- Added `NonBlocking_ThrowsInvalidOperationException` test covering both
`SendFile` overloads
- All 161 existing SendFile tests continue to pass

### Breaking Change

This is a breaking change. Code that previously called `SendFile` on a
non-blocking socket will now throw an exception:

- **On Linux:** This surfaces existing bugs — code was silently losing
data
- **On Windows:** Code that relied on the undocumented behavior of
Windows ignoring the `Blocking` flag will now fail

The previous behavior was undefined and platform-inconsistent, so
failing explicitly is preferable to silent misbehavior.

Fixes #47287

Author: laveeshb

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

@@ -1325,6 +1325,13 @@ public void SendFile(string? fileName, ReadOnlySpan<byte> preBuffer, ReadOnlySpa
 
             ThrowIfDisposed();
 
+            // SendFile is not supported on non-blocking sockets.
+            // ValidateBlockingMode() below checks for async mismatch; this checks explicit non-blocking.
+            if (!Blocking)
+            {
+                throw new InvalidOperationException(SR.net_sockets_blocking);
+            }
+
             if (!IsConnectionOriented || !Connected)
             {
                 throw new NotSupportedException(SR.net_notconnected);

src/libraries/System.Net.Sockets/tests/FunctionalTests/SendFile.cs

@@ -37,6 +37,18 @@ public async Task NotConnected_ThrowsNotSupportedException()
             await Assert.ThrowsAsync<NotSupportedException>(() => SendFileAsync(s, null, null, null, TransmitFileOptions.UseDefaultWorkerThread));
         }
 
+        [Fact]
+        public void SendFile_NonBlockingSocket_ThrowsInvalidOperationException()
+        {
+            (Socket client, Socket server) = SocketTestExtensions.CreateConnectedSocketPair();
+            using (client)
+            using (server)
+            {
+                client.Blocking = false;
+                Assert.Throws<InvalidOperationException>(() => client.SendFile(null));
+            }
+        }
+
         [Theory]
         [InlineData(false)]
         [InlineData(true)]