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

转载自  http://freshflower.iteye.com/blog/2285286

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

    服务器实现参考：《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
     {

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

         ///
         /// 设置/获取使用状态
         ///
         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
         //
         // true if the buffer was successfully set, else false
         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 listArgs = new List();
         private MySocketEventArgs receiveEventArgs = new MySocketEventArgs();
         int tagCount = 0;

         ///
         /// 当前连接状态
         ///
         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>();
         }

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

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

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

         ///
         /// 初始化发送参数MySocketEventArgs
         ///
         ///
         MySocketEventArgs initSendArgs()
         {
             MySocketEventArgs sendArg = new MySocketEventArgs();
             sendArg.Completed += new EventHandler(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
         //
         //
         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);
             }
         }

         ///
         /// 使用新进程通知事件回调
         ///
         ///
         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;

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

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

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


         #region 基本方法

         ///
         /// 连接到服务器
         ///
         ///
         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;
         }

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


         ///
         /// 发送请求
         ///
         ///
         ///
         public static bool Send(ApiResponse request)
         {
             return Send(JsonConvert.SerializeObject(request));
         }

         ///
         /// 发送消息
         ///
         /// 消息实体
         /// True.已发送; False.未发送
         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;
         }


         ///
         /// 发送字节流
         ///
         ///
         ///
         static bool Send(byte[] buff)
         {
             if (!Connected) return false;
             smanager.Send(buff);
             return true;
         }



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



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

         #endregion

         #region 心跳包
         //心跳包也是很重要的,看自己的需要了, 我只定义出来, 你自己找个地方去调用吧
         ///
         /// 开启心跳
         ///
         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")));
         }

         ///
         /// 定时执行
         ///
         ///
         ///
         static void TimeElapsed(object source, ElapsedEventArgs e)
         {
             Request.Send(heartRes);
         }

         #endregion
     }
 }

 

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

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

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