WSAEventSelect模型编程详解

╰+哭是因爲堅強的太久メ 2022-03-27 12:38 209阅读 0赞

### 转自：[http://blog.csdn.net/wangjieest/article/details/7042108][http_blog.csdn.net_wangjieest_article_details_7042108] ###

### WSAEventSelect模型编程  ###

WSAEventSelect模型编程  
这个模型是一个简单的异步事件模型，使用起来比较方便，现在说一下其的具体的用法和需要注意的地方。  
一，模型的例程（服务端）：  
先举一个王艳平网络通信上的例子：

**\[cpp\]** [view plain][http_blog.csdn.net_wangjieest_article_details_7042108] [copy][http_blog.csdn.net_wangjieest_article_details_7042108] [print][http_blog.csdn.net_wangjieest_article_details_7042108] [?][http_blog.csdn.net_wangjieest_article_details_7042108]

1.  // 
2.  // WSAEventSelect文件 
3.  
4.  \#include "initsock.h" 
5.  \#include <stdio.h> 
6.  \#include <iostream.h> 
7.  \#include <windows.h> 
8.  
9.  // 初始化Winsock库 
10. CInitSock theSock;
11. 
12. int main() 
13. \{
14. // 事件句柄和套节字句柄表 
15. WSAEVENT eventArray\[WSA\_MAXIMUM\_WAIT\_EVENTS\];
16. SOCKET sockArray\[WSA\_MAXIMUM\_WAIT\_EVENTS\];
17. int nEventTotal = 0; 
18. 
19. USHORT nPort = 4567; // 此服务器监听的端口号 
20. 
21. // 创建监听套节字 
22. SOCKET sListen = ::socket(AF\_INET, SOCK\_STREAM, IPPROTO\_TCP);
23. sockaddr\_in sin;
24. sin.sin\_family = AF\_INET;
25. sin.sin\_port = htons(nPort);
26. sin.sin\_addr.S\_un.S\_addr = INADDR\_ANY;
27. if(::bind(sListen, (sockaddr\*)&sin, sizeof(sin)) == SOCKET\_ERROR) 
28. \{
29. printf(" Failed bind() \\n"); 
30. return -1; 
31. \}
32. ::listen(sListen, 5);
33. 
34. // 创建事件对象，并关联到新的套节字 
35. WSAEVENT event = ::WSACreateEvent();
36. ::WSAEventSelect(sListen, event, FD\_ACCEPT|FD\_CLOSE);
37. // 添加到表中 
38. eventArray\[nEventTotal\] = event;
39. sockArray\[nEventTotal\] = sListen;
40. nEventTotal++;
41. 
42. // 处理网络事件 
43. while(TRUE) 
44. \{
45. // 在所有事件对象上等待 
46. int nIndex = ::WSAWaitForMultipleEvents(nEventTotal, eventArray, FALSE, WSA\_INFINITE, FALSE); 
47. // 对每个事件调用WSAWaitForMultipleEvents函数，以便确定它的状态 
48. nIndex = nIndex - WSA\_WAIT\_EVENT\_0;
49. for(int i=nIndex; i<nEventTotal; i++) 
50. \{
51. nIndex = ::WSAWaitForMultipleEvents(1, &eventArray\[i\], TRUE, 1000, FALSE);
52. if(nIndex == WSA\_WAIT\_FAILED || nIndex == WSA\_WAIT\_TIMEOUT) 
53. \{
54. continue; 
55. \}
56. else 
57. \{
58. // 获取到来的通知消息，WSAEnumNetworkEvents函数会自动重置受信事件 
59. WSANETWORKEVENTS event;
60. ::WSAEnumNetworkEvents(sockArray\[i\], eventArray\[i\], &event);
61. if(event.lNetworkEvents & FD\_ACCEPT) // 处理FD\_ACCEPT通知消息 
62. \{
63. if(event.iErrorCode\[FD\_ACCEPT\_BIT\] == 0) 
64. \{
65. if(nEventTotal > WSA\_MAXIMUM\_WAIT\_EVENTS) 
66. \{
67. printf(" Too many connections! \\n"); 
68. continue; 
69. \}
70. SOCKET sNew = ::accept(sockArray\[i\], NULL, NULL);
71. WSAEVENT event = ::WSACreateEvent();
72. ::WSAEventSelect(sNew, event, FD\_READ|FD\_CLOSE|FD\_WRITE);
73. // 添加到表中 
74. eventArray\[nEventTotal\] = event;
75. sockArray\[nEventTotal\] = sNew;
76. nEventTotal++;
77. \}
78. \}
79. else if(event.lNetworkEvents & FD\_READ) // 处理FD\_READ通知消息 
80. \{
81. if(event.iErrorCode\[FD\_READ\_BIT\] == 0) 
82. \{
83. char szText\[256\]; 
84. int nRecv = ::recv(sockArray\[i\], szText, strlen(szText), 0); 
85. if(nRecv > 0) 
86. \{
87. szText\[nRecv\] = '\\0'; 
88. printf("接收到数据：%s \\n", szText); 
89. \}
90. \}
91. \}
92. else if(event.lNetworkEvents & FD\_CLOSE) // 处理FD\_CLOSE通知消息 
93. \{
94. if(event.iErrorCode\[FD\_CLOSE\_BIT\] == 0) 
95. \{
96. ::closesocket(sockArray\[i\]);
97. for(int j=i; j<nEventTotal-1; j++) 
98. \{
99. sockArray\[j\] = sockArray\[j+1\];
100. sockArray\[j\] = sockArray\[j+1\]; //这个是个BUG，应为： eventArray\[j\] = eventArray\[j+1\];还真没注意，直到同事提 起才注意到。 
101. \}
102. nEventTotal--;
103. \}
104. \}
105. else if(event.lNetworkEvents & FD\_WRITE) // 处理FD\_WRITE通知消息 
106. \{
107. \}
108. \}
109. \}
110. \}
111. return 0; 
112. \}

二、例程的分析  
1、事件的创建和绑定  
前面的一些设置我们略过，从WSAEVENT 开始说起，跟踪发现在winsock2.h中有如下定义：  
\#define WSAEVENT HANDLE  
这个事件说明是一个句柄，我们知道在事件中有两种状态，一种是手动处理事件，一种是自动的，这里使用WSACreateEvent()这个函数创建返回的事件句柄，正常的返回的情况下，其创建的是一个手工处理的句柄，否则，其返回WSA\_INVALID\_EVENT，表明创建未成功，如果需要知道更多的信息WSAGetLastError()这个函数来得到具体的信息出错代码。**这里埋伏下了一个雷**，为什么创建的是手工处理的事件（manually reset ），那后面为什么**没有WSAResetEvent()**这个函数来处理事件，先记下。  
然后接着讲，

1.  ::WSAEventSelect(sListen, event, FD\_ACCEPT|FD\_CLOSE);
2.  // 添加到表中 
3.  eventArray\[nEventTotal\] = event;
4.  sockArray\[nEventTotal\] = sListen;
5.  nEventTotal++;

将事件绑定到监听的套接字上，这里我们只对这个套接字的接收和关闭两个消息有兴趣，所以只监听这两个消息，那别的读写啥的呢，不要急，慢慢向下看。eventArray和sockArray，定义的是WSA\_MAXIMUM\_WAIT\_EVENTS大小，而在头文件中\#define WSA\_MAXIMUM\_WAIT\_EVENTS (MAXIMUM\_WAIT\_OBJECTS)， **后者被定义成64**，这也是需要注意的一点，这个模型单线程只能处理最多64个事件，再多就只能用多线程了，不过，这里重点说明一下，这个模型即使你使用多线程， **最多也只能处理1200个左右的处理量（正常情况），**否则，会造成整个程序的性能下降，至于怎么下降，还真没有真正的测试，只是从书上和资料上看是这么讲的。  
接着原来，程序然后进入了死循环，在这个循环里，因为是简单的使用嘛，所以很多的异常并没有进行控制，但是为了说明用法，就得简单一些不是么？  
2、事件的监听和控制处理  
2.1 事件的监听

1.  int nIndex = ::WSAWaitForMultipleEvents(nEventTotal, eventArray, FALSE, WSA\_INFINITE, FALSE); 
2.  nIndex = nIndex - WSA\_WAIT\_EVENT\_0;

先说这个索引为什么要减去WSA\_WAIT\_EVENT\_0这个值，因为事件的起始值在内核中是进行定义了的，不过，在这里这个东西最终定义仍然是0。然后我们看这个函数  
::WSAWaitForMultipleEvents(nEventTotal, eventArray, FALSE, WSA\_INFINITE, FALSE),

这个函数用来监听多个事件（就是上面我们绑定的事件）的状态，有状态或者是事件被触发，就会返回，否则会按照你设置的参数进行操作。  
**前面两个参数，第一个是监听的数量，最小是一，MSDN上有，第二是一个事件的数组，第三个是精彩的去处，如果设置成TRUE，那么只有这第二个事件数组中的所有的事件都受信或者说触发，才会动作，如果是FALSE呢，则只要有一个就可以动作。第五个是超时设置，可以是0，是WSA\_INFINITE，也可以是其它的数值，这里有一个问题，如果设置为0会造成程序的CPU占用率过高，WSA\_INFINITE则可能会出现在等待数量为一个字时，且第三个参数设置为TRUE，产生死套接字的长期阻塞。所以还是设置成一个经验值为好，至于这个经验值是多少，看你的程序的具体的应用了**。  
其实这个函数**本质还是调用WaitForMulipleObjectsEx这个函数**，MSDN上讲WSAEventSelect模型在等待时不占用CPU时间，就是这个原因，所以其比阻塞的SOCKET通信要效率高很多，其实那个消息的模型WSAAsycSelect和这个事件的模型也差不多，异曲同工之妙吧。不过适用范围是有区别的，这个可以用在WINCE上。消息则不行。  
这里就又引出一个注意点，在这个模型里，**如果同时有几个事件受信，或者说触发**，那么nIndex = ::WSAWaitForMultipleEvents()**只返回最前面的一个事件**，那么怎么解决其后面的呢，书上有曰：多次循环调用这个就可以了，所以才会引出下面的再次在for循环里调用  
nIndex = ::WSAWaitForMultipleEvents(1, &eventArray\[i\], TRUE, 1000, FALSE);  
注意这里参数的变化，数量为1，事件为\[i\]，但事件会不断的增长，全面受信改成了TRUE，超时为1000，最后的这个参数在这里只能设置成FALSE，具体为什么查MSDN去。  
如果这里我们处理的不好，如果把1000改成无限等待的话，就可以出现上面说的死套接字的无限阻塞，也就是说如果一个套接字死掉了，你没有在事件队伍里删除他，那么他就会一直在这儿阻塞，即使后面有事件也无法得到响应，但是，如果你的套接字只有一个连接的话，就没有什么了，可以改成无限等待。不过，最好还是别这样，因为如果你处理一个失误，就会产生死的套接字（比如重连，但你没有删除先前无用的套接字）。  
**用两个::WSAWaitForMultipleEvents函数，**

**一个用来处理监听多个事件数组，一个用来遍历每个数组事件，**

**防止出现丢失响应的现象，所以其参数的设置是不同的，一定要引起注意。**

2.2事件的处理

然后戏又来了，上面说的读写监听呢，就在这里出现了，包括上面埋伏下的一个雷，也在这里处理了：

首先调用::**WSAEnumNetworkEvents(sockArray\[i\], eventArray\[i\], &event)，把上面的雷给拆了，**

**::WSAEnumNetworkEvents会自动重置事件**，

然后得到事件的索引或者说ID，

1.  if(event.lNetworkEvents & FD\_ACCEPT) // 处理FD\_ACCEPT通知消息 
2.  \{
3.  if(event.iErrorCode\[FD\_ACCEPT\_BIT\] == 0) 
4.  \{
5.  if(nEventTotal > WSA\_MAXIMUM\_WAIT\_EVENTS) 
6.  \{
7.  printf(" Too many connections! \\n"); 
8.  continue; 
9.  \}
10. SOCKET sNew = ::accept(sockArray\[i\], NULL, NULL);
11. WSAEVENT event = ::WSACreateEvent();
12. ::WSAEventSelect(sNew, event, FD\_READ|FD\_CLOSE|FD\_WRITE);
13. // 添加到表中 
14. eventArray\[nEventTotal\] = event;
15. sockArray\[nEventTotal\] = sNew;
16. nEventTotal++;
17. \}
18. \}

代码里重新调用了事件创建和事件绑定函数，并且将两个数组自动增大，最最重要的是我们终于看到了，**FD\_READ|FD\_CLOSE|FD\_WRITE**，

明白了吧，这个简单的程序的**本质其实是将 读 写 和 接收关闭 的套接字混合到了一起**，

而在后面的服务器例程里，我们发现，这个已经拆开，并且**重新手动设置受信的事件，调用了::ResetEvent(event**)。这样不就完美的拆除了上面的雷么。

2.3 其它处理方法  
当程序继续循环到最外层时，::WSAWaitForMultipleEvents无限等待所有的事件，只要有一个事件响应，就会进入到下一层循环，如果是接收就重复上述的动作，如果是读写就进入：

1.  else if(event.lNetworkEvents & FD\_READ) // 处理FD\_READ通知消息 
2.  \{
3.  if(event.iErrorCode\[FD\_READ\_BIT\] == 0) 
4.  \{
5.  char szText\[256\]; 
6.  int nRecv = ::recv(sockArray\[i\], szText, strlen(szText), 0); 
7.  if(nRecv > 0) 
8.  \{
9.  szText\[nRecv\] = '\\0'; 
10. printf("接收到数据：%s \\n", szText); 
11. \}
12. \}
13. \}
14. else if(event.lNetworkEvents & FD\_CLOSE) // 处理FD\_CLOSE通知消息 
15. \{
16. if(event.iErrorCode\[FD\_CLOSE\_BIT\] == 0) 
17. \{
18. ::closesocket(sockArray\[i\]);
19. for(int j=i; j<nEventTotal-1; j++) 
20. \{
21. sockArray\[j\] = sockArray\[j+1\];
22. sockArray\[j\] = sockArray\[j+1\];
23. \}
24. nEventTotal--;
25. \}
26. \}
27. else if(event.lNetworkEvents & FD\_WRITE) // 处理FD\_WRITE通知消息 
28. \{
29. \}

如此往复，不就达到了不断接收连接和处理数据的问题么。  
这里还重复一下，**网上很多程序都没有处理多个事件同时受信的情况，在网上和各种资料中，也有的只使用一个::WSAWaitForMultipleEvents函数，但参数的设置得重新来过，而且得小心的处理各种的事件和异常的发生。可能在小并发量和小数据量时没有问题，但并发一多数据一大，可能会出现丢数据的问题，没有做过测试，但可能是很大的。否则不会说遍历调用这个函数了。**

2.4 FD\_WRITE 事件的触发

这里得罗嗦两句FD\_WRITE 事件的触发，前面的都好理解，主要是啥时候儿会触发这个事件呢，我们在一开始只对接收和关闭进行了监听，为什么没有这个FD\_WRITE事件的

监听呢，

这就引出了下面的东东：（从一个网友那转来）

下面是MSDN中对FD\_WRITE触发机制的解释：

The FD\_WRITE network event is handled slightly differently. An FD\_WRITE network event is recorded when a socket is first connected with connect/WSAConnect or

accepted with accept/WSAAccept, and then after a send fails with WSAEWOULDBLOCK and buffer space becomes available. Therefore, an application can assume that

sends are possible starting from the first FD\_WRITE network event setting and lasting until a send returns WSAEWOULDBLOCK. After such a failure the

application will find out that sends are again possible when an FD\_WRITE network event is recorded and the associated event object is set

FD\_WRITE事件只有在以下三种情况下才会触发

①client 通过connect（WSAConnect）首次和server建立连接时，在client端会触发FD\_WRITE事件

②server通过accept（WSAAccept）接受client连接请求时，在server端会触发FD\_WRITE事件

③send（WSASend）/sendto（WSASendTo）发送失败返回WSAEWOULDBLOCK，并且当缓冲区有可用空间时，则会触发FD\_WRITE事件

①②其实是同一种情况，在第一次建立连接时，C/S端都会触发一个FD\_WRITE事件。

主要是③这种情况：send出去的数据其实都先存在winsock的发送缓冲区中，然后才发送出去，如果缓冲区满了，那么再调用send（WSASend,sendto,WSASendTo）的话，就会返回一个 WSAEWOULDBLOCK的错误码，接下来随着发送缓冲区中的数据被发送出去，缓冲区中出现可用空间时，一个 FD\_WRITE 事件才会被触发，这里比较容易混淆的是 FD\_WRITE 触发的前提是 缓冲区要先被充满然后随着数据的发送又出现可用空间，而不是缓冲区中有可用空间，也就是说像如下的调用方式可能出现问题

1.  else if(event.lNetworkEvents & FD\_WRITE) 
2.  \{
3.  if(event.iErrorCode\[FD\_WRITE\_BIT\] == 0) 
4.  \{
5.  send(g\_sockArray\[nIndex\], buffer, buffersize);
6.  ....
7.  \}
8.  else 
9.  \{
10. \}
11. \}

问题在于建立连接后 FD\_WRITE 第一次被触发， 如果send发送的数据不足以充满缓冲区，虽然缓冲区中仍有空闲空间，但是 FD\_WRITE 不会再被触发，程序永远也等不到可以发送的网络事件。

基于以上原因，在收到FD\_WRITE事件时，程序就用循环或线程不停的send数据，**直至send返回WSAEWOULDBLOCK，**表明缓冲区已满，再退出循环或线程。

当缓冲区中又有新的空闲空间时，FD\_WRITE 事件又被触发，程序被通知后又可发送数据了。

上面代码片段中省略的对 FD\_WRITE 事件处理

1.  else if(event.lNetworkEvents & FD\_WRITE) 
2.  \{
3.  if(event.iErrorCode\[FD\_WRITE\_BIT\] == 0) 
4.  \{
5.  while(TRUE) 
6.  \{
7.  // 得到要发送的buffer，可以是用户的输入，从文件中读取等 
8.  GetBuffer....
9.  if(send(g\_sockArray\[nIndex\], buffer, buffersize, 0) == SOCKET\_ERROR) 
10. \{
11. // 发送缓冲区已满 
12. if(WSAGetLastError() == WSAEWOULDBLOCK) 
13. break; 
14. else 
15. ErrorHandle...
16. \}
17. \}
18. \}
19. else 
20. \{
21. ErrorHandle..
22. break; 
23. \}
24. \}

如果你不是大数据量的不断的发送数据，建议你忽略这个事件，毕竟缓冲区不是很容易被弄满的，结果就是你的发送事件无法完成。

2.5异常的处理

主要是0个连接时，处理CPU的占用率的问题，以及在多于64个事件时的监听处理问题。而且包括上面讲的，没有双循环时的多事件同时受信的问题。

2.6 多线程服务端

这个大家可以看王艳平的书，说得很清楚，需要注意的是在他的主服务程序里，使用的是int nRet = ::WaitForSingleObject(event, 5\*1000);

所以下面要手动的重新对事件进行设置，否则这个事件就再无法监听得到了。

其它的难度主要是面向对象的设计封装要弄明白，如果这个弄明白知道封装SOCKET和THREAD结构体的目的是什么，再照着书上看就不会有错了，

但提醒一点， **线程结构体中**的第一个事件是重建事件，不要和其它的监听事件弄混了。

**如果做一个介于书上两种代码间的小框架，可以用一个线程来监听ACCEPT和CLOSE事件，另外的线程监听小于64个的读写等事件，一般的小的SOCKET通信应该就没有什么问题了。重要的是你要把这个服务端封装好，有时间做一下。**

三、例程（客户端）

先上一段代码：

1.  DWORD WINAPI Connect(LPVOID lpParam) 
2.  \{
3.  //第1步:初始化,创建,连接套接字// 
4.  WSADATA WsaData;int err; 
5.  err = WSAStartup (0x0002, &WsaData);if(err!=0) return 1; //0x0002代表版本2.0 
6.  socket\_client=socket(AF\_INET,SOCK\_STREAM,0);
7.  if(socket\_client==INVALID\_SOCKET)\{AfxMessageBox("创建套接字错误!\\n");return 1;\} 
8.  
9.  SOCKADDR\_IN sconnect\_pass;
10. sconnect\_pass.sin\_family=AF\_INET;
11. sconnect\_pass.sin\_addr.S\_un.S\_addr=inet\_addr("127.0.0.1"); 
12. sconnect\_pass.sin\_port=htons(55551);
13. 
14. if (SOCKET\_ERROR==connect(socket\_client,(SOCKADDR\*)&sconnect\_pass,sizeof(SOCKADDR))) 
15. \{
16. AfxMessageBox("连接服务端错误\\n"); 
17. return 1; 
18. \}
19. else 
20. \{
21. //将套接口s置于”非阻塞模式“ 
22. u\_long u1=1;//0为保持默认的阻塞,非0表示改为非阻塞 
23. ioctlsocket(socket\_client,FIONBIO,(u\_long\*)&u1);
24. //--------------①创建事件对象----------------- 
25. WSAEVENT ClientEvent=WSACreateEvent();
26. if (ClientEvent==WSA\_INVALID\_EVENT) 
27. \{
28. \#ifdef \_DEBUG 
29. ::OutputDebugString("创建事件错误!\\n"); 
30. \#endif // \_DEBUG 
31. AfxMessageBox("WSACreateEvent() Failed,Error=【%d】\\n"); 
32. return 1; 
33. \}
34. //--------------②网络事件注册------------ 
35. int WESerror=WSAEventSelect(socket\_client,ClientEvent,FD\_READ|FD\_CLOSE); 
36. if (WESerror==INVALID\_SOCKET) 
37. \{
38. \#ifdef \_DEBUG 
39. ::OutputDebugString("网络事件注册错误!\\n"); 
40. \#endif // \_DEBUG 
41. AfxMessageBox("WSAEventSelect() Failed,Error=【%d】\\n"); 
42. return -1; 
43. \}
44. //-----------准备工作--------------- 
45. //WSAWaitForMultipleEvents只能等待64个事件,若想更多,则创建额外的工作线程 
46. SOCKET sockArray\[WSA\_MAXIMUM\_WAIT\_EVENTS\]; WSAEVENT eventArray\[WSA\_MAXIMUM\_WAIT\_EVENTS\];
47. int nEventCount = 0; 
48. sockArray\[0\]=socket\_client; eventArray\[nEventCount\]=ClientEvent;
49. nEventCount++;//事件个数+1,第1次等待1个事件,注意WSAWaitForMultipleEvents的参数1是动态 
50. int t=1;//超时次数 
51. //------------循环处理------------- 
52. while (1) 
53. \{
54. //---------------⑦等待事件对象-------------- 
55. int nIndex=WSAWaitForMultipleEvents(nEventCount,eventArray,FALSE,40000,FALSE);//参数1:注意是动态增减的,不能固定死 .注:参数1与2本质一样,但数值不一样.如果参 
56. 
57. 数1为1个,那么数组括号内\[\]为0
58. //参数3:参数1中的任何一个有消息进来,都立刻停止阻塞,运行下一步操作 
59. AfxMessageBox("响应事件,进入下一步\\n");//进来时为0,响应时为对应的数组标签号 
60. if (nIndex==WSA\_WAIT\_FAILED)//------7.1调用失败--------- 
61. \{
62. AfxMessageBox("WSAEventSelect调用失败\\n"); 
63. break;//退出while(1)循环 
64. \}
65. else if (nIndex==WSA\_WAIT\_TIMEOUT)//-------7.2超时--------- 
66. \{
67. if (t<3) 
68. \{
69. AfxMessageBox("第【%d】次超时\\n"); 
70. t++;
71. continue; 
72. \}
73. else 
74. \{
75. AfxMessageBox("第【%d】次超时，退出\\n"); 
76. break; 
77. \}
78. \}
79. //---------------7.3网络事件触发事件对象句柄的工作状态-------- 
80. else 
81. \{
82. WSANETWORKEVENTS event;//该结构记录网络事件和对应出错代码 
83. //---------⑧网络事件查询----------- 
84. WSAEnumNetworkEvents(sockArray\[nIndex-WSA\_WAIT\_EVENT\_0\],NULL,&event);
85. WSAResetEvent(eventArray\[nIndex-WSA\_WAIT\_EVENT\_0\]);
86. if (event.lNetworkEvents&FD\_READ) //-------8.2处理FD\_READ通知消息 
87. \{
88. if (event.iErrorCode\[FD\_READ\_BIT\]==0) 
89. \{
90. char m\_RecvBuffer\[4096\]; 
91. PCMD\_HEADER pcm = (PCMD\_HEADER)m\_RecvBuffer;
92. if(recv(sockArray\[nIndex-WSA\_WAIT\_EVENT\_0\],(char\*)&m\_RecvBuffer,sizeof(m\_RecvBuffer),0)==SOCKET\_ERROR) 
93. \{
94. AfxMessageBox("接收失败,退出重recv接收!"); 
95. break; 
96. \}
97. else 
98. \{
99. switch ( pcm->ncmd ) 
100. \{
101. case CMD\_AS\_REP\_C\_MACHINE\_LOGIN://很明显这个pcm->ncmd,是登录包中ncmd标识符 
102. \{
103. PAREP\_C\_MACHINE\_LOGIN cmd = (PAREP\_C\_MACHINE\_LOGIN)pcm;
104. if (cmd->nStatus==1) 
105. \{
106. AfxMessageBox("收到登录回复包(Client->Server)状态:成功!"); 
107. \}
108. else 
109. \{
110. AfxMessageBox("收到登录回复包(Client->Server)状态:失败!"); 
111. \}
112. \}
113. break; 
114. \}
115. \}
116. \}
117. \}
118. else if (event.lNetworkEvents&FD\_CLOSE) //---------8.3处理FD\_CLOSE通知消息 
119. \{
120. if (event.iErrorCode\[FD\_CLOSE\_BIT\]==0) //客户端正常关闭 
121. \{
122. closesocket(sockArray\[nIndex-WSA\_WAIT\_EVENT\_0\]);
123. WSACloseEvent(eventArray\[nIndex-WSA\_WAIT\_EVENT\_0\]);
124. AfxMessageBox("套接字已关闭连接\\n");//注:会触发7.1调用失败 
125. \}
126. else //客户端异常已关闭 
127. \{
128. if (event.iErrorCode\[FD\_CLOSE\_BIT\]==10053)//右键->转到定义,可以查看到很多错误标识.按需设置(此处仅设置了客户端没有通知服务端,就非法关闭了) 
129. \{
130. closesocket(sockArray\[nIndex-WSA\_WAIT\_EVENT\_0\]);
131. WSACloseEvent(eventArray\[nIndex-WSA\_WAIT\_EVENT\_0\]);
132. AfxMessageBox("服务端非法关闭连接\\n");//注:会触发7.1调用失败 
133. \}
134. \}
135. for (int j=nIndex-WSA\_WAIT\_EVENT\_0;j<nEventCount-1;j++) 
136. \{
137. sockArray\[j\]=sockArray\[j+1\];
138. eventArray\[j\]=eventArray\[j+1\];
139. \}
140. nEventCount--;
141. \}
142. \}// end 网络事件触发 
143. \}//end while 
144. // 
145. \}
146. AfxMessageBox("服务端已退出.客户端退出中\\n"); 
147. closesocket(socket\_client);
148. WSACleanup();
149. return 0; 
150. \}
151. void CMyDlg::OnBnClickedButtonRun() 
152. \{
153. //发包 
154. C\_MACHINE\_LOGIN\_SYSTEM cmd;
155. strcpy(cmd.sMachineCode,"20100904164702750199");//机器码 
156. CString str;
157. str.Format("%d",cmd.nVersion); 
158. if(send(socket\_client,(char\*)&cmd,sizeof(cmd),0)==SOCKET\_ERROR) 
159. \{
160. \#ifdef \_DEBUG 
161. ::OutputDebugString("发送失败:发送机器码!\\n"); 
162. \#endif // \_DEBUG 
163. \}
164. \}

这里就不再进行详细的分析，比照服务端，这里会更简单，需要说明的是，在这里可以使用WSAConnect这个函数来达到连接的目的，不用使用这个东西，当然，如果这样的话，你的发送和接收都要使用WSARecv和 WSASend函数。主要是使用overloapped重叠IO，使用起来更简单明了。

[http_blog.csdn.net_wangjieest_article_details_7042108]: http://blog.csdn.net/wangjieest/article/details/7042108