public static SocketAwaitable AcceptAsync(this Socket socket,
     SocketAwaitable awaitable)
 {
     awaitable.Reset();
     if (!socket.AcceptAsync(awaitable.EventArgs))
         awaitable.WasCompleted = true;
     return awaitable;
 }
示例#2
0
 internal static Task<Socket> AcceptAsync(this Socket socket)
 {
     var tcs = new TaskCompletionSource<Socket>();
     var ce = new SocketAsyncEventArgs { UserToken = tcs };
     ce.Completed += AcceptCompleted;
     if (socket.AcceptAsync(ce))
         return tcs.Task;
     return Task.FromResult(ce.AcceptSocket);
 }
        public static Task<Socket> AcceptSocketAsync(this Socket socket) {
            TaskCompletionSource<Socket> tcs = new TaskCompletionSource<Socket>();

            SocketAsyncEventArgs args = new SocketAsyncEventArgs();
            args.Completed += (object sender, SocketAsyncEventArgs e) => {
                tcs.SetResult(e.AcceptSocket);
            };
            socket.AcceptAsync(args);

            return tcs.Task;
        }
        public static void AcceptAsync(this Socket socket, SocketAsyncEventArgs eventArgs, Action<Socket> handler)
        {
            EventHandler<SocketAsyncEventArgs> wrappedHandler = null;
            wrappedHandler = (_, args) =>
            {
                Assert.Equal(SocketError.Success, args.SocketError);

                Socket remote = args.AcceptSocket;
                args.AcceptSocket = null;
                args.Completed -= wrappedHandler;

                handler(remote);
            };

            eventArgs.Completed += wrappedHandler;
            if (!socket.AcceptAsync(eventArgs))
            {
                wrappedHandler(null, eventArgs);
            }
        }
        public static IObservable<Socket> ToListenerObservable(this Socket socket, int backlog)
        {
            return Observable.Create<Socket>(async (observer, token) =>
            {
                socket.Listen(backlog);

                try
                {
                    while (!token.IsCancellationRequested)
                        observer.OnNext(await socket.AcceptAsync());

                    observer.OnCompleted();

                    socket.Close();
                }
                catch (Exception error)
                {
                    observer.OnError(error);
                }
            });
        }
示例#6
0
 //
 // Summary:
 //     Begins an asynchronous operation to accept an incoming connection attempt.
 //
 // Parameters:
 //   callback:
 //     The System.AsyncCallback delegate.
 //
 //   state:
 //     An object that contains state information for this request.
 //
 // Returns:
 //     An System.IAsyncResult that references the asynchronous System.Net.Sockets.Socket
 //     creation.
 //
 // Exceptions:
 //   T:System.ObjectDisposedException:
 //     The System.Net.Sockets.Socket object has been closed.
 //
 //   T:System.NotSupportedException:
 //     Windows NT is required for this method.
 //
 //   T:System.InvalidOperationException:
 //     The accepting socket is not listening for connections. You must call System.Net.Sockets.Socket.Bind(System.Net.EndPoint)
 //     and System.Net.Sockets.Socket.Listen(System.Int32) before calling System.Net.Sockets.Socket.BeginAccept(System.AsyncCallback,System.Object).-or-
 //     The accepted socket is bound.
 //
 //   T:System.ArgumentOutOfRangeException:
 //     receiveSize is less than 0.
 //
 //   T:System.Net.Sockets.SocketException:
 //     An error occurred when attempting to access the socket. See the Remarks section
 //     for more information.
 public static IAsyncResult BeginAccept(this Socket socket, AsyncCallback callback, object state)
 {
     return TaskToApm.Begin(socket.AcceptAsync(), callback, state);
 }
示例#7
0
 public static void AcceptAsync(this Socket socket, ServerAsyncEventArgs e, ServerAsyncEventArgs.CompletedEventHandler handler)
 {
     e.Completed = handler;
     if (socket.AcceptAsync(e) == false)
         e.OnCompleted(socket);
 }