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

http://freshflower.iteye.com/blog/2285286

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

    服务器实现参考：《C#如何利用SocketAsyncEventArgs实现高效能TCPSocket通信 (服务器实现)》
     与服务器不同的是客户端的实现需要多个SocketAsyncEventArgs共同协作，至少需要两个：接收的只需要一个，发送的需要一个，也可以多个,这在多线程中尤为重要，接下来说明。
 
     客户端一般需要数据的时候，就要发起请求，在多线程环境中，请求服务器一般不希望列队等候，这样会大大拖慢程序的处理。如果发送数据包的SocketAsyncEventArgs只有一个，且当他正在工作的时候, 下一个请求也来访问,这时会抛出异常, 提示当前的套接字正在工作, 所以这不是我们愿意看到, 唯有增加SocketAsyncEventArgs对象来解决。
那么接下来的问题就是我怎么知道当前的SocketAsyncEventArgs对象是否正在工作呢. 很简单，我们新建一个MySocketEventArgs类来继承它。

C#代码  


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类，这个类已经在服务端贴出来了，与服务端是一样的， 再贴一次：

C#代码  


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);  
        }  
    }  
}  

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

C#代码  


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了. 

C#代码  


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  
    }  
}  

 
好了, 就这些, 所有的请求都是异步进行的, 如果你想同步进行, 我也有实现过, 等有空了再贴上来.
如果你还没有弄懂服务器端, 请进入: