unity之如何使用socket来处理消息

参考代码如下：

using System;
using System.Net;
using System.Net.Sockets;
using System.Collections.Generic;
using UnityGMClient.Network.Utility;

namespace UnityGMClient.Network
{
    public class TCPConnect
    {
        private Socket m_CliSocket = null;
        public const int s_nReadBufferSize = 1024 * 64;
        public const int s_nWriteBufferSize = 1024 * 64;
        private IPEndPoint m_IpEndPoint = null;
        private Queue<GameMsgBase> m_WriteMsgQueue = null;
        private NetReadBuffer m_Readbuffer = null;
        private NetWriteBuffer m_Writebuffer = null;
        private bool m_bConnecting = false;
        private bool m_bSending = false;
        private AddressFamily addressFamily = AddressFamily.InterNetwork;

        public bool IsConnected
        {
            get
            {
                if (m_CliSocket != null && m_CliSocket.Connected)
                {
                    return true;
                }
                return false;
            }
        }

        public void InitServerConnect()
        {
            m_WriteMsgQueue = new Queue<GameMsgBase>();
            m_Readbuffer = new NetReadBuffer(s_nReadBufferSize);
            m_Writebuffer = new NetWriteBuffer(s_nWriteBufferSize);
            m_Readbuffer.Clear();
            m_Writebuffer.Clear();
        }

        void ReinitSocket()
        {
            try
            {
                m_CliSocket.Close();
                if (m_IpEndPoint != null)
                {
                    //m_CliSocket = new Socket(m_IpEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
                    m_CliSocket = new Socket(addressFamily, SocketType.Stream, ProtocolType.Tcp);
                }
                else
                {
                    CTrace.Singleton.error("Reinit socket failed. IPEndPoint is null");
                }
            }
            catch (Exception e)
            {
                CTrace.Singleton.error("Reinit socket failed. exception = {0}", e.Message);
            }
        }

        void PostDisconnectMsg()
        {
            GameMsgBase msg = new GameMsg_Disconnect();
            CGameClient.Singleton.msgQueue.Enqueue(msg);
        }

        public void Disconnect()
        {
            if (m_CliSocket.Connected)
            {
                ReinitSocket();
                PostDisconnectMsg();
            }
        }

        public void Connect(string server, int port)
        {
            if (!m_bConnecting)
            {
                IPAddress servAD = null;

                try
                {
                    if (server.Contains(".com") || server.Contains(".net") || server.Contains(".cn"))
                    {
                        IPAddress[] IPs = Dns.GetHostAddresses(server);
                        if (IPs.Length > 0)
                        {
                            servAD = IPs[0];
                        }
                    }
                    else
                    {
                        servAD = IPAddress.Parse(server);
                    }
                }
                catch (Exception e)
                {
                    CTrace.Singleton.error("Parse connect address failed. address = {0}, port = {1}, exception = {3}", server, port, e.Message);
                }

                if (servAD != null)
                {
                    m_IpEndPoint = new IPEndPoint(servAD, port);
                    if(servAD.AddressFamily == AddressFamily.InterNetworkV6) {
                        addressFamily = AddressFamily.InterNetworkV6;
                    } else {
                        addressFamily = AddressFamily.InterNetwork;
                    }
                    m_CliSocket = new Socket(addressFamily, SocketType.Stream, ProtocolType.Tcp);
                    ReConnect();
                }
            }
        }

        public void ReConnect()
        {
            try
            {
                if (m_CliSocket.Connected)
                {
                    ReinitSocket();
                }

                if (m_IpEndPoint != null)
                {
                    CTrace.Singleton.debug("Begin to Connect address = {0}, port = {1}", m_IpEndPoint.Address.ToString() , m_IpEndPoint.Port.ToString());

                    m_bConnecting = true;
                    m_CliSocket.BeginConnect(m_IpEndPoint.Address, m_IpEndPoint.Port, new AsyncCallback(ConnectCallback), this);
                }
                else
                {
                    CTrace.Singleton.error("Connect Error. IPEndPoint is null");
                }
            }
            catch (Exception e)
            {
                CTrace.Singleton.error("Connect address failed. exception = {0}", e.Message);
            }
        }

        public void ConnectCallback(IAsyncResult ar)
        {
            if (ar.IsCompleted)
            {
                m_bConnecting = false;

                try
                {
                    m_CliSocket.EndConnect(ar);
                }
                catch (Exception e)
                {
                    CTrace.Singleton.error("Connect callback failed. exception = {0}", e.Message);
                    ReinitSocket();
                }

                GameMsgBase msg = new GameMsg_Connect(m_CliSocket.Connected);
                CGameClient.Singleton.msgQueue.Enqueue(msg);

                if (m_CliSocket.Connected)
                {
                    CTrace.Singleton.debug("connect success");
                    BeginRecv();
                }
                else
                {
                    CTrace.Singleton.debug("connect failed");
                }
            }
        }

        public void BeginRecv()
        {
            try
            {
                m_CliSocket.BeginReceive(m_Readbuffer.getRealBuffer(),
                    m_Readbuffer.getMaxDataPostion(), m_Readbuffer.getCapability(), 0, new AsyncCallback(ReceiveCallback), this);
            }
            catch (Exception e)
            {
                CTrace.Singleton.error("BeginRecv failed. exception = {0}", e.Message);
            }
        }

        private void ReceiveCallback(IAsyncResult ar)
        {
            try
            {
                NetReadBuffer buffer = m_Readbuffer;
                int nReadDataLen = m_CliSocket.EndReceive(ar);

                if (nReadDataLen == 0)
                {
                    ReinitSocket();
                    PostDisconnectMsg();
                }
                else
                {
                    buffer.setMaxDataPostion(buffer.getMaxDataPostion() + nReadDataLen);
                    CGameClient.Singleton.msgMap.HandleMsg(m_Readbuffer);
                    m_Readbuffer.Settle();
                    BeginRecv();
                }
            }
            catch (Exception e)
            {
                CTrace.Singleton.error("ReceiveCallback failed. exception = {0}, stack trace = 
{1}", e.Message,e.StackTrace);
                ReinitSocket();
                PostDisconnectMsg();
            }
        }

        public void SendMessage(GameMsgBase Msg)
        {
            m_WriteMsgQueue.Enqueue(Msg);
        }

        public void TrySendMsg()
        {
            if (!m_bSending)
            {
                try
                {
                    while (m_WriteMsgQueue.Count > 0)
                    {
                        GameMsgBase gamemsg = m_WriteMsgQueue.Peek();
                        if (!gamemsg.encodeMessage(m_Writebuffer))
                            break;
                        m_WriteMsgQueue.Dequeue();
                        CTrace.Singleton.debug("Send Message. Message Type = {0}, Messenge Id = {1}", gamemsg.Type, gamemsg.MsgId);
                    }

                    if (m_Writebuffer.getPostion() > 0)
                    {
                        m_bSending = true;
                        m_CliSocket.BeginSend(m_Writebuffer.getWriteBuffer(), 0, m_Writebuffer.getPostion(), 0, new AsyncCallback(SendCallback), this);
                    }
                }
                catch (Exception e)
                {
                    CTrace.Singleton.error("TrySendMsg failed. exception = {0}", e.Message);
                    m_bSending = false;
                }
            }
        }

        void SendCallback(IAsyncResult ar)
        {
            try
            {
                m_Writebuffer.Clear();
                m_CliSocket.EndSend(ar);
            }
            catch (Exception e)
            {
                CTrace.Singleton.error("Send Callback failed. exception = {0}", e.Message);
            }
            m_bSending = false;
        }
    }
}

转载请注明出处：https://www.cnblogs.com/jietian331/p/13491851.html