mcs/class/System/System.Net.Sockets/SocketTaskExtensions.cs

   1 // Licensed to the .NET Foundation under one or more agreements.
   2 // The .NET Foundation licenses this file to you under the MIT license.
   3 // See the LICENSE file in the project root for more information.
   4
   5 #if NETSTANDARD
   6
   7 using System.Collections.Generic;
   8 using System.Threading.Tasks;
   9
  10 namespace System.Net.Sockets
  11 {
  12     public static class SocketTaskExtensions
  13     {
  14         public static Task<Socket> AcceptAsync(this Socket socket)
  15         {
  16             return Task<Socket>.Factory.FromAsync(
  17                 (callback, state) => ((Socket)state).BeginAccept(callback, state),
  18                 asyncResult => ((Socket)asyncResult.AsyncState).EndAccept(asyncResult),
  19                 state: socket);
  20         }
  21
  22         public static Task<Socket> AcceptAsync(this Socket socket, Socket acceptSocket)
  23         {
  24             const int ReceiveSize = 0;
  25             return Task<Socket>.Factory.FromAsync(
  26                 (socketForAccept, receiveSize, callback, state) => ((Socket)state).BeginAccept(socketForAccept, receiveSize, callback, state),
  27                 asyncResult => ((Socket)asyncResult.AsyncState).EndAccept(asyncResult),
  28                 acceptSocket,
  29                 ReceiveSize,
  30                 state: socket);
  31         }
  32
  33         public static Task ConnectAsync(this Socket socket, EndPoint remoteEP)
  34         {
  35             return Task.Factory.FromAsync(
  36                 (targetEndPoint, callback, state) => ((Socket)state).BeginConnect(targetEndPoint, callback, state),
  37                 asyncResult => ((Socket)asyncResult.AsyncState).EndConnect(asyncResult),
  38                 remoteEP,
  39                 state: socket);
  40         }
  41
  42         public static Task ConnectAsync(this Socket socket, IPAddress address, int port)
  43         {
  44             return Task.Factory.FromAsync(
  45                 (targetAddress, targetPort, callback, state) => ((Socket)state).BeginConnect(targetAddress, targetPort, callback, state),
  46                 asyncResult => ((Socket)asyncResult.AsyncState).EndConnect(asyncResult),
  47                 address,
  48                 port,
  49                 state: socket);
  50         }
  51
  52         public static Task ConnectAsync(this Socket socket, IPAddress[] addresses, int port)
  53         {
  54             return Task.Factory.FromAsync(
  55                 (targetAddresses, targetPort, callback, state) => ((Socket)state).BeginConnect(targetAddresses, targetPort, callback, state),
  56                 asyncResult => ((Socket)asyncResult.AsyncState).EndConnect(asyncResult),
  57                 addresses,
  58                 port,
  59                 state: socket);
  60         }
  61
  62         public static Task ConnectAsync(this Socket socket, string host, int port)
  63         {
  64             return Task.Factory.FromAsync(
  65                 (targetHost, targetPort, callback, state) => ((Socket)state).BeginConnect(targetHost, targetPort, callback, state),
  66                 asyncResult => ((Socket)asyncResult.AsyncState).EndConnect(asyncResult),
  67                 host,
  68                 port,
  69                 state: socket);
  70         }
  71
  72         public static Task<int> ReceiveAsync(this Socket socket, ArraySegment<byte> buffer, SocketFlags socketFlags)
  73         {
  74             return Task<int>.Factory.FromAsync(
  75                 (targetBuffer, flags, callback, state) => ((Socket)state).BeginReceive(
  76                                                               targetBuffer.Array,
  77                                                               targetBuffer.Offset,
  78                                                               targetBuffer.Count,
  79                                                               flags,
  80                                                               callback,
  81                                                               state),
  82                 asyncResult => ((Socket)asyncResult.AsyncState).EndReceive(asyncResult),
  83                 buffer,
  84                 socketFlags,
  85                 state: socket);
  86         }
  87
  88         public static Task<int> ReceiveAsync(
  89             this Socket socket,
  90             IList<ArraySegment<byte>> buffers,
  91             SocketFlags socketFlags)
  92         {
  93             return Task<int>.Factory.FromAsync(
  94                 (targetBuffers, flags, callback, state) => ((Socket)state).BeginReceive(targetBuffers, flags, callback, state),
  95                 asyncResult => ((Socket)asyncResult.AsyncState).EndReceive(asyncResult),
  96                 buffers,
  97                 socketFlags,
  98                 state: socket);
  99         }
 100
 101         public static Task<SocketReceiveFromResult> ReceiveFromAsync(
 102             this Socket socket,
 103             ArraySegment<byte> buffer,
 104             SocketFlags socketFlags,
 105             EndPoint remoteEndPoint)
 106         {
 107             object[] packedArguments = new object[] { socket, remoteEndPoint };
 108
 109             return Task<SocketReceiveFromResult>.Factory.FromAsync(
 110                 (targetBuffer, flags, callback, state) =>
 111                 {
 112                     var arguments = (object[])state;
 113                     var s = (Socket)arguments[0];
 114                     var e = (EndPoint)arguments[1];
 115
 116                     IAsyncResult result = s.BeginReceiveFrom(
 117                         targetBuffer.Array,
 118                         targetBuffer.Offset,
 119                         targetBuffer.Count,
 120                         flags,
 121                         ref e,
 122                         callback,
 123                         state);
 124
 125                     arguments[1] = e;
 126                     return result;
 127                 },
 128                 asyncResult =>
 129                 {
 130                     var arguments = (object[])asyncResult.AsyncState;
 131                     var s = (Socket)arguments[0];
 132                     var e = (EndPoint)arguments[1];
 133
 134                     int bytesReceived = s.EndReceiveFrom(asyncResult, ref e);
 135
 136                     return new SocketReceiveFromResult()
 137                     {
 138                         ReceivedBytes = bytesReceived,
 139                         RemoteEndPoint = e
 140                     };
 141                 },
 142                 buffer,
 143                 socketFlags,
 144                 state: packedArguments);
 145         }
 146
 147         public static Task<SocketReceiveMessageFromResult> ReceiveMessageFromAsync(
 148             this Socket socket,
 149             ArraySegment<byte> buffer,
 150             SocketFlags socketFlags,
 151             EndPoint remoteEndPoint)
 152         {
 153             object[] packedArguments = new object[] { socket, socketFlags, remoteEndPoint };
 154
 155             return Task<SocketReceiveMessageFromResult>.Factory.FromAsync(
 156                 (targetBuffer, callback, state) =>
 157                 {
 158                     var arguments = (object[])state;
 159                     var s = (Socket)arguments[0];
 160                     var f = (SocketFlags)arguments[1];
 161                     var e = (EndPoint)arguments[2];
 162
 163                     IAsyncResult result = s.BeginReceiveMessageFrom(
 164                         targetBuffer.Array,
 165                         targetBuffer.Offset,
 166                         targetBuffer.Count,
 167                         f,
 168                         ref e,
 169                         callback,
 170                         state);
 171
 172                     arguments[2] = e;
 173                     return result;
 174                 },
 175                 asyncResult =>
 176                 {
 177                     var arguments = (object[])asyncResult.AsyncState;
 178                     var s = (Socket)arguments[0];
 179                     var f = (SocketFlags)arguments[1];
 180                     var e = (EndPoint)arguments[2];
 181                     IPPacketInformation ipPacket;
 182
 183                     int bytesReceived = s.EndReceiveMessageFrom(
 184                         asyncResult,
 185                         ref f,
 186                         ref e,
 187                         out ipPacket);
 188
 189                     return new SocketReceiveMessageFromResult()
 190                     {
 191                         PacketInformation = ipPacket,
 192                         ReceivedBytes = bytesReceived,
 193                         RemoteEndPoint = e,
 194                         SocketFlags = f
 195                     };
 196                 },
 197                 buffer,
 198                 state: packedArguments);
 199         }
 200
 201         public static Task<int> SendAsync(this Socket socket, ArraySegment<byte> buffer, SocketFlags socketFlags)
 202         {
 203             return Task<int>.Factory.FromAsync(
 204                 (targetBuffer, flags, callback, state) => ((Socket)state).BeginSend(
 205                                                               targetBuffer.Array,
 206                                                               targetBuffer.Offset,
 207                                                               targetBuffer.Count,
 208                                                               flags,
 209                                                               callback,
 210                                                               state),
 211                 asyncResult => ((Socket)asyncResult.AsyncState).EndSend(asyncResult),
 212                 buffer,
 213                 socketFlags,
 214                 state: socket);
 215         }
 216
 217         public static Task<int> SendAsync(
 218             this Socket socket,
 219             IList<ArraySegment<byte>> buffers,
 220             SocketFlags socketFlags)
 221         {
 222             return Task<int>.Factory.FromAsync(
 223                 (targetBuffers, flags, callback, state) => ((Socket)state).BeginSend(targetBuffers, flags, callback, state),
 224                 asyncResult => ((Socket)asyncResult.AsyncState).EndSend(asyncResult),
 225                 buffers,
 226                 socketFlags,
 227                 state: socket);
 228         }
 229
 230         public static Task<int> SendToAsync(
 231             this Socket socket,
 232             ArraySegment<byte> buffer,
 233             SocketFlags socketFlags,
 234             EndPoint remoteEP)
 235         {
 236             return Task<int>.Factory.FromAsync(
 237                 (targetBuffer, flags, endPoint, callback, state) => ((Socket)state).BeginSendTo(
 238                                                                         targetBuffer.Array,
 239                                                                         targetBuffer.Offset,
 240                                                                         targetBuffer.Count,
 241                                                                         flags,
 242                                                                         endPoint,
 243                                                                         callback,
 244                                                                         state),
 245                 asyncResult => ((Socket)asyncResult.AsyncState).EndSendTo(asyncResult),
 246                 buffer,
 247                 socketFlags,
 248                 remoteEP,
 249                 state: socket);
 250         }
 251     }
 252 }
 253
 254 #endif