C# TcpListener.AcceptTcpClientAsync方法代码示例

 private void StartListener(IPEndPoint endPoint)
 {
     _listener = new TcpListener(endPoint);
     _listener.Start(5);
     _log.WriteLine("Server {0} listening", endPoint.Address.ToString());
     _listener.AcceptTcpClientAsync().ContinueWith(t => OnAccept(t), TaskScheduler.Default);
 }

        public static void Main(string[] args)
        {
            Console.WriteLine("Starting...");
            X509Certificate2 serverCertificate = new X509Certificate2("certificate.pfx"); // Any valid certificate with private key will work fine.
            TcpListener listener = new TcpListener(IPAddress.Any, 4567);
            TcpClient client = new TcpClient();
            listener.Start();

            Task clientConnectTask = client.ConnectAsync(IPAddress.Loopback, 4567);
            Task<TcpClient> listenerAcceptTask = listener.AcceptTcpClientAsync();
            Task.WaitAll(clientConnectTask, listenerAcceptTask);

            TcpClient server = listenerAcceptTask.Result;
            SslStream clientStream = new SslStream(client.GetStream(), false, new RemoteCertificateValidationCallback(ValidateServerCertificate), null, EncryptionPolicy.RequireEncryption);
            SslStream serverStream = new SslStream(server.GetStream(), false, null, null, EncryptionPolicy.RequireEncryption);

            Task clientAuthenticationTask = clientStream.AuthenticateAsClientAsync(serverCertificate.GetNameInfo(X509NameType.SimpleName, false), null, SslProtocols.Tls12, false);
            Task serverAuthenticationTask = serverStream.AuthenticateAsServerAsync(serverCertificate, false, SslProtocols.Tls12, false);
            Task.WaitAll(clientAuthenticationTask, serverAuthenticationTask);
            
            byte[] readBuffer = new byte[256];
            Task<int> readTask = clientStream.ReadAsync(readBuffer, 0, readBuffer.Length); // Create a pending ReadAsync, which will wait for data that will never come (for testing purposes).
            byte[] writeBuffer = new byte[256];
            Task writeTask = clientStream.WriteAsync(writeBuffer, 0, writeBuffer.Length); // The main thread actually blocks here (not asychronously waits) on .NET Core making this call.
            bool result = Task.WaitAll(new Task[1] { writeTask }, 5000); // This code won't even be reached on .NET Core. Works fine on .NET Framework.

            if (result)
            {
                Console.WriteLine("WriteAsync completed successfully while ReadAsync was pending... nothing locked up.");
            }
            else
            {
                Console.WriteLine("WriteAsync failed to complete after 5 seconds.");
            }
        }

        public static IDisposable HandleClients(TcpListener listener, Func<TcpClient, string, Task> handleClientAccessPolicy, string policyResponse)
        {
            listener.Start();

            var disposableHandler = ThreadPoolScheduler.Instance.ScheduleAsync(async (scheduler, ct) =>
            {
                var disposable = new BooleanDisposable();

                while (!disposable.IsDisposed)
                {
                    var client = await listener.AcceptTcpClientAsync();
                    await handleClientAccessPolicy(client, policyResponse);
                    await scheduler.Yield();
                }

                return disposable;
            });

            var compositeDisposable = new CompositeDisposable();

            compositeDisposable.Add(Disposable.Create(() => listener.Stop()));
            compositeDisposable.Add(disposableHandler);

            return compositeDisposable;
        }

        public static void TestTcpLisener()
        {
            var tcpListener = new TcpListener(IPAddress.Any, 3456);
            tcpListener.Start();
            tcpListener.AcceptTcpClientAsync();

            var tcpClient = new TcpClient();
            tcpClient.Connect(IPAddress.Parse("127.0.0.1"), 3456);

            var clnt = tcpListener.AcceptTcpClientAsync().ConfigureAwait(true).GetAwaiter().GetResult();
        }

 /// <summary>
 /// Method to be used on seperate thread.
 /// </summary>
 private Task RunServerAsync()
 {
     return Task.Run(async () =>
     {
         try
         {
             logger.Info("Starting tcp server on port {0}", settings.Port);
             var listener = new TcpListener(IPAddress.Any, settings.Port);
             listener.Start();
             while (runServer)
             {
                 try
                 {
                     var client = await listener.AcceptTcpClientAsync().WithCancellation(cancellationToken.Token);
                     logger.Info("Got new TCP client from {0}", client.Client.RemoteEndPoint as IPEndPoint);
                     tcpClients.AddLast(client);
                     HandleClientAsync(client);
                 }
                 catch (Exception exp)
                 {
                     logger.Error(exp, "Exception while waiting for new TCP client.");
                 }
             }
         }
         catch (Exception exp)
         {
             logger.Error(exp, "Exception starting Tcp Server.");
         }
     });
 }

 static async Task AcceptClient (TcpListener server, TaskCompletionSource<byte[]> result)
 {
     using (var client = await server.AcceptTcpClientAsync ())
     using (var stream = client.GetStream ()) {
         result.SetResult (await DataStreamReader.ReadDataAsync (stream));
     }
 }

        public async Task TestTcpTraceListener()
        {
            var listener = new TcpListener(IPAddress.Loopback, 0);
            listener.Start();
            int port = ((IPEndPoint)listener.Server.LocalEndPoint).Port;


            var traceSource = new TraceSource("UnitTestLogger");
            traceSource.Listeners.Remove("Default");
            traceSource.Switch.Level = SourceLevels.All;
            traceSource.Listeners.Add(new TcpTraceListener(
                                            IPAddress.Loopback, port, 
                                            new ExponentialBackoffTcpReconnectionPolicy()));

            var listenerClient = await listener.AcceptTcpClientAsync();

            traceSource.TraceEvent(TraceEventType.Information, 100, "Boris");

            var receiverReader = new StreamReader(listenerClient.GetStream());
            var line = await receiverReader.ReadLineAsync();

            Assert.True(line.EndsWith("UnitTestLogger Information: 100 : Boris"));

            listenerClient.Close();
            listener.Stop();
            traceSource.Close();
        }

        public async Task TestEventSink()
        {
            var listener = new TcpListener(IPAddress.Loopback, 0);
            listener.Start();
            int port = ((IPEndPoint)listener.Server.LocalEndPoint).Port;

            var slabListener = new ObservableEventListener();
            slabListener.Subscribe(new TcpEventSink(IPAddress.Loopback, port, 
                new ExponentialBackoffTcpReconnectionPolicy(),
                new TestEventFormatter()));
            var source = TestEventSource.GetInstance();
            slabListener.EnableEvents(source, EventLevel.LogAlways, Keywords.All);

            var listenerClient = await listener.AcceptTcpClientAsync();

            source.Message("Boris", "Meep");

            var receiverReader = new StreamReader(listenerClient.GetStream());
            var line = await receiverReader.ReadLineAsync();

            Assert.Equal(
                "EventId=1 EventName=MessageInfo Level=Error \"FormattedMessage=Meep - Boris\" \"message=Boris\" \"caller=Meep\"",
                line);

            listenerClient.Close();
            listener.Stop();
            slabListener.Dispose();
        }

        public void SendReceiveAndVerify_keeps_SendTimeout_ReceiveTimeout()
        {
            var endpoint = TestHelpers.CreateEndpointForTransport(RedFoxTransport.Tcp);
            var socketConfiguration = new SocketConfiguration
            {
                SendTimeout = TimeSpan.FromSeconds(10),
                ReceiveTimeout = TimeSpan.FromSeconds(20)
            };

            var server = new TcpListener(IPAddress.Loopback, endpoint.Port);
            server.Start();
            try
            {
                server.AcceptTcpClientAsync();

                var nodeGreetingVerifier = new NodeGreetingMessageVerifier(NodeType.Requester, NodeType.Responder);

                var socket = (TcpSocket)new SocketFactory().CreateAndConnectAsync(endpoint, NodeType.Responder, socketConfiguration);
                Assert.Throws<TimeoutException>(() => nodeGreetingVerifier.SendReceiveAndVerify(socket, TimeSpan.FromSeconds(2)));

                Assert.AreEqual(socketConfiguration.SendTimeout.ToMillisOrZero(), socket.TcpClient.SendTimeout);
                Assert.AreEqual(socketConfiguration.ReceiveTimeout.ToMillisOrZero(), socket.TcpClient.ReceiveTimeout);
            }
            finally
            {
                server.Stop();
            }
        }

        public Task Start(CancellationToken cancellationToken)
        {
            Console.WriteLine($"Starting viewer connector on port {_listenerPort}.");
            var listener = new TcpListener(IPAddress.Any, _listenerPort);
            listener.Start();

            return Task.Run(async () =>
            {
                var clients = new List<Task>();
                try
                {
                    while (!cancellationToken.IsCancellationRequested)
                    {
                        var tcpClient =
                            await listener.AcceptTcpClientAsync().ContinueWith(t => t.Result, cancellationToken);
                        clients = clients.Where(task => !task.IsCompleted).ToList();
                        clients.Add(HandleSinglePlayer(tcpClient, cancellationToken));
                    }
                }
                finally
                {
                    await Task.WhenAll(clients.ToArray());
                }
            }, cancellationToken);
        }

        private static string ReadFromClient()
        {
            TcpListener listener = null;
            try
            {
                listener = new TcpListener(IPAddress.Any, 6740);
                listener.Start();
                var acceptTcpClientAsync = listener.AcceptTcpClientAsync();
                acceptTcpClientAsync.Wait(5000);
                if (acceptTcpClientAsync.IsCompleted)
                {
                    using (TcpClient client = acceptTcpClientAsync.Result)
                    {
                        using (StreamReader reader = new StreamReader(client.GetStream(), Encoding.UTF8))
                        {
                            string actual;
                            actual = reader.ReadLine();
                            return actual;
                        }

                    }
                }
                else
                {
                    return null;
                }
            }
            finally
            {
                listener?.Stop();
            }
        }

        public void Run()
        {
            if (_disposed)
            {
                throw new InvalidOperationException("Cannot run disposed server");
            }
            _server = new TcpListener(_host, _port);

            // Start listening for client requests.
            _server.Start();
            _running = true;
            Task.Run(async () =>
            {
                while (_running)
                {
                    var tcpClient = await _server.AcceptTcpClientAsync();
                    var cancelTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(5)); // todo configuration
                    var task = Task.Run(async () =>
                    {
                        var source = tcpClient.GetStream();
                        var lines = await new LineParser().Parse(source, cancelTokenSource.Token);
                        var httpRequest = HttpRequest.Parse(lines);
                        var responseChannel = new HttpResponseChannel(tcpClient);
                        var httpContext = new HttpContext(httpRequest, responseChannel, cancelTokenSource.Token);
                        _handler(httpContext);
                    }, cancelTokenSource.Token);
                }
            });
        }

        public void SocketConfiguration_applied_to_TcpSocket_when_connecting(NodeType nodeType, bool hasReceiveTimeout)
        {
            var endpoint = TestHelpers.CreateEndpointForTransport(RedFoxTransport.Tcp);
            var socketConfiguration = new SocketConfiguration
            {
                ConnectTimeout = TimeSpan.FromSeconds(5),
                SendBufferSize = 128,
                ReceiveBufferSize = 256,
                SendTimeout = TimeSpan.FromSeconds(1),
                ReceiveTimeout = TimeSpan.FromSeconds(2)
            };

            var server = new TcpListener(IPAddress.Loopback, endpoint.Port);
            server.Start();
            try
            {
                server.AcceptTcpClientAsync();

                var socket = (TcpSocket)new SocketFactory().CreateAndConnectAsync(endpoint, nodeType, socketConfiguration);

                Assert.AreEqual(socketConfiguration.SendBufferSize, socket.TcpClient.SendBufferSize);
                Assert.AreEqual(socketConfiguration.ReceiveBufferSize, socket.TcpClient.ReceiveBufferSize);
                Assert.AreEqual(socketConfiguration.SendTimeout.ToMillisOrZero(), socket.TcpClient.SendTimeout);
                var expectedReceiveTimeout = hasReceiveTimeout ? socketConfiguration.ReceiveTimeout.ToMillisOrZero() : 0;
                Assert.AreEqual(expectedReceiveTimeout, socket.TcpClient.ReceiveTimeout);
            }
            finally
            {
                server.Stop();
            }
        }

        public async void Start()
        {
            recorder.StartRecording();

            var ipAdresses = Dns.GetHostEntry("localhost");
            this.IPAddress =
                ipAdresses.AddressList.FirstOrDefault(x => x.AddressFamily == AddressFamily.InterNetwork) ??
                ipAdresses.AddressList.First();

            listener = new TcpListener(this.IPAddress, 5050);
            listener.Start();

            IsActive = true;
            while (IsActive)
            {
                var dTask = Task.Delay(1000);
                var sTask = listener.AcceptTcpClientAsync();

                var t = await Task.WhenAny(dTask, sTask);

                if (t == sTask)
                {
                    ProcessResult(sTask.Result);
                }

                if (terminate)
                {
                    IsActive = false;
                }
            }
        }

        public override async void initialize()
        {
            log.Info("Setting up for AddonManager.");
            isWaitingForClient = true;

            try
            {
                listener = new TcpListener(IPAddress.Parse("127.0.0.1"), 0);
                listener.Start();
                port = ((IPEndPoint)listener.LocalEndpoint).Port;

                log.Info(String.Format("Successfully setup AddonManager IPC Talk on port {0}.", port));

                client = await listener.AcceptTcpClientAsync();
                log.Info("Accepted AddonManager client.");

                isAddonManagerRunning = true;
                isWaitingForClient = false;

                cts = new CancellationTokenSource();
                ct = cts.Token;

                stream = client.GetStream();
                client.Client.NoDelay = true;
                client.NoDelay = true;

                listenLoop();
            }
            catch (ObjectDisposedException ex)
            {
                log.Warn("Shutdown of IPC Talk is requested while waiting a client connection from AddonManager.", ex);
            }
        }