dotnet · stephentoub · Mar 3, 2017 · Mar 2, 2017 · Mar 1, 2017 · Mar 2, 2017
diff --git a/src/System.Net.Sockets/src/Resources/Strings.resx b/src/System.Net.Sockets/src/Resources/Strings.resx
@@ -232,4 +232,7 @@
   <data name="ArgumentOutOfRange_NeedPosNum" xml:space="preserve">
     <value>Positive number required.</value>
   </data>
+  <data name="net_io_readwritefailure" xml:space="preserve">
+    <value>Unable to transfer data on the transport connection: {0}.</value>
+  </data>
 </root>
diff --git a/src/System.Net.Sockets/src/System.Net.Sockets.csproj b/src/System.Net.Sockets/src/System.Net.Sockets.csproj
@@ -40,6 +40,7 @@
     <Compile Include="System\Net\Sockets\SelectMode.cs" />
     <Compile Include="System\Net\Sockets\SendPacketsElement.cs" />
     <Compile Include="System\Net\Sockets\Socket.cs" />
+    <Compile Include="System\Net\Sockets\Socket.Tasks.cs" />
     <Compile Include="System\Net\Sockets\SocketAsyncEventArgs.cs" />
     <Compile Include="System\Net\Sockets\SocketAsyncOperation.cs" />
     <Compile Include="System\Net\Sockets\SocketFlags.cs" />

diff --git a/src/System.Net.Sockets/src/System/Net/Sockets/NetworkStream.cs b/src/System.Net.Sockets/src/System/Net/Sockets/NetworkStream.cs
@@ -16,16 +16,17 @@ namespace System.Net.Sockets
     public class NetworkStream : Stream
     {
         // Used by the class to hold the underlying socket the stream uses.
-        private Socket _streamSocket;
+        private readonly Socket _streamSocket;
+
+        // Whether the stream should dispose of the socket when the stream is disposed
+        private readonly bool _ownsSocket;
 
         // Used by the class to indicate that the stream is m_Readable.
         private bool _readable;
 
         // Used by the class to indicate that the stream is writable.
         private bool _writeable;
 
-        private bool _ownsSocket;
-
         // Creates a new instance of the System.Net.Sockets.NetworkStream class for the specified System.Net.Sockets.Socket.
         public NetworkStream(Socket socket)
             : this(socket, FileAccess.ReadWrite, ownsSocket: false)
@@ -664,24 +665,48 @@ public void EndWrite(IAsyncResult asyncResult)
         //     A Task<int> representing the read.
         public override Task<int> ReadAsync(byte[] buffer, int offset, int size, CancellationToken cancellationToken)
         {
-#if netcore50
+            bool canRead = CanRead; // Prevent race with Dispose.
+            if (_cleanedUp)
+            {
+                throw new ObjectDisposedException(this.GetType().FullName);
+            }
+            if (!canRead)
+            {
+                throw new InvalidOperationException(SR.net_writeonlystream);
+            }
+
+            // Validate input parameters.
+            if (buffer == null)
+            {
+                throw new ArgumentNullException(nameof(buffer));
+            }
+            if (offset < 0 || offset > buffer.Length)
+            {
+                throw new ArgumentOutOfRangeException(nameof(offset));
+            }
+            if (size < 0 || size > buffer.Length - offset)
+            {
+                throw new ArgumentOutOfRangeException(nameof(size));
+            }
+
             if (cancellationToken.IsCancellationRequested)
             {
                 return Task.FromCanceled<int>(cancellationToken);
             }
 
-            return Task.Factory.FromAsync(
-                (bufferArg, offsetArg, sizeArg, callback, state) => ((NetworkStream)state).BeginRead(bufferArg, offsetArg, sizeArg, callback, state),
-                iar => ((NetworkStream)iar.AsyncState).EndRead(iar),
-                buffer,
-                offset,
-                size,
-                this);
-#else
-            // Use optimized Stream.ReadAsync that's more efficient than
-            // Task.Factory.FromAsync when NetworkStream overrides Begin/EndRead.
-            return base.ReadAsync(buffer, offset, size, cancellationToken);
-#endif
+            try
+            {
+                return _streamSocket.ReceiveAsync(
+                    new ArraySegment<byte>(buffer, offset, size),
+                    SocketFlags.None,
+                    wrapExceptionsInIOExceptions: true);
+            }
+            catch (Exception exception) when (!(exception is OutOfMemoryException))
+            {
+                // Some sort of error occurred on the socket call,
+                // set the SocketException as InnerException and throw.
+                throw new IOException(SR.Format(SR.net_io_readfailure, exception.Message), exception);
+            }
         }
 
         // WriteAsync - provide async write functionality.
@@ -701,24 +726,48 @@ public override Task<int> ReadAsync(byte[] buffer, int offset, int size, Cancell
         //     A Task representing the write.
         public override Task WriteAsync(byte[] buffer, int offset, int size, CancellationToken cancellationToken)
         {
-#if netcore50
+            bool canWrite = CanWrite; // Prevent race with Dispose.
+            if (_cleanedUp)
+            {
+                throw new ObjectDisposedException(this.GetType().FullName);
+            }
+            if (!canWrite)
+            {
+                throw new InvalidOperationException(SR.net_readonlystream);
+            }
+
+            // Validate input parameters.
+            if (buffer == null)
+            {
+                throw new ArgumentNullException(nameof(buffer));
+            }
+            if (offset < 0 || offset > buffer.Length)
+            {
+                throw new ArgumentOutOfRangeException(nameof(offset));
+            }
+            if (size < 0 || size > buffer.Length - offset)
+            {
+                throw new ArgumentOutOfRangeException(nameof(size));
+            }
+
             if (cancellationToken.IsCancellationRequested)
             {
-                return Task.FromCanceled<int>(cancellationToken);
+                return Task.FromCanceled(cancellationToken);
             }
 
-            return Task.Factory.FromAsync(
-                (bufferArg, offsetArg, sizeArg, callback, state) => ((NetworkStream)state).BeginWrite(bufferArg, offsetArg, sizeArg, callback, state),
-                iar => ((NetworkStream)iar.AsyncState).EndWrite(iar),
-                buffer,
-                offset,
-                size,
-                this);
-#else
-            // Use optimized Stream.WriteAsync that's more efficient than
-            // Task.Factory.FromAsync when NetworkStream overrides Begin/EndWrite.
-            return base.WriteAsync(buffer, offset, size, cancellationToken);
-#endif
+            try
+            {
+                return _streamSocket.SendAsync(
+                    new ArraySegment<byte>(buffer, offset, size),
+                    SocketFlags.None,
+                    wrapExceptionsInIOExceptions: true);
+            }
+            catch (Exception exception) when (!(exception is OutOfMemoryException))
+            {
+                // Some sort of error occurred on the socket call,
+                // set the SocketException as InnerException and throw.
+                throw new IOException(SR.Format(SR.net_io_writefailure, exception.Message), exception);
+            }
         }
 
         public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)