Question

我曾经开始/结束APM模式，我想将我的套接字服务器更新为.Net 4.5 / async / await。我从互联网资源中编写了一个示例代码，但它无法正常工作。

我希望在接受连接（尚未实现..）后，将所有已连接的客户端分隔为自己的类。接受所有传入连接的循环在自己的线程上运行。

基本上，Main.cs是我接受客户端，为连接创建新类（Client.cs / Session.cs）并将接受客户端指向该类的地方。嗯，这就是我计划做的事情，而不是代码和主要问题，目前是我对如何处理这个接受序列的知识以及为什么我当时无法连接多个客户端？我希望你能指出我正确答案。

提前谢谢。

Picture of server logic

码

Form1.cs的

using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace Server
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            // Own thread for accepting connections

            Main ConnectionLoop = new Main(10);
            Thread thread = new Thread(new ThreadStart(ConnectionLoop.PrepareThread));
            thread.IsBackground = true;
            thread.Start();
        }
    }
}

Main.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace Server
{
    public class Main
    {
        private int m_backLog = 0;

        // constructor
        public Main(int Backlog)
        {
            m_backLog = Backlog;
            Console.WriteLine("Main class created, backlog: {0}", Backlog);
        }

        public void PrepareThread()
        {
            Console.WriteLine("Thread created");
            StartAccepting(CancellationToken.None).Wait();
        }

        private async Task StartAccepting(CancellationToken token)
        {
            Console.WriteLine("Started listening..");
            CancellationTokenSource cts = new CancellationTokenSource();
            TcpListener listener = new TcpListener(IPAddress.Any, 6112);
            listener.Start();
            await AcceptClientsAsync(listener, cts.Token);
            //  Thread.Sleep(600000);
        }

        private async Task AcceptClientsAsync(TcpListener listener, CancellationToken token)
        {
            var clientCounter = 0;
            while (!token.IsCancellationRequested)
            {
                TcpClient client = await listener.AcceptTcpClientAsync().ConfigureAwait(false);
                clientCounter++;
                Console.WriteLine("Client {0} accepted!", clientCounter);
                await EchoAsync(client, clientCounter, token);
            }
        }

        private async Task EchoAsync(TcpClient client, int clientCounter, CancellationToken token)
        {
            using (client)
            {
                var buf = new byte[4096];   // buffer for stream
                var stream = client.GetStream();    // stream itself

                while (!token.IsCancellationRequested)
                {
                    // some conditions we don't know is client connected, lets have timeout
                    var timeoutTask = Task.Delay(TimeSpan.FromSeconds(15));
                    var amountReadTask = stream.ReadAsync(buf, 0, buf.Length, token);
                    var completedTask = await Task.WhenAny(timeoutTask, amountReadTask).ConfigureAwait(false);

                    if (completedTask == timeoutTask)
                    {
                        var msg = Encoding.ASCII.GetBytes("Client timed out");
                        await stream.WriteAsync(msg, 0, msg.Length);
                        break;
                    }

                    var amountRead = amountReadTask.Result;
                    if (amountRead == 0) break; // end of stream
                    await stream.WriteAsync(buf, 0, amountRead, token).ConfigureAwait(false);
                }
            }
            Console.WriteLine("Client {0} disconnected", clientCounter);
        }
    }
}

Answer 1

Async用于长时间运行的进程，并防止对长时间运行的I / O绑定进程进行不必要的等待。它不会提供任何类型的并发。它只是释放了CPU，所以它不会等待。

因此，您需要利用TPL的其余部分（任务并行库）来提供允许同时客户端所需的并发性。可能这意味着一旦发生连接就会为客户端分离任务，并使用该任务来管理客户端。

Async可以通过确保每个客户端不阻塞完整的线程来补充它，但是async本身只能帮助你阻止它，它不提供并发性。

首先，我强烈建议您阅读MSDN上有关TPL的所有信息。这很多，但这是一个很好的阅读，并将极大地帮助。 https://msdn.microsoft.com/en-us/library/dd460717(v=vs.110).aspx

至于一个更具体的例子，我可以试试。在接受客户端的循环中，只要有连接的客户端，就会希望获得并行性。这将使您的运行循环返回到接受客户端，并让客户端仍然进行交互。例如：

    private async Task AcceptClientsAsync(TcpListener listener, CancellationToken token)
    {
        var clientCounter = 0;
        while (!token.IsCancellationRequested)
        {
            TcpClient client = await listener.AcceptTcpClientAsync().ConfigureAwait(false);
            clientCounter++;
            Console.WriteLine("Client {0} accepted!", clientCounter);
            Task.Run(async () => await EchoAsync(client, clientCounter, token), token);
        }
    }

注意这是伪代码。我没有尝试编译它。但这个概念很扎实。

如果您拥有大量客户端，则需要比仅使用Task.Run更具体，但对于示例，它可以正常工作。它将利用线程池线程进行并行化。哪个适用于至少100，但在此之后可能会降低性能。

Answer 2

async函数返回在该函数完成时完成的任务。

在AcceptClientsAsync功能中，您await EchoAsync功能。这意味着直到AcceptTcpClientAsync完成后才会再次调用EchoAsync（即，在发出取消令牌信号后）。

对于异步套接字服务器，您应该只有一个只能在循环中接受的任务，并且对于每个连接，您应该有一个＆＃34;处理＆＃34;任务。这些必须是独立的 - 您不能await来自接受任务的处理任务。

更新：根据请求添加示例：

private async Task AcceptClientsAsync(TcpListener listener, CancellationToken token)
{
    var clientCounter = 0;
    while (!token.IsCancellationRequested)
    {
        TcpClient client = await listener.AcceptTcpClientAsync().ConfigureAwait(false);
        clientCounter++;
        Console.WriteLine("Client {0} accepted!", clientCounter);
        var echoTask = EchoAsync(client, clientCounter, token);
        // TODO: save the echoTask in some kind of per-client data structure.
    }
}

async / await Tcp套接字工具只接受一个连接

码

2 个答案: