Socket通讯是软硬件直接常用的一种通讯方式，分为TCP和UDP通讯。

在我的职业生涯中，有且仅用过一次UDP通讯。而TCP通讯系统却经常写，正好今天写了一个TCP通讯的软件。总结一下内容

软件使用C#编程原因写的，为了能够使用所有的电脑，采用了NET Framework 4.0。

启动服务端

服务端启动的时候，先写一个Task任务启动一个服务端的链接,注意服务端的ip,最好设置为0.0.0.0，这样所有的客户端都可以通过服务器ip地址链接到服务端。

Task.Factory.StartNew(() =>
{
    Socket server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    EndPoint point = new IPEndPoint(IPAddress.Parse(ip), port);
    server.Bind(point);
    server.Listen(1000);
    while (true)
    {
        Socket client = server.Accept();
    }
}

服务端会启动一个无限循环的while，在这个循环中，通过Accept方法不断的接收链接的客户端。

接收客户端消息

在这个循环里面可以记录一下客户端的信息，并启动另一个Task任务，去接受客户端给服务端发送的消息。

Task.Factory.StartNew(() =>
{
    while (true) {
        byte[] buffer = new byte[1024];
        if (!client.Connected) {
            break;
        }
        int cnt = 0;
        try {
            cnt = client.Receive(buffer);
            if (cnt <= 0)
            {
                Thread.Sleep(1000);
                continue;
            }
        }
        catch (Exception ex) {
            break;
        }
        //因为buffer数组是1024长度，如果实际数据长度小于1024 则会出现0x00的空白数据，需要删除，只保留有效数据
        List<byte> lstBuffer = new List<byte>();
        for (int i = buffer.Length - 1; i >= 0; i--) {
            if (buffer[i] == 0x00 && lstBuffer.Count<=0)
                continue;
            lstBuffer.Insert(0, buffer[i]);
        }
        //接收到的消息
        Business.queueReceiver.Enqueue(new Tuple<string, byte[]>(pointClient.ToString(), lstBuffer.ToArray<byte>()));
        ReceiveCount += 1;
    }
});

对于服务端来说，任何一个链接到服务端的客户端，在服务端都应该启动一个Task去实时接收客户端的消息。

而由于客户端有可能会随时关闭或者断开，所以对Receive方法加异常判断，防止因为某一次的接收消息异常造成Task任务过期关闭。

对于服务端，一旦发现客户端的消息没有接收成功，或者判断到客户端已经断开，则可以推出while循环，然后关闭Task任务，结束与客户端的链接。

业务逻辑处理

对于任何项目的Socket通讯软件，都会有相关的通信协议，对照业务相关的通信协议和上面接收的客户端信息对业务逻辑进行处理即可。

业务处理需要，如果数据量比较小，则正常处理即可。

如果业务量大，并发大，数据量大等则需要考虑粘包的问题。

为了后期方面查询问题，需要对所有接收和处理的数据做日志处理，在处理日志时，如果有redis最好，如果没有，建议日志信息写入自己定义的队列中(比如:ConcurrentQueue),不建议直接写入文件或者数据库，这样会造成数据处理的效率缓慢。

为了使业务处理的逻辑不影响正常的客户端和服务端的通讯，建议对业务处理在其他的Task任务中进行处理。这样可以保证客户端和服务端之间接收和发送的通道正常。

对客户端发送消息

对于所有链接到服务端的客户端，都应该对客户端进行记录，并在新的Task任务中，分别对服务端需要发送的信息进行发送。这样就可以保证发送消息的统一性，在一个任务中进行发送，方便数据控制。

由于客户端数量不知道，所以发送的时候，把需要发送的消息放入队列中，然后在队列有消息的时候在进行异步发送。只要发送队列中有消息，则不需要对发送任务进行暂停控制，保证消息及时有效。

Task.Factory.StartNew(() =>
{
    while (true)
    {
        try 
        {
            if (Business.queueSender.IsEmpty)
            {
                Thread.Sleep(1000);
                continue;
            }
            Business.queueSender.TryDequeue(out Tuple<string, byte[]> tuple);
            if (tuple == null)
                continue;
            Socket client = Business.dicClient[tuple.Item1];
            if (!client.Connected)
            {
                Business.dicClient.TryRemove(tuple.Item1, out Socket outSocket);
                continue;
            }
            List<byte> buffer = new List<byte>();
            client_name = tuple.Item1;
            buffer.AddRange(tuple.Item2);
            client.BeginSend(buffer.ToArray(), 0, buffer.Count, SocketFlags.None, SendCallback, new Object[] { tuple, client, buffer });
            Thread.Sleep(1);
        }catch (Exception ex) {

        }
    }
});

业务数据入库

在通讯稳定的情况下，如果没有redis缓存等，建议把需要写入数据库的数据也放入队列中，每隔一段时间进行保存。而不要实时保存，数据库的写入需要更多的IO,放到一个Task任务中进行处理，可以保证数据保存的一致性。

Task.Factory.StartNew(() =>
{
    while (true) {
        string[] tablenames = Business.dicSaveData.Keys.ToArray();
        foreach (string table in tablenames) {
            if (Business.dicSaveData[table].IsEmpty) {
                continue;
            }
            var datas= Business.GetDataFromQueue(table);
            DataTable dt = DicToTable(table, datas);
            DbAccess.BatchAdd(table, dt,DbAccess.log_connectionstring);
        }
        Thread.Sleep(30000);
    }
});

日志处理

所有的消息都需要实施显示在系统上，并供用户查询，定位问题。而在CS软件中，如果对界面控件进行操作，就要进入主线程。主线程的频繁操作或者大数据量处理、显示，会造成系统卡顿。影响整个系统的性能。

日志处理也放到一个Task任务中，并定时清空系统软件的界面显示的数据

对于日志信息，也要进行物理保存。在日志信息达到一定的数量，或者达到一段时间后，可以把日志信息保存到文本中。

Task.Factory.StartNew(() =>
{
    List<string> msgs = new List<string>();
    while (true) {
        if (Business.queueMsg.IsEmpty) {
            Thread.Sleep(1000);
            continue;
        }
        while (!Business.queueMsg.IsEmpty) {
            if (msgs.Count > 1000) {
                break;
            }
            Business.queueMsg.TryDequeue(out string msg);
            if (string.IsNullOrEmpty(msg))
                continue;
            msgs.Add(msg);
        }
        try
        {
            string file = #34;{logdir}/{DateTime.Now.ToString("yyyyMMddHH")}.txt";
            string data = string.Join("\r\n", msgs);
            using (StreamWriter writer = new StreamWriter(file, true, Encoding.Default))
            {
                writer.WriteLine(data);
            }
            msgs.Clear();
        }
        catch (Exception ex) {
            Business.AddFailLogs(#34;写日志失败，错误描述:{ex.Message}");
        }
        if (Business.queueMsg.Count > 1000) {
            Thread.Sleep(10);
            continue;
        }
        Thread.Sleep(10000);
    }
});

队列处理

在整个业务逻辑过程中，使用了大量的队列，字典等，需要在软件的界面上显示队列的数量或者字典的详细信息。

说一个碰到的问题：

刚开始写的时候，由于链接的客户端比较少，所以日志的数量比较少，很快就写入数据库了，后来随着客户端的增多，日志的数量翻倍的增加，发现问题后，查询日志竟然找不到。

后来，把日志队列的数量显示在界面上，发现所有的客户端设备上线后，竟然在内存中有5万条日志信息。处理特别缓慢。

客户端测试

在写完服务端后，需要写一个客户端进行所有的协议测试。根据协议文档，在客户端发送相关协议，并收集服务端返回的信息。

客户端测试，可以写单客户端测试，也可以写多客户端测试，通过在软件上定义多个Task任务，分别启动多个客户端进行压力测试和并发测试。

总结

在整个软件的编码过程中，碰到的问题包括

1. 大端小端的数据处理问题
2. 协议文档对接过程中对于字节的定义和编码问题
3. 怎么保证服务端软件持续在线。在前期的测试中，发现有的时候服务端显示正常，但是经常不返回消息，就是因为客户端断开后，服务端的Task关闭了，造成服务端对应的客户端没有反馈。
4. 经常需要与各种设备进行协议对接和修改验证。经常需要给设备端查看相关的协议过程，这就是日志的功劳了
5. 使用Task作业进行异步编程，可以提高软件的使用效率，防止软件出现未响应的情况。

最后

写了这么多年的软件，写过委托处理、多线程处理、Task作业、并行编程、异步编程。

虽然技术发展的很快，业务处理的性能得到的极大的提升。但是看到现在的大数据处理，感觉还得靠提升硬件性能和网络带宽来提升性能。

说一个有趣的事情：

以前写过一个服务端软件，需要接收1000个客户端软件持续发送的大量数据。当时服务端放到了阿里云上，怎么测试都是不行。后来在登录服务器看了看，CPU一直100%。内存倒是不多。

你猜最后怎么解决的，客户把阿里云的CPU提升到128核，CPU马上降到2%。

技术解决性能问题到最后都要钞能力