Example #1
0
 public static void ReceiveFromAPM(this Socket socket, byte[] buffer, int offset, int count, SocketFlags flags, EndPoint remoteEndpoint, Action<int, EndPoint> handler)
 {
     var callback = new AsyncCallback(asyncResult =>
     {
         int received = ((Socket)asyncResult.AsyncState).EndReceiveFrom(asyncResult, ref remoteEndpoint);
         handler(received, remoteEndpoint);
     });
     socket.BeginReceiveFrom(buffer, offset, count, flags, ref remoteEndpoint, callback, socket);
 }
Example #2
0
        public static Task<int> ReceiveAsync(this Socket socket, byte[] buffer, int offset, int size)
        {
            var tcs = new TaskCompletionSource<int>(socket);
            var remoteip = new IPEndPoint(IPAddress.Any, 0);
            var endpoint = (EndPoint)remoteip;

            socket.BeginReceiveFrom(buffer, offset, size, SocketFlags.None, ref endpoint, iar =>
            {
                var result = (TaskCompletionSource<int>)iar.AsyncState;
                var iarSocket = (Socket)result.Task.AsyncState;

                try
                {
                    result.TrySetResult(iarSocket.EndReceive(iar));
                }
                catch (Exception exc)
                {
                    result.TrySetException(exc);
                }
            }, tcs);

            return tcs.Task;
        }
Example #3
0
        public static Task<SocketReceiveFromResult> ReceiveFromAsync(
            this Socket socket, 
            ArraySegment<byte> buffer, 
            SocketFlags socketFlags, 
            EndPoint remoteEndPoint)
        {
            return Task<SocketReceiveFromResult>.Factory.FromAsync(
                (callback, state) => socket.BeginReceiveFrom(
                    buffer.Array, 
                    buffer.Offset, 
                    buffer.Count, 
                    socketFlags, 
                    ref remoteEndPoint, 
                    callback, 
                    state),
                asyncResult => {
                    int bytesReceived = socket.EndReceiveFrom(asyncResult, ref remoteEndPoint);

                    return new SocketReceiveFromResult() {
                        ReceivedBytes = bytesReceived,
                        RemoteEndPoint = remoteEndPoint };
                },
                null);
        }
        /// <summary>
        /// Extends BeginReceiveFrom so that buffer offset of 0 and call to Array.Length are not needed.
        /// <example>
        /// socket.BeginReceiveFrom(buffer, socketFlags, remoteEP, callback);
        /// </example>
        /// </summary>
        public static IAsyncResult BeginReceiveFrom(this Socket socket, Byte[] buffer, SocketFlags socketFlags, ref System.Net.EndPoint remoteEP, AsyncCallback callback)
        {
            if(socket == null) throw new ArgumentNullException("socket");

            if(buffer == null) throw new ArgumentNullException("buffer");

            return socket.BeginReceiveFrom(buffer, 0, buffer.Length, socketFlags, ref remoteEP, callback);
        }
        /// <summary>
        /// Extends BeginReceiveFrom so that when a state object is not needed, null does not need to be passed.
        /// <example>
        /// socket.BeginReceiveFrom(buffer, offset, size, socketFlags, remoteEP, callback);
        /// </example>
        /// </summary>
        public static IAsyncResult BeginReceiveFrom(this Socket socket, Byte[] buffer, Int32 offset, Int32 size, SocketFlags socketFlags, ref System.Net.EndPoint remoteEP, AsyncCallback callback)
        {
            if(socket == null) throw new ArgumentNullException("socket");

            return socket.BeginReceiveFrom(buffer, offset, size, socketFlags, ref remoteEP, callback, null);
        }
Example #6
0
        public static Task<ReceiveFromOutput> ReceiveFromAsync(this Socket socket, byte[] buffer, int offset, int size,
            SocketFlags socketFlags, EndPoint remoteEp)
        {
            var input = new ReceiveFromInput(socket, remoteEp);
            var tcs = new TaskCompletionSource<ReceiveFromOutput>(input);

            socket.BeginReceiveFrom(buffer, offset, size, socketFlags, ref remoteEp, ar =>
            {
                var t = (TaskCompletionSource<ReceiveFromOutput>)ar.AsyncState;
                var input2 = (ReceiveFromInput)t.Task.AsyncState;
                Socket s = input2.Socket;
                EndPoint ep = input2.RemoteEp;
                try
                {
                    int recv = s.EndReceiveFrom(ar, ref ep);

                    var output = new ReceiveFromOutput(recv, ep);
                    t.TrySetResult(output);
                }
                catch (Exception ex)
                {
                    t.TrySetException(ex);
                }
            }, tcs);
            return tcs.Task;
        }