点击刷新
目录
第1章同步TCP通讯
本文将说明如何使用MFC的CSocket和CAsyncSocket实现同步、异步TCP/UDP通讯。文中的代码已被上传至git服务器：
https://github.com/hanford77/Exercise
https://git.oschina.net/hanford/Exercise
在目录 Socket 里。
1.1 同步通讯与异步通讯
同步通讯与异步通讯就好比SendMessage与PostMessage。
SendMessage直接把消息提交给窗口过程进行处理。它返回时，消息已经被处理完毕。
PostMessage只是把消息放入消息队列，在系统空闲的时候才会调用窗口过程处理消息。
同步通讯每调用一次读写函数，实际的读写工作都将被完成。因此，它的特点就是效率较低，但是代码逻辑结构较为简单。
异步通讯每调用一次读写函数，实际的读写工作可能并没有完成。因此，它的特点就是效率较高，但是代码逻辑结构较为复杂。
1.2 同步通讯类
同步通讯类CSocketSync派生自CSocket，用于TCP/UDP的同步通讯。代码如下：
|
class CSocketSync : public CSocket { protected: enum { UDP_MAX_PKG = 65507 }; //UDP 数据包最大字节数 ISocketEventHandler*m_pEventHandler; //套接字事件处理器 public: CSocketSync(ISocketEventHandler*pEvent = NULL) { m_pEventHandler = pEvent; } void SetEventHandler(ISocketEventHandler*pEvent) { m_pEventHandler = pEvent; } public: //用于发送 UDP 数据 int SendTo(const void* lpBuf, int nBufLen,UINT nHostPort , LPCTSTR lpszHostAddress = NULL, int nFlags = 0) { SOCKADDR_IN sockAddr; if(CSocketAsync::IpAddress(lpszHostAddress,nHostPort,sockAddr)) { return SendTo(lpBuf,nBufLen,(SOCKADDR*)&sockAddr ,sizeof(sockAddr),nFlags); } return 0; } //用于发送 UDP 数据 int SendTo(const void*pData,int nLen,const SOCKADDR*lpSockAddr ,int nSockAddrLen,int nFlags = 0) { if(pData && lpSockAddr && nSockAddrLen > 0) { if(nLen < 0) { nLen = strlen((const char*)pData); } if(nLen > 0) { int n = 0; //单次发送的字节数 int nSum = 0; //发送的累计字节数 for(;;) { n = nLen - nSum; //待发送的字节数 if(n > UDP_MAX_PKG) {//待发送的字节数不能太大 n = UDP_MAX_PKG; } n = CSocket::SendTo(pData,n,lpSockAddr ,nSockAddrLen,nFlags); if(n > 0) { nSum += n; //累计 if(nSum >= nLen) {//发送完毕 return nLen; } } else if(n == SOCKET_ERROR) { return nSum; } } } } return 0; } protected: virtual void OnReceive(int nErrorCode) {//接收到数据时，会触发该事件 if(m_pEventHandler) { m_pEventHandler->OnReceive(this,nErrorCode); } } virtual void OnClose(int nErrorCode) {//连接断了，会触发该事件 if(m_pEventHandler) { m_pEventHandler->OnClose(this,nErrorCode); } } }; |
上述代码中，SendTo函数用于UDP通讯，暂时不用管它。重点是事件处理，如：CSocket接收到OnReceive事件时，会调用virtual void OnReceive(int nErrorCode)函数。后者会调用 m_pEventHandler->OnReceive(this,nErrorCode);让m_pEventHandler来处理这个事件。
m_pEventHandler是一个事件处理器（ISocketEventHandler*），接口ISocketEventHandler的定义如下：
|
class ISocketEventHandler { public: virtual void OnAccept (CAsyncSocket*pSender,int nErrorCode){} virtual void OnClose (CAsyncSocket*pSender,int nErrorCode){} virtual void OnConnect(CAsyncSocket*pSender,int nErrorCode){} virtual void OnReceive(CAsyncSocket*pSender,int nErrorCode){} virtual void OnSend (CAsyncSocket*pSender,int nErrorCode){} }; |
1.3 同步TCP通讯客户端
1.3.1 界面
TCP客户端界面如下：
图1.1
1.3.2 界面类声明
上面的界面，对应于类CDlgTcpClientSync，其声明代码如下：
|
class CDlgTcpClientSync : public CDialog , public ISocketEventHandler { ... ... ... protected://ISocketEventHandler virtual void OnReceive(CAsyncSocket*pSender,int nErrorCode); virtual void OnClose (CAsyncSocket*pSender,int nErrorCode); protected: CSocketSync m_Socket; std::string m_sRecv; }; |
上述代码的重点：
1）定义了CSocketSync m_Socket，用于套接字通讯；
2）成员变量std::string m_sRecv用来存储接收到的数据；
3）CDlgTcpClientSync继承了ISocketEventHandler，并重写了OnReceive、OnClose函数。m_Socket的套接字事件，将由OnReceive、OnClose函数来处理。
1.3.3 界面类构造函数
界面类构造函数如下
|
CDlgTcpClientSync::CDlgTcpClientSync(CWnd* pParent /*=NULL*/) : CDialog(CDlgTcpClientSync::IDD, pParent) { m_Socket.SetEventHandler(this); } |
设置m_Socket的事件处理器为this。其含义为：m_Socket的OnReceive被调用时，就会调用函数CDlgTcpClientSync::OnReceive。
1.3.4 连接服务器
单击图1.1的"连接"按钮，将连接服务器。示例代码如下：
|
CString sIP = _T("127.0.0.1"); //服务器 IP int nPort = 2001; //服务器端口 if(m_Socket.Socket() //创建套接字成功 && m_Socket.Connect(sIP,nPort) //连接服务器成功 ) {//连接成功 ... ... ... } else {//连接失败 m_Socket.Close(); //关闭套接字 ... ... ... } |
重点在于：
1）调用m_Socket.Socket创建套接字；
2）调用m_Socket.Connect连接服务器。
1.3.5 写数据
单击图1.1的"发送"按钮，将发送数据给服务器。示例代码如下：
|
std::string s(1024,,'1'); m_Socket.Send(s.c_str(),s.length()); |
重点就是调用CSocket::Send函数发送数据。上面的代码将发送1024字节的'1'给服务器。因为是同步的，所以数据未发送完毕之前，这个函数是不会返回的。
1.3.6 读数据
服务器发送数据过来时，CSocket::OnReceive会被调用。m_Socket所属的类CSocketSync重写了OnReceive函数，因此CSocketSync::OnReceive会被调用。代码m_pEventHandler->OnReceive(this,nErrorCode);会被调用。这里的m_pEventHandler是一个CDlgTcpClientSync*，后者重写了ISocketEventHandler::OnReceive函数，因此：程序一旦接收到服务器发来的数据，函数CDlgTcpClientSync::OnReceive将被调用。其代码如下：
|
char buf[1024]; int nRead = 0;
while((nRead = m_Socket.CAsyncSocket::Receive(buf,sizeof(buf))) > 0) {//异步读取。读取到的数据加入变量m_sRecv m_sRecv += std::string((const char*)buf,nRead); } |
重点在于：调用CAsyncSocket::Receive函数读取发送过来的数据。注意：CAsyncSocket::Receive是异步读取的，它仅仅从套接字输入缓冲区内读取数据。如果输入缓冲区为空，它就直接返回-1。
如果把m_Socket.CAsyncSocket::Receive中的".CAsyncSocket"删除，那么调用的就是CSocket::Receive函数。CSocket::Receive是同步读取的，亦即在未读取到预定字节数（上面代码中的sizeof(buf)）之前，它是不会返回的。结果就是整个程序会阻塞在这一行，将处于假死状态。
1.3.7 断开连接
单击图1.1的"断开"按钮，将执行如下代码：
|
m_Socket.ShutDown(CAsyncSocket::both); //禁止TCP连接收、发数据 m_Socket.Close(); //关闭套接字 |
如果是服务器断开了此TCP连接，则CDlgTcpClientSync::OnClose会被调用。代码如下：
|
void CDlgTcpClientSync::OnClose(CAsyncSocket*pSender,int nErrorCode) { m_Socket.ShutDown(CAsyncSocket::both); m_Socket.Close(); } |
1.4 同步TCP通讯服务端
1.4.1 界面
TCP服务端界面如下：
图1.2
1.4.2 界面类声明
上面的界面，对应于类CDlgTcpServerSync，其声明代码如下：
|
class CDlgTcpServerSync : public CDialog , public ISocketEventHandler { ... ... ... protected://ISocketEventHandler virtual void OnAccept (CAsyncSocket*pSender,int nErrorCode); virtual void OnReceive(CAsyncSocket*pSender,int nErrorCode); virtual void OnClose (CAsyncSocket*pSender,int nErrorCode); protected: typedef std::map<CSocketSync*,CString> MapClient; CSocketTcpListen m_SocketListen; //一个监听套接字 MapClient m_mapClient; //一个客户端对应一个通讯套接字 CString m_sRecv; //接收到的数据 }; |
上述代码的重点：
1）定义了 CSocketTcpListen m_SocketListen，该套接字用于监听客户端发送过来的连接请求；
2）定义了std::map<CSocketSync*,CString> m_mapClient，用来存储多个通讯套接字，每个通讯套接字对应于一个客户端；
3）成员变量m_sRecv用来存储接收到的数据；
4）CDlgTcpServerSync继承了ISocketEventHandler，并重写了Socket事件处理函数。
1.4.3 CSocketTcpListen
CSocketTcpListen继承自CAsyncSocket，用来监听客户端发送过来的连接请求。其代码如下：
|
class CSocketTcpListen : public CAsyncSocket { public: CSocketTcpListen(ISocketEventHandler*pEvent = NULL) { m_pEventHandler = pEvent; } void SetEventHandler(ISocketEventHandler*pEvent) { m_pEventHandler = pEvent; } protected: virtual void OnAccept(int nErrorCode) {//客户端发送连接请求时，会触发该事件 if(m_pEventHandler) { m_pEventHandler->OnAccept(this,nErrorCode); } } public: ISocketEventHandler*m_pEventHandler; //套接字事件处理器 }; |
1.4.4 界面类构造函数
界面类构造函数如下
|
CDlgTcpServerSync::CDlgTcpServerSync(CWnd* pParent /*=NULL*/) : CDialog(CDlgTcpServerSync::IDD, pParent) { m_SocketListen.SetEventHandler(this); } |
设置m_SocketListen的事件处理器为this。其含义为：m_SocketListen的OnAccept被调用时，就会调用函数CDlgTcpServerSync::OnAccept。
1.4.5 开始监听
单击图1.2的"开始监听"按钮，示例代码如下：
|
int nPort = 2001; //监听该端口 CSocketTcpListen& s = m_SocketListen; if(s.Create(nPort) //创建套接字，绑定端口 && s.Listen()) //开始监听 {//监听成功 EnableControls(); } else {//监听失败 s.Close(); } |
1.4.6 客户端上线
服务端接收到客户端的连接请求时，函数CSocketTcpListen::OnAccept和CDlgTcpServerSync::OnAccept会被依次调用。后者的代码如下：
|
void CDlgTcpServerSync::OnAccept(CAsyncSocket*pSender,int nErrorCode) { if(0 == nErrorCode) { CSocketSync*pClient = new CSocketSync(this); if(m_SocketListen.Accept(*pClient)) {//接受连接请求成功 m_mapClient[pClient] = GetPeerName(pClient); } else {//接受连接请求失败 delete pClient; } } } |
上面代码的重点在于：
1）调用CAsyncSocket::Accept函数，接受客户端的连接请求；
2）将客户端套接字加入到m_mapClient里。m_mapClient的Key是CSocketSync*pClient可用于与客户端通讯；m_mapClient的Value由函数GetPeerName获得，是客户端的IP地址和端口号，如："127.0.0.1:5000"。函数GetPeerName的代码如下：
|
inline CString GetPeerName(CAsyncSocket*p) { CString s; if(p) { CString sIP; UINT nPort; if(p->GetPeerName(sIP,nPort)) { s.Format(_T("%s:%u"),sIP,nPort); } } return s; } |
3）new CSocketSync(this) 将 Socket 事件处理器设置为 this，也就是CDlgTcpServerSync。因此，当CSocketSync::OnReceive、CSocketSync::OnClose被调用时，CDlgTcpServerSync::OnReceive、CDlgTcpServerSync::OnClose也会被调用。
1.4.7 写数据
单击图1.2的"发送"按钮，将发送数据给客户端。下面的代码将1024个'1'发送给所有的客户端：
|
std::string s(1024,'1'); for(MapClient::iterator it = m_mapClient.begin(); it != m_mapClient.end();++it) { it->first->Send(s.c_str(),s.length()); } |
重点就是调用CSocket::Send函数发送数据。因为是同步的，所以数据未发送完毕之前，这个函数是不会返回的。
1.4.8 读数据
某个客户端发送数据过来时，CDlgTcpServerSync::OnReceive将被调用。代码如下：
|
void CDlgTcpServerSync::OnReceive(CAsyncSocket*pSender ,int nErrorCode) { if(pSender) { CSocketSync*pClient = (CSocketSync*)pSender; char buf[1024]; int nRead = 0; std::string s;
while((nRead = pClient->CAsyncSocket::Receive(buf,sizeof(buf))) > 0) {//异步读取 s += std::string((const char*)buf,nRead); } } } |
要点如下：
1）多个客户端是通过OnReceive的第一个参数pSender进行区分的；
2）读取数据时使用的是CAsyncSocket::Receive函数，这个函数是异步读取数据的。
1.4.9 客户端下线
某个客户端下线时，CDlgTcpServerSync::OnClose将被调用。代码如下：
|
void CDlgTcpServerSync::OnClose(CAsyncSocket*pSender,int nErrorCode) { if(pSender) { CSocketSync*pClient = (CSocketSync*)pSender; MapClient::iterator it = m_mapClient.find(pClient); if(it != m_mapClient.end()) {//从m_mapClient里删除该客户端 m_mapClient.erase(pClient); } pClient->ShutDown(2); pClient->Close(); delete pClient; } } |
要点如下：
1）从m_mapClient里删除该客户端；
2）销毁该客户端对应的 CSocketSync 对象。
1.4.10 停止监听
单击图1.2的"停止监听"按钮，将执行如下代码：
|
CSocketSync*pClient = NULL; for(MapClient::iterator it = m_mapClient.begin(); it != m_mapClient.end();++it) {//断开所有与客户端的 TCP 连接 if(pClient = it->first) { pClient->ShutDown(2); pClient->Close(); delete pClient; } } m_mapClient.clear(); //停止监听 if(m_SocketListen.m_hSocket != INVALID_SOCKET) { m_SocketListen.ShutDown(2); m_SocketListen.Close(); } |
要点如下：
1）遍历m_mapClient，断开所有与客户端的 TCP 连接；
2）关闭监听套接字 m_SocketListen。
第2章异步TCP通讯
同步通讯较为简单，但是执行效率较低。如：多个TCP客户端都是通过GPRS上网的，网速低得只有十几KB/s。TCP服务器给这些客户端发送数据时，将会等待很长时间，整个程序也可能会处于假死状态。
为了提高通讯效率，可以使用异步通讯。
2.1 异步通讯类
异步通讯类CSocketAsync派生自CAsyncSocket，用于TCP/UDP的异步通讯。代码如下：
|
class CSocketAsync : public CAsyncSocket { protected: enum { UDP_MAX_PKG = 65507 }; //UDP 数据包最大字节数 class SendToData { public: std::string sAddr; std::string sData; }; ISocketEventHandler*m_pEventHandler; //套接字事件处理器 std::string m_sSend; //Send 函数缓存的发送数据 std::list<SendToData> m_lstSendTo; //SendTo 函数缓存的发送数据 public: CSocketAsync(ISocketEventHandler*pEvent = NULL) { m_pEventHandler = pEvent; } void SetEventHandler(ISocketEventHandler*pEvent) { m_pEventHandler = pEvent; } /***********************************************************\ 转换 IP 地址格式 szIP [in] 字符串格式的 IP 地址。如：192.168.1.200 nPort [in] 端口，范围 [0,65535]。如：2001 addr [out] 地址 \***********************************************************/ static bool IpAddress(LPCTSTR szIP,UINT nPort ,SOCKADDR_IN&addr) { USES_CONVERSION; memset(&addr,0,sizeof(addr)); char*szIpA = T2A((LPTSTR)szIP); if(szIpA) { addr.sin_addr.s_addr = inet_addr(szIpA); if(addr.sin_addr.s_addr == INADDR_NONE) { LPHOSTENT lphost = gethostbyname(szIpA); if(lphost) { addr.sin_addr.s_addr = ((LPIN_ADDR)lphost->h_addr)->s_addr; } else { return false; } } } else { addr.sin_addr.s_addr = htonl(INADDR_BROADCAST); } addr.sin_family = AF_INET; addr.sin_port = htons((u_short)nPort); return true; } public: //用于发送 TCP 数据 virtual int Send(const void*pData,int nLen,int nFlags = 0) { if(pData) { if(nLen < 0) { nLen = strlen((const char*)pData); } if(nLen > 0) { if(m_sSend.empty()) {//缓存数据 m_sSend 为空，发送数据 int n = 0; //单次发送的字节数 int nSum = 0; //发送的累计字节数 for(;;) { n = nLen - nSum; n = send(m_hSocket,(const char*)pData + nSum,n,0); if(n > 0) { nSum += n; if(nSum >= nLen) { return nLen; } } else if(n == SOCKET_ERROR) { if(WSAGetLastError() == WSAEWOULDBLOCK) {//将数据加入缓存 m_sSend += std::string((const char*)pData + nSum,nLen - nSum); return nLen; } else { return nSum; } } } } else {//缓存数据 m_sSend 不为空，直接将数据加入缓存 m_sSend += std::string((const char*)pData,nLen); return nLen; } } } return 0; } //用于发送 UDP 数据 int SendTo(const void* lpBuf, int nBufLen,UINT nHostPort , LPCTSTR lpszHostAddress = NULL, int nFlags = 0) { SOCKADDR_IN sockAddr; if(IpAddress(lpszHostAddress,nHostPort,sockAddr)) { return SendTo(lpBuf,nBufLen,(SOCKADDR*)&sockAddr ,sizeof(sockAddr), nFlags); } return 0; } //用于发送 UDP 数据 int SendTo(const void*pData,int nLen,const SOCKADDR*lpSockAddr ,int nSockAddrLen,int nFlags = 0) { if(pData && lpSockAddr && nSockAddrLen > 0) { if(nLen < 0) { nLen = strlen((const char*)pData); } if(nLen > 0) { SendToData data; if(m_lstSendTo.empty()) {//无缓存数据，发送 int n = 0; //单次发送的字节数 int nSum = 0; //发送的累计字节数 for(;;) { n = nLen - nSum; //待发送的字节数 if(n > UDP_MAX_PKG) {//待发送的字节数不能太大 n = UDP_MAX_PKG; } n = CAsyncSocket::SendTo( (const char*)pData + nSum,n,lpSockAddr,nSockAddrLen,nFlags); if(n > 0) { nSum += n; //累计 if(nSum >= nLen) {//发送完毕 return nLen; } } else if(n == SOCKET_ERROR) { switch(GetLastError()) { //case WSAEMSGSIZE: //超过 65507 字节 case WSAEWOULDBLOCK://操作被挂起 data.sAddr.assign((const char*)lpSockAddr,nSockAddrLen); //地址 data.sData.assign((const char*)pData + nSum,nLen - nSum); //数据 m_lstSendTo.push_back(data); //缓存地址和数据 return nLen; default: return nSum; } } } } else {//有缓存数据，直接缓存 data.sAddr.assign((const char*)lpSockAddr,nSockAddrLen); //地址 data.sData.assign((const char*)pData,nLen); //数据 m_lstSendTo.push_back(data); //缓存地址和数据 return nLen; } } } return 0; } protected: virtual void OnConnect(int nErrorCode) {//连接上服务器了 if(m_pEventHandler) { m_pEventHandler->OnConnect(this,nErrorCode); } } virtual void OnReceive(int nErrorCode) {//接收到数据 if(m_pEventHandler) { m_pEventHandler->OnReceive(this,nErrorCode); } } virtual void OnSend(int nErrorCode) {//输出缓冲区空了，可以发送数据了 if(m_sSend.length() > 0) {//发送缓存数据 m_sSend int n = 0; //单次发送的字节数 int nSum = 0; //发送的累计字节数 int nTotal = m_sSend.length(); //待发送的总字节数 for(;;) { n = nTotal - nSum; //待发送的字节数 n = send(m_hSocket,m_sSend.c_str() + nSum,n,0); if(n > 0) { nSum += n; if(nSum >= nTotal) { break; } } else if(n == SOCKET_ERROR) { //WSAGetLastError() == WSAEWOULDBLOCK break; } } if(nSum > 0) { m_sSend = m_sSend.substr(nSum); } } if(!m_lstSendTo.empty()) {//发送缓存数据 m_lstSendTo for(std::list<SendToData>::iterator it = m_lstSendTo.begin(); it != m_lstSendTo.end();) { if(DoSendToData(*it)) { it = m_lstSendTo.erase(it); } else { break; } } } } virtual void OnClose(int nErrorCode) {//连接断了 if(m_pEventHandler) { m_pEventHandler->OnClose(this,nErrorCode); } } protected: //发送一包数据 bool DoSendToData(SendToData&data) { int nTotal = data.sData.length(); //总字节数 int nSum = 0; //发送字节数的累计值 int n = 0; //单次发送的字节数 for(;;) { n = nTotal - nSum; if(n <= 0) { return true; //这一包数据发送完毕了 } if(n > UDP_MAX_PKG) {//每次发送的字节数不能过大 n = UDP_MAX_PKG; } n = sendto(m_hSocket,data.sData.c_str() + nSum,n,0 ,(const struct sockaddr*)data.sAddr.c_str() ,data.sAddr.length()); if(n > 0) { nSum += n; } else if(n == SOCKET_ERROR) { data.sData = data.sData.substr(nSum); //WSAGetLastError() == WSAEWOULDBLOCK break; } } return false; //这一包数据没有发送完毕 } }; |
上述代码量是同步通讯类CSocketSync的近四倍。具体含义下文进行说明。
2.2 异步TCP通讯客户端
同步TCP通讯客户端使用的是CSocketSync m_Socket；异步TCP通讯客户端使用的是CSocketAsync m_Socket。两者的用法基本相同，不同之处如下：
2.2.1 连接服务器
单击图1.1的"连接"按钮，将连接服务器。示例代码如下：
|
if(m_Socket.Socket()) {//创建套接字成功 CString sIP = _T("127.0.0.1"); //服务器 IP int nPort = 2001; //服务器端口 if(m_Socket.Connect(sIP,nPort)) {//连接服务器成功 OnConnect(&m_Socket,0); } else if(GetLastError() == WSAEWOULDBLOCK) {//连接操作被挂起，连接操作完成时会调用 OnConnect 函数 } else { m_Socket.Close(); SetDlgItemText(IDC_TXT_LOCAL,_T("连接失败")); } } |
|
void CDlgTcpClientAsync::OnConnect(CAsyncSocket*pSender ,int nErrorCode) {//连接完成时的回调函数 if(0 == nErrorCode) {//连接成功 } else {//连接失败 } } |
重点在于：
1）m_Socket.Connect(sIP,nPort)返回TRUE，表示连接成功；
2）m_Socket.Connect(sIP,nPort)返回FALSE，GetLastError() == WSAEWOULDBLOCK表示连接操作被挂起。当连接操作完成时，会调用CDlgTcpClientAsync::OnConnect函数，该函数的第二个参数nErrorCode用来说明连接是否成功。
m_Socket.Connect返回时，连接操作可能并没有完成，这就是异步操作。
2.2.2 写数据
异步写数据的代码与同步写数据的代码完全相同，如下所示：
|
std::string s(1024,,'1'); m_Socket.Send(s.c_str(),s.length()); |
不过上面的m_Socket.Send调用的是CSocketAsync::Send函数。这个函数有些复杂，其精简代码如下：
|
virtual int Send(const void*pData,int nLen,int nFlags = 0) { int n = 0; //单次发送的字节数 int nSum = 0; //发送的累计字节数 for(;;) { n = nLen - nSum; n = send(m_hSocket,(const char*)pData + nSum,n,0); if(n > 0) { nSum += n; if(nSum >= nLen) { return nLen; } } else if(n == SOCKET_ERROR) { if(WSAGetLastError() == WSAEWOULDBLOCK) {//将数据加入缓存 m_sSend += std::string((const char*)pData + nSum ,nLen - nSum); return nLen; } else { return nSum; } } } } |
重点如下：
1）send函数的返回值大于零，表明发送成功了一些数据；
2）send函数的返回值等于SOCKET_ERROR且WSAGetLastError() == WSAEWOULDBLOCK，说明该写操作被挂起了。send函数发送数据的实质是给套接字输出缓冲区内填入数据，当输出缓冲区满了，无法填入数据时就会这种情况，此即为写操作被挂起。那么，何时才能继续发送数据呢？当输出缓冲区为空时，系统会给套接字发送OnSend事件，在这里继续发送数据。代码如下：
|
virtual void OnSend(int nErrorCode) {//输出缓冲区空了，可以发送数据了 if(m_sSend.length() > 0) {//发送缓存数据 m_sSend int n = 0; //单次发送的字节数 int nSum = 0; //发送的累计字节数 int nTotal = m_sSend.length(); //待发送的总字节数 for(;;) { n = nTotal - nSum; //待发送的字节数 n = send(m_hSocket,m_sSend.c_str() + nSum,n,0); if(n > 0) { nSum += n; if(nSum >= nTotal) { break; } } else if(n == SOCKET_ERROR) {//输出缓冲区又满了，停止发送 //WSAGetLastError() == WSAEWOULDBLOCK break; } } if(nSum > 0) {//舍弃掉已经发送的缓存数据 m_sSend = m_sSend.substr(nSum); } } } |
上面的代码调用send函数把缓存数据std::string m_sSend发送出去。发送时输出缓冲区再次满的时候就停止发送。等输出缓冲区再次为空时，会再次调用OnSend函数，继续发送缓存数据……
可见：异步写数据需要缓存发送失败的数据，并且在OnSend函数里发送这些缓存数据。
2.3 异步TCP通讯服务端
"异步TCP通讯服务端"与"同步TCP通讯服务端"的不同之处在于m_mapClient的定义：
|
std::map<CSocketAsync*,CString> m_mapClient; //异步 std::map<CSocketSync*,CString> m_mapClient; //同步 |
与客户端的通讯，异步使用的是CSocketAsync，同步使用的是CSocketSync。其余代码基本相同。
第3章同步UDP通讯
3.1 界面
UDP通讯界面如下
图3.1
3.2 界面类声明
上面的界面，对应于类CDlgTcpClientSync，其声明代码如下：
|
class CDlgUdpSync : public CDialog , public ISocketEventHandler { ... ... ... protected://ISocketEventHandler virtual void OnReceive(CAsyncSocket*pSender,int nErrorCode); protected: CSocketSync m_Socket; //套接字 CString m_sRecv; //接收到的数据 }; |
上述代码的重点：
1）定义了CSocketSync m_Socket，用于套接字通讯；
2）成员变量std::string m_sRecv用来存储接收到的数据；
3）CDlgUdpSync继承了ISocketEventHandler，并重写了OnReceive函数。m_Socket的套接字事件，将由OnReceive函数来处理。
3.3 界面类构造函数
界面类构造函数如下
|
CDlgUdpSync::CDlgUdpSync(CWnd* pParent /*=NULL*/) : CDialog(CDlgUdpSync::IDD, pParent) { m_Socket.SetEventHandler(this); } |
设置m_Socket的事件处理器为this。其含义为：m_Socket的OnReceive被调用时，就会调用函数CDlgUdpSync::OnReceive。
3.4 创建套接字
单击图3.1中的"打开"按钮，将创建UDP套接字。示例代码如下：
|
BOOL bOK = FALSE; if(((CButton*)GetDlgItem(IDC_CHK_BIND))->GetCheck()) {//绑定某个端口 int nPort = 2001; bOK = m_Socket.Create(nPort,SOCK_DGRAM); //创建套接字并绑定 } else {//不绑定 bOK = m_Socket.Socket(SOCK_DGRAM); //创建套接字，不绑定 } if(bOK) {//创建套接字成功 } else {//创建套接字失败 m_Socket.Close(); } |
调用m_Socket.Socket或m_Socket.Create创建套接字，两者的区别在于：前者不绑定端口，后者绑定端口。
3.5 写数据
单击图3.1中的"发送"按钮，即可给"127.0.0.1:2001"发送数据，其代码如下：
|
std::string s(1024,'1'); CString sIP = _T("127.0.0.1"); UINT nPort = 2001; m_Socket.SendTo(s.c_str(),s.length(),nPort,sIP); |
3.6 读数据
程序一旦接收到对方发来的数据，函数CDlgTcpClientSync::OnReceive将被调用。其代码如下：
|
void CDlgUdpSync::OnReceive(CAsyncSocket*pSender,int nErrorCode) { char buf[64 * 1024]; int nRead = 0; CString sIP; UINT nPort = 0; CString sFrom; std::map<CString,std::string> mapRecv; SOCKADDR_IN sockAddr; int nAddrLen = sizeof(sockAddr); memset(&sockAddr,0,sizeof(sockAddr));
while((nRead = recvfrom(m_Socket.m_hSocket,buf,sizeof(buf),0 ,(struct sockaddr*)&sockAddr,&nAddrLen)) > 0) { nPort = ntohs(sockAddr.sin_port); //对方的端口 sIP = inet_ntoa(sockAddr.sin_addr); //对方的IP sFrom.Format(_T("%s:%d"),sIP,nPort); mapRecv[sFrom] += std::string((const char*)buf,nRead); } if(!mapRecv.empty()) { for(std::map<CString,std::string>::iterator it = mapRecv.begin(); it != mapRecv.end();++it) { const std::string&s = it->second; m_sRecv += it->first + _T(" > ") + CString(s.c_str(),s.length()) + _T("\r\n"); } if(m_sRecv.GetLength() > MAXRECV) { m_sRecv = m_sRecv.Right(MAXRECV); } SetEditText(::GetDlgItem(m_hWnd,IDC_TXT_RECV),m_sRecv); } } |
重点在于：
1）调用recvfrom函数异步读取UDP数据包；
2）buf要足够大，否则无法读取一包UDP数据。一包UDP数据最多64KB，所以这里的buf也设置为64KB；
3）读取到一包UDP数据后，即可获得对方的IP地址、端口号；
4）UDP数据包可能是由不同的终端发送过来的，其IP地址、端口号不尽相同，因此使用std::map<CString,std::string> mapRecv;来存储读取到的UDP数据；
5）最后一段代码把mapRecv里的数据显示到图3.1中的"接收"文本框内。
3.7 关闭套接字
单击图3.1中的"关闭"按钮，将关闭套接字。代码如下：
|
m_Socket.Close(); |
第4章异步UDP通讯
"异步UDP通讯"与"同步UDP通讯"的写数据代码是相同的，如下：
|
std::string s(1024,'1'); CString sIP = _T("127.0.0.1"); UINT nPort = 2001; m_Socket.SendTo(s.c_str(),s.length(),nPort,sIP); |
不过上面的m_Socket.SendTo调用的是CSocketAsync::SendTo函数。这个函数与CSocketAsync::Send类似，也会将挂起的写数据缓存起来（std::list<SendToData> m_lstSendTo）。在输出缓冲区为空，系统调用CSocketAsync::OnSend函数时，将缓存数据发送出去。
© 著作权归作者所有
相关热门文章
发表评论
