C#SocketAsyncEventArgs实现高效能多并发TCPSocket通信 (客户端实现)

    上一篇讲了服务器端的实现, 这一篇就是客户端的实现.

    服务器实现参考：《C#如何利用SocketAsyncEventArgs实现高效能TCPSocket通信 (服务器实现)》

     与服务器不同的是客户端的实现需要多个SocketAsyncEventArgs共同协作，至少需要两个：接收的只需要一个，发送的需要一个，也可以多个,这在多线程中尤为重要，接下来说明。

 

     客户端一般需要数据的时候，就要发起请求，在多线程环境中，请求服务器一般不希望列队等候，这样会大大拖慢程序的处理。如果发送数据包的SocketAsyncEventArgs只有一个，且当他正在工作的时候, 下一个请求也来访问,这时会抛出异常, 提示当前的套接字正在工作, 所以这不是我们愿意看到, 唯有增加SocketAsyncEventArgs对象来解决。 那么接下来的问题就是我怎么知道当前的SocketAsyncEventArgs对象是否正在工作呢. 很简单，我们新建一个MySocketEventArgs类来继承它。

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

namespace Plates.Client.Net
{
    class MySocketEventArgs : SocketAsyncEventArgs
    {

        /// <summary>
        /// 标识，只是一个编号而已
        /// </summary>
        public int ArgsTag { get; set; }

        /// <summary>
        /// 设置/获取使用状态
        /// </summary>
        public bool IsUsing { get; set; }

    }
}

 

     接下来，我们还需要BufferManager类，这个类已经在服务端贴出来了，与服务端是一样的， 再贴一次：

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

namespace Plates.Client.Net
{
    class BufferManager
    {
        int m_numBytes;                 // the total number of bytes controlled by the buffer pool
        byte[] m_buffer;                // the underlying byte array maintained by the Buffer Manager
        Stack<int> m_freeIndexPool;     // 
        int m_currentIndex;
        int m_bufferSize;

        public BufferManager(int totalBytes, int bufferSize)
        {
            m_numBytes = totalBytes;
            m_currentIndex = 0;
            m_bufferSize = bufferSize;
            m_freeIndexPool = new Stack<int>();
        }

        // Allocates buffer space used by the buffer pool
        public void InitBuffer()
        {
            // create one big large buffer and divide that 
            // out to each SocketAsyncEventArg object
            m_buffer = new byte[m_numBytes];
        }

        // Assigns a buffer from the buffer pool to the 
        // specified SocketAsyncEventArgs object
        //
        // <returns>true if the buffer was successfully set, else false</returns>
        public bool SetBuffer(SocketAsyncEventArgs args)
        {

            if (m_freeIndexPool.Count > 0)
            {
                args.SetBuffer(m_buffer, m_freeIndexPool.Pop(), m_bufferSize);
            }
            else
            {
                if ((m_numBytes - m_bufferSize) < m_currentIndex)
                {
                    return false;
                }
                args.SetBuffer(m_buffer, m_currentIndex, m_bufferSize);
                m_currentIndex += m_bufferSize;
            }
            return true;
        }

        // Removes the buffer from a SocketAsyncEventArg object.  
        // This frees the buffer back to the buffer pool
        public void FreeBuffer(SocketAsyncEventArgs args)
        {
            m_freeIndexPool.Push(args.Offset);
            args.SetBuffer(null, 0, 0);
        }
    }
}

 

     接下来是重点实现了，别的不多说，看代码：

 

using System;
using System.Collections;
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 Plates.Client.Net
{
    class SocketManager: IDisposable
    {
        private const Int32 BuffSize = 1024;

        // The socket used to send/receive messages.
        private Socket clientSocket;

        // Flag for connected socket.
        private Boolean connected = false;

        // Listener endpoint.
        private IPEndPoint hostEndPoint;

        // Signals a connection.
        private static AutoResetEvent autoConnectEvent = new AutoResetEvent(false);

        BufferManager m_bufferManager;
        //定义接收数据的对象
        List<byte> m_buffer; 
        //发送与接收的MySocketEventArgs变量定义.
        private List<MySocketEventArgs> listArgs = new List<MySocketEventArgs>();
        private MySocketEventArgs receiveEventArgs = new MySocketEventArgs();
        int tagCount = 0;

        /// <summary>
        /// 当前连接状态
        /// </summary>
        public bool Connected { get { return clientSocket != null && clientSocket.Connected; } }

        //服务器主动发出数据受理委托及事件
        public delegate void OnServerDataReceived(byte[] receiveBuff);
        public event OnServerDataReceived ServerDataHandler;

        //服务器主动关闭连接委托及事件
        public delegate void OnServerStop();
        public event OnServerStop ServerStopEvent;


        // Create an uninitialized client instance.
        // To start the send/receive processing call the
        // Connect method followed by SendReceive method.
        internal SocketManager(String ip, Int32 port)
        {
            // Instantiates the endpoint and socket.
            hostEndPoint = new IPEndPoint(IPAddress.Parse(ip), port);
            clientSocket = new Socket(hostEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
            m_bufferManager = new BufferManager(BuffSize * 2, BuffSize);
            m_buffer = new List<byte>();
        }

        /// <summary>
        /// 连接到主机
        /// </summary>
        /// <returns>0.连接成功, 其他值失败,参考SocketError的值列表</returns>
        internal SocketError Connect()
        {
            SocketAsyncEventArgs connectArgs = new SocketAsyncEventArgs();
            connectArgs.UserToken = clientSocket;
            connectArgs.RemoteEndPoint = hostEndPoint;
            connectArgs.Completed += new EventHandler<SocketAsyncEventArgs>(OnConnect);

            clientSocket.ConnectAsync(connectArgs);
            autoConnectEvent.WaitOne(); //阻塞. 让程序在这里等待,直到连接响应后再返回连接结果
            return connectArgs.SocketError;
        }

        /// Disconnect from the host.
        internal void Disconnect()
        {
            clientSocket.Disconnect(false);
        }

        // Calback for connect operation
        private void OnConnect(object sender, SocketAsyncEventArgs e)
        {
            // Signals the end of connection.
            autoConnectEvent.Set(); //释放阻塞.
            // Set the flag for socket connected.
            connected = (e.SocketError == SocketError.Success);
            //如果连接成功,则初始化socketAsyncEventArgs
            if (connected) 
                initArgs(e);
        }


        #region args

        /// <summary>
        /// 初始化收发参数
        /// </summary>
        /// <param name="e"></param>
        private void initArgs(SocketAsyncEventArgs e)
        {
            m_bufferManager.InitBuffer();
            //发送参数
            initSendArgs();
            //接收参数
            receiveEventArgs.Completed += new EventHandler<SocketAsyncEventArgs>(IO_Completed);
            receiveEventArgs.UserToken = e.UserToken;
            receiveEventArgs.ArgsTag = 0;
            m_bufferManager.SetBuffer(receiveEventArgs);

            //启动接收,不管有没有,一定得启动.否则有数据来了也不知道.
            if (!e.ConnectSocket.ReceiveAsync(receiveEventArgs))
                ProcessReceive(receiveEventArgs);
        }

        /// <summary>
        /// 初始化发送参数MySocketEventArgs
        /// </summary>
        /// <returns></returns>
        MySocketEventArgs initSendArgs()
        {
            MySocketEventArgs sendArg = new MySocketEventArgs();
            sendArg.Completed += new EventHandler<SocketAsyncEventArgs>(IO_Completed);
            sendArg.UserToken = clientSocket;
            sendArg.RemoteEndPoint = hostEndPoint;
            sendArg.IsUsing = false;
            Interlocked.Increment(ref tagCount);
            sendArg.ArgsTag = tagCount;
            lock (listArgs)
            {
                listArgs.Add(sendArg);
            }
            return sendArg;
        }



        void IO_Completed(object sender, SocketAsyncEventArgs e)
        {
            MySocketEventArgs mys = (MySocketEventArgs)e;
            // determine which type of operation just completed and call the associated handler
            switch (e.LastOperation)
            {
                case SocketAsyncOperation.Receive:
                    ProcessReceive(e);
                    break;
                case SocketAsyncOperation.Send:
                    mys.IsUsing = false; //数据发送已完成.状态设为False
                    ProcessSend(e);
                    break;
                default:
                    throw new ArgumentException("The last operation completed on the socket was not a receive or send");
            }
        }

        // This method is invoked when an asynchronous receive operation completes. 
        // If the remote host closed the connection, then the socket is closed.  
        // If data was received then the data is echoed back to the client.
        //
        private void ProcessReceive(SocketAsyncEventArgs e)
        {
            try
            {
                // check if the remote host closed the connection
                Socket token = (Socket)e.UserToken;
                if (e.BytesTransferred > 0 && e.SocketError == SocketError.Success)
                {
                    //读取数据
                    byte[] data = new byte[e.BytesTransferred];
                    Array.Copy(e.Buffer, e.Offset, data, 0, e.BytesTransferred);
                    lock (m_buffer)
                    {
                        m_buffer.AddRange(data);
                    }

                    do
                    {
                        //注意: 这里是需要和服务器有协议的,我做了个简单的协议,就是一个完整的包是包长(4字节)+包数据,便于处理,当然你可以定义自己需要的; 
                        //判断包的长度,前面4个字节.
                        byte[] lenBytes = m_buffer.GetRange(0, 4).ToArray();
                        int packageLen = BitConverter.ToInt32(lenBytes, 0);
                        if (packageLen <= m_buffer.Count - 4)
                        {
                            //包够长时,则提取出来,交给后面的程序去处理
                            byte[] rev = m_buffer.GetRange(4, packageLen).ToArray();
                            //从数据池中移除这组数据,为什么要lock,你懂的
                            lock (m_buffer)
                            {
                                m_buffer.RemoveRange(0, packageLen + 4);
                            }
                            //将数据包交给前台去处理
                            DoReceiveEvent(rev);
                        }
                        else
                        {   //长度不够,还得继续接收,需要跳出循环
                            break;
                        }
                    } while (m_buffer.Count > 4);
                    //注意:你一定会问,这里为什么要用do-while循环?   
                    //如果当服务端发送大数据流的时候,e.BytesTransferred的大小就会比服务端发送过来的完整包要小,  
                    //需要分多次接收.所以收到包的时候,先判断包头的大小.够一个完整的包再处理.  
                    //如果服务器短时间内发送多个小数据包时, 这里可能会一次性把他们全收了.  
                    //这样如果没有一个循环来控制,那么只会处理第一个包,  
                    //剩下的包全部留在m_buffer中了,只有等下一个数据包过来后,才会放出一个来.
                    //继续接收
                    if (!token.ReceiveAsync(e))
                        this.ProcessReceive(e);
                }
                else
                {
                    ProcessError(e);
                }
            }
            catch (Exception xe)
            {
                Console.WriteLine(xe.Message);
            }
        }

        // This method is invoked when an asynchronous send operation completes.  
        // The method issues another receive on the socket to read any additional 
        // data sent from the client
        //
        // <param name="e"></param>
        private void ProcessSend(SocketAsyncEventArgs e)
        {
            if (e.SocketError != SocketError.Success)
            { 
                ProcessError(e);
            }
        }

        #endregion

        #region read write

        // Close socket in case of failure and throws
        // a SockeException according to the SocketError.
        private void ProcessError(SocketAsyncEventArgs e)
        {
            Socket s = (Socket)e.UserToken;
            if (s.Connected)
            {
                // close the socket associated with the client
                try
                {
                    s.Shutdown(SocketShutdown.Both);
                }
                catch (Exception)
                {
                    // throws if client process has already closed
                }
                finally
                {
                    if (s.Connected)
                    {
                        s.Close();
                    }
                    connected = false;
                }
            }
            //这里一定要记得把事件移走,如果不移走,当断开服务器后再次连接上,会造成多次事件触发.
            foreach (MySocketEventArgs arg in listArgs)
                arg.Completed -= IO_Completed;
            receiveEventArgs.Completed -= IO_Completed;

            if (ServerStopEvent != null)
                ServerStopEvent();
        }

        // Exchange a message with the host.
        internal void Send(byte[] sendBuffer)
        {
            if (connected)
            {
                //先对数据进行包装,就是把包的大小作为头加入,这必须与服务器端的协议保持一致,否则造成服务器无法处理数据.
                byte[] buff = new byte[sendBuffer.Length + 4];
                Array.Copy(BitConverter.GetBytes(sendBuffer.Length), buff, 4);
                Array.Copy(sendBuffer, 0, buff, 4, sendBuffer.Length);
                //查找有没有空闲的发送MySocketEventArgs,有就直接拿来用,没有就创建新的.So easy!
                MySocketEventArgs sendArgs = listArgs.Find(a => a.IsUsing == false);
                if (sendArgs == null) {
                    sendArgs = initSendArgs();
                }
                lock (sendArgs) //要锁定,不锁定让别的线程抢走了就不妙了.
                {
                    sendArgs.IsUsing = true;
                    sendArgs.SetBuffer(buff, 0, buff.Length);
                }
                clientSocket.SendAsync(sendArgs);
            }
            else
            {
                throw new SocketException((Int32)SocketError.NotConnected);
            }
        }

        /// <summary>
        /// 使用新进程通知事件回调
        /// </summary>
        /// <param name="buff"></param>
        private void DoReceiveEvent(byte[] buff)
        {
            if (ServerDataHandler == null) return;
            //ServerDataHandler(buff); //可直接调用.
            //但我更喜欢用新的线程,这样不拖延接收新数据.
            Thread thread = new Thread(new ParameterizedThreadStart((obj) =>
            {
                ServerDataHandler((byte[])obj);
            }));
            thread.IsBackground = true;
            thread.Start(buff);
        }

        #endregion

        #region IDisposable Members

        // Disposes the instance of SocketClient.
        public void Dispose()
        {
            autoConnectEvent.Close();
            if (clientSocket.Connected)
            {
                clientSocket.Close();
            }
        }

        #endregion
    }
}

 

 

 好了, 怎么使用, 那是再简单不过的事了, 当然连接同一个服务器的同一端口, 这个类你只需要初始化一次就可以了, 不要创建多个, 这样太浪费资源. 上面是定义了通讯的基础类, 那么接下来就是把相关的方法再包装一下, 做成供前台方便调用的含有静态方法的类就OK了. 

using Newtonsoft.Json;
using Plates.Common;
using Plates.Common.Base;
using Plates.Common.Beans;
using RuncomLib.File;
using RuncomLib.Log;
using RuncomLib.Text;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Sockets;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
using System.Timers;

namespace Plates.Client.Net
{
    class Request
    {
        //定义,最好定义成静态的, 因为我们只需要一个就好
        static SocketManager smanager = null;
        static UserInfoModel userInfo = null;

        //定义事件与委托
        public delegate void ReceiveData(object message);
        public delegate void ServerClosed();
        public static event ReceiveData OnReceiveData;
        public static event ServerClosed OnServerClosed;

        /// <summary>
        /// 心跳定时器
        /// </summary>
        static System.Timers.Timer heartTimer = null;
        /// <summary>
        /// 心跳包
        /// </summary>
        static ApiResponse heartRes = null;

        /// <summary>
        /// 判断是否已连接
        /// </summary>
        public static bool Connected
        {
            get { return smanager != null && smanager.Connected; } 
        }

        /// <summary>
        /// 已登录的用户信息
        /// </summary>
        public static UserInfoModel UserInfo
        {
            get { return userInfo; }
        }


        #region 基本方法

        /// <summary>
        /// 连接到服务器
        /// </summary>
        /// <returns></returns>
        public static SocketError Connect()
        {
            if (Connected) return SocketError.Success;
            //我这里是读取配置, 
            string ip = Config.ReadConfigString("socket", "server", "");
            int port = Config.ReadConfigInt("socket", "port", 13909);
            if (string.IsNullOrWhiteSpace(ip) || port <= 1000) return SocketError.Fault;
 
            //创建连接对象, 连接到服务器
            smanager = new SocketManager(ip, port);
            SocketError error = smanager.Connect();
            if (error == SocketError.Success){
               //连接成功后,就注册事件. 最好在成功后再注册.
                smanager.ServerDataHandler += OnReceivedServerData;
                smanager.ServerStopEvent += OnServerStopEvent;
            }
            return error;
        }

        /// <summary>
        /// 断开连接
        /// </summary>
        public static void Disconnect()
        {
            try
            {
                smanager.Disconnect();
            }
            catch (Exception) { }
        }


        /// <summary>
        /// 发送请求
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public static bool Send(ApiResponse request)
        {
            return Send(JsonConvert.SerializeObject(request));
        }

        /// <summary>
        /// 发送消息
        /// </summary>
        /// <param name="message">消息实体</param>
        /// <returns>True.已发送; False.未发送</returns>
        public static bool Send(string message)
        {
            if (!Connected) return false;

            byte[] buff = Encoding.UTF8.GetBytes(message);
            //加密,根据自己的需要可以考虑把消息加密
            //buff = AESEncrypt.Encrypt(buff, m_aesKey);
            smanager.Send(buff);
            return true;
        }


        /// <summary>
        /// 发送字节流
        /// </summary>
        /// <param name="buff"></param>
        /// <returns></returns>
        static bool Send(byte[] buff)
        {
            if (!Connected) return false;
            smanager.Send(buff);
            return true;
        }



        /// <summary>
        /// 接收消息
        /// </summary>
        /// <param name="buff"></param>
        private static void OnReceivedServerData(byte[] buff)
        {
            //To do something
            //你要处理的代码,可以实现把buff转化成你具体的对象, 再传给前台
            if (OnReceiveData != null)
                OnReceiveData(buff);
        }



        /// <summary>
        /// 服务器已断开
        /// </summary>
        private static void OnServerStopEvent()
        {
            if (OnServerClosed != null)
                OnServerClosed();
        }

        #endregion

        #region 心跳包
        //心跳包也是很重要的,看自己的需要了, 我只定义出来, 你自己找个地方去调用吧
        /// <summary>
        /// 开启心跳
        /// </summary>
        private static void StartHeartbeat()
        {
            if (heartTimer == null)
            {
                heartTimer = new System.Timers.Timer();
                heartTimer.Elapsed += TimeElapsed;
            }
            heartTimer.AutoReset = true;     //循环执行
            heartTimer.Interval = 30 * 1000; //每30秒执行一次
            heartTimer.Enabled = true;
            heartTimer.Start();
            
            //初始化心跳包
            heartRes = new ApiResponse((int)ApiCode.心跳);
            heartRes.data = new Dictionary<string, object>();
            heartRes.data.Add("beat", Function.Base64Encode(userInfo.nickname + userInfo.userid + DateTime.Now.ToString("HH:mm:ss")));
        }

        /// <summary>
        /// 定时执行
        /// </summary>
        /// <param name="source"></param>
        /// <param name="e"></param>
        static void TimeElapsed(object source, ElapsedEventArgs e)
        {
            Request.Send(heartRes);
        }

        #endregion
    }
}

 

好了, 就这些, 所有的请求都是异步进行的, 如果你想同步进行, 我也有实现过, 等有空了再贴上来.

如果你还没有弄懂服务器端, 请进入:

服务器实现参考：《C#如何利用SocketAsyncEventArgs实现高效能TCPSocket通信 (服务器实现)》

 

本贴为原创, 转载请注明出处: http://freshflower.iteye.com/blog/2285286

 

评论

4 楼 QW去 2017-12-20  

东西确实 不错，但是对 Socket 不太熟悉，这代码 不完整，跑步起来；
有点鸡肋，还是感谢楼主的分享，最好有Demo下载就好了

3 楼 randyzhuwei 2017-11-21  

你好，请问处理了粘包，断包的情况吗

2 楼 gloot 2017-05-18  

问个问题:

客户端程序；
采用 异步的 BeginSend/EndSend, BeginReceive/EndRecie 进行发送跟接收数据；
当一直不断的对服务端进行发送数据时，服务器端能接收正常；但过了一段时间后，客户端最后一次BeginSend数据（本次有执行到EndSend，提醒发送成功），服务端没有接收到数据；
这次BeginSend的数据，只能等到下一次的 BeginSend才能成功；
就是本次BeginSend会触发上次未发送成功的数据，本次的data，程序也会进行EndSend，但实际，没有发送成功!
----------------------------------------------------------
改造
1. SocketAsyncEventArgs 也一样；
2. 将Send添加成自定义的 队列中， 再开一个线程，获取数据，再发送； 情况好一次，但久了也还是会出现类拟的情况 (有对发送的频率进行控制)；

private void realSends()
        {
            int sendPad = 0;
            MessageType mt;
            Thread thread = new Thread(delegate()
            {
                while (true)
                {
                    mt = MessageQueue.getMessage();

                    if (mt != null)
                    {
                        sendPad++;
                        Send(mt);
                    }

                    if (sendPad >= 5) //控制发送频率
                    {
                        sendPad = 0;
                        Thread.Sleep(2000);
                    }
                    else
                    {
                        Thread.Sleep(200);
                    }

                }
            });
            thread.IsBackground = true;
            thread.Start();
        }

-------------------------------------------------
对于这种情况，该如何处理？
（BeginSend或SocketAsyncEventArgs，都是用的是完成端口的模型，据说是一种非复杂的东西，Socket发送的数据，会先到操作系统底层的某种队列，再依据底层操作完成，再通知应用程序接收处理EndSend；如果发送速度太快，似乎会出现异常情况，数据有到EndSend得到完成通知，但是实际没有发送到服务端；这部分数据要等到下一次的BeginSend才能发送，很怪）
（现在就是找不到方法， 能把这部分发送到系统底层队列的数据，刷出去）

1 楼 M_Want_To_Fly 2016-07-05  

if (!e.ConnectSocket.ReceiveAsync(receiveEventArgs)) 
                ProcessReceive(receiveEventArgs); 
e.ConnectSocket 没有这个属性呀？