.net Socket 客户端

记录下这两天修改后的Socket客户端类，用在unity上的。

服务器返回的消息采用 4+n 简单协议，即数据包的前4个字节代表真实数据长度.

1. 因为需求会切换服务器地址，所以支持切换服务器重新创建连接；
2. 创建一个新连接后，会立刻创建一个线程用于监听服务器返回数据；
3. 创建一个定时处理线程，当连接闲置15秒后，关闭当前线程；

代码很简单，只有核心代码，稍微修改下可以直接使用:

static DateTime lastAvtiveDateTime = DateTime.Now;
static Socket tcpClient;
static Thread tcpClientThread;
static bool tcpRecvThreadRuning;
static IPEndPoint CurrentRemoteEP;
static bool tcpIsWorking = false;
const int tcpCacheSeconds = 15;

/// <summary>
/// 发送数据到指定服务器
/// </summary>
/// <param name="buffer"></param>
/// <param name="remoteEP"></param>
public static void SendTcp(byte[] buffer, IPEndPoint remoteEP)
{
    lastAvtiveDateTime = DateTime.Now;
    if (tcpClient == null)
    {
        InitTcpClient();
    }

    if (tcpClientThread == null)
    {
        tcpClientThread = new Thread(new ThreadStart(CloseTcpWork));
        tcpClientThread.IsBackground = true;
        tcpClientThread.Start();
    }

    if (!tcpClient.Connected || remoteEP.ToString() != CurrentRemoteEP.ToString())
    {
        CloseTcpClient();
        CurrentRemoteEP = remoteEP;

        if (ConnectTo(CurrentRemoteEP))
        {
            Debug.Log("###通讯报告###：连接服务器成功!");
            CreateRecvThread();
        }
        else
        {
            OnError(new Exception("###通讯报告###：创建服务器连接失败!"));
            return;
        }
    }
    tcpIsWorking = true;//防止连接在等待接收过程中被关闭
    try
    {
        tcpClient.Send(buffer);
        Debug.Log("###通讯报告###：数据发送成功!");
    }
    catch (Exception ex)
    {
        CloseTcpClient();
        tcpIsWorking = false;
        OnError(new Exception("###通讯报告###：数据发送失败!", ex));
    }
    finally
    {
        lastAvtiveDateTime = DateTime.Now;
    }
}

/// <summary>
/// 初始化Socket连接
/// </summary>
private static void InitTcpClient()
{
    tcpClient = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
}

/// <summary>
/// 创建连接
/// </summary>
/// <param name="remoteEP"></param>
/// <returns></returns>
private static bool ConnectTo(IPEndPoint remoteEP)
{
    try
    {
        tcpClient.Connect(remoteEP);
        return true;
    }
    catch
    {
        tcpClient.Close();
        tcpClient = null;
        return false;
    }
}

/// <summary>
/// 创建数据接收线程
/// </summary>
private static void CreateRecvThread()
{
    Thread tcpRecvThread = new Thread(new ThreadStart(Recv));
    tcpRecvThread.IsBackground = true;
    tcpRecvThreadRuning = true;
    tcpRecvThread.Start();
}

/// <summary>
/// 数据接收工作
/// </summary>
private static void Recv()
{
    Debug.Log("###通讯报告###：数据接收线程已启动!");
    while (tcpRecvThreadRuning)
    {
        if (tcpIsWorking)
        {
            try
            {
                byte[] recv_length = new byte[4];

                int length = tcpClient.Receive(recv_length);
                if (length < 0)
                {
                    throw new Exception("###通讯报告###：连接出错!");
                }
                else if (length == 0)
                {
                    throw new Exception("###通讯报告###：连接已从远程关闭!");
                }
                //else if (length == 3 && recv_length.Take(3).ToArray().SequenceEqual(UnhandleBytes))
                //{
                //    throw new Exception("###通讯报告###：请求协议错误!");
                //}
                else if (length == 4)
                {
                    int packageLen = BitConverter.ToInt32(recv_length, 0);
                    byte[] recv_data = new byte[packageLen];
                    int recvDataLength;
                    using (MemoryStream stream = new MemoryStream())
                    {
                        do
                        {
                            recvDataLength = tcpClient.Receive(recv_data);
                            if (recvDataLength > 0)
                            {
                                stream.Write(recv_data, 0, recvDataLength);
                            }
                        } while (stream.Length < packageLen);

                        Debug.Log("###通讯报告###：接收数据长度 " + stream.Length);
                        if (packageLen == stream.Length)
                        {
                            lastAvtiveDateTime = DateTime.Now;
                            tcpIsWorking = false;
                            OnNewPackageReceived(stream.ToArray());
                            continue;
                        }
                    }
                }
                throw new Exception("###通讯报告###：接收数据长度不正确!");
            }
            catch (Exception ex)
            {
                tcpClient.Close();
                tcpClient = null;
                Debug.Log(ex.Message);
                tcpIsWorking = false;
                OnError(ex);
                break;
            }
        }
        else
        {
            Thread.Sleep(0);
        }
    }
    Debug.Log("###通讯报告###：数据接收线程已关闭!");
}

/// <summary>
/// 关闭当前连接
/// </summary>
private static void CloseTcpClient()
{
    tcpRecvThreadRuning = false;
    if (tcpClient.Connected)
    {
        tcpClient.Close();
        tcpClient.Dispose();
        Debug.Log("###通讯报告###：服务器连接已关闭!");
    }
    InitTcpClient();
}

/// <summary>
/// 关闭连接线程工作
/// </summary>
private static void CloseTcpWork()
{
    while (true)
    {
        if (!tcpIsWorking && DateTime.Now.AddSeconds(-tcpCacheSeconds) > lastAvtiveDateTime)
        {
            CloseTcpClient();
        }
        if (!tcpClient.Connected)
        {
            Thread.Sleep(tcpCacheSeconds * 1000);
        }
        else
        {
            Thread.Sleep(1000);
        }

    }
}

/// <summary>
/// 错误操作
/// </summary>
private static void OnError(Exception e)
{
    Debug.Log(e.Message);
    //TODO
}

/// <summary>
/// 收到新包操作
/// </summary>
private static void OnNewPackageReceived(byte[] bytes)
{
    Debug.Log("###通讯报告###：数据接收成功!");
    //TODO
}

---

记录一篇介绍socket的文章：你得学会并且学得会的Socket编程基础知识