CAsyncSocket，CSocket的使用方法

    Socket有同步（阻塞）方式和异步（非阻塞）方式两种。"同步"就是函数直到其要执行的功能全部完成时才返回，“异步”则是，函数仅仅做一些简单的工作，然后马上返回，而他所要实现的功能留给别的线程或者函数去完成。

一、Socket API

    1、默认用作同步方式，就是你从不调用WSAIoctl()和ioctlsocket() 来改变Socket IO模式，也从不调用WSAAysncSelect()和WSAEventSelect()来选择需要处理的Socket事件。由于函数accept(),WSAAccept(),connect(),

WSAConnect(),send(),WSASend(),recv(),WSARecv()等函数被用作阻塞方式，所以可能你需要放在专门的线程里，这样以不影响主程序的运行和主窗口的刷新。

    2、 如果作为异步用，那么程序主要就是要处理事件。它有两种处理事件的办法：

    第一种，它常关联一个窗口 ，也就是异步Socket的事件将作为消息发往该窗口，这是由WinSock扩展规范里的一个函数WSAAsyncSelect()来实现和窗口关联。最终你只需要处理窗口消息，来收发数据。
    第二种，用到了扩展规范里另一个关于事件的函数  ，WSAEventSelect()，它是用事件对象的方式来处理Socket事件，也就是，你必须首先用 WSACreateEvent()来创建一个事件对象，然后调用WSAEventSelect()来使得Socket的事件和这个事件对象关联。最终你将要在一个线程里用扩展规范里提供的 WSAWaitForMultipleEvents()来等待这个事件对象被触发。这个过程也稍显复杂。

二、CAsyncSocket

    CAsyncSocket的Create()函数，除了创建了一个SOCKET以外，还创建了个CSocketWnd窗口对象，并使用 WSAAsyncSelect()将这个SOCKET与该窗口对象关联，以让该窗口对象处理来自Socket的事件(消息)，然而CSocketWnd收 到Socket事件之后，只是简单地回调CAsyncSocket::OnReceive()，CAsyncSocket::OnSend()， CAsyncSocket::OnAccept()，CAsyncSocket::OnConnect()等虚函数。所以CAsyncSocket的派生 类，只需要在这些虚函数里添加发送和接收的代码。 

bool CAsyncSocket::Create( long lEvent ) file: //参数lEvent是指定你所  关心的Socket事件
        {
         m_hSocket = socket( PF_INET, SOCK_STREAM, 0 ); file: //创建Socket本身
         CSocketWnd* pSockWnd = new CSocketWnd; file: //创建响应事件的窗口，实际的这个窗口在AfxSockInit()调用时就被创建了。
         pSockWnd->Create(...);
         WSAAsyncSelect( m_hSocket, pSockWnd->m_hWnd, WM_SOCKET_NOTIFY, lEvent ); file: //Socket事件和窗口关联
        }

         static void PASCAL CAsyncSocket::DoCallBack(WPARAM wParam, LPARAM lParam)
        {
         CAsyncSocket Socket;
         Socket.Attach( (SOCKET)wParam ); file: //wParam就是触发这个事件的Socket的句柄
         int nErrorCode = WSAGETSELECTERROR(lParam); file: //lParam是错误码与事件码的合成
         switch (WSAGETSELECTEVENT(lParam))
         {
         case FD_READ:
                pSocket->OnReceive(nErrorCode);
                 break;
         case FD_WRITE:
                pSocket->OnSend(nErrorCode);
                 break;
         case FD_OOB:
                pSocket->OnOutOfBandData(nErrorCode);
                 break;
         case FD_ACCEPT:
                pSocket->OnAccept(nErrorCode);
                 break;
         case FD_CONNECT:
                pSocket->OnConnect(nErrorCode);
                 break;
         case FD_CLOSE:
                pSocket->OnClose(nErrorCode);
                 break;
         }
        }
        CSocketWnd类大致为：
        BEGIN_MESSAGE_MAP(CSocketWnd, CWnd)
         ON_MESSAGE(WM_SOCKET_NOTIFY, OnSocketNotify)
        END_MESSAGE_MAP()
        LRESULT CSocketWnd::OnSocketNotify(WPARAM wParam, LPARAM lParam)
        {
         CAsyncSocket::DoCallBack( wParam, lParam ); file: //收到Socket事件消息，回调CAsyncSocket的DoCallBack()函数
         return 0L;
        }

     然而，最不容易被初学Socket编程的人理解的，也是本文最要提醒的一点是，客户方在使用CAsyncSocket::Connect() 时，往往返回一个WSAEWOULDBLOCK的错误(其它的某些函数调用也如此)，实际上这不应该算作一个错误，它是Socket提醒我们，由于你使用 了非阻塞Socket方式，所以(连接)操作需要时间，不能瞬间建立。既然如此，我们可以等待呀，等它连接成功为止，于是许多程序员就在调用 Connect()之后，Sleep(0)，然后不停地用WSAGetLastError()或者CAsyncSocket::GetLastError ()查看Socket返回的错误，直到返回成功为止。这是一种错误的做法，断言，你不能达到预期目的。事实上，我们可以在Connect()调用之后等待 CAsyncSocket::OnConnect()事件被触发，CAsyncSocket::OnConnect()是要表明Socket要么连接成功 了，要么连接彻底失败了。至此，我们在CAsyncSocket::OnConnect()被调用之后就知道是否Socket连接成功了，还是失败了。
    类似的，Send()如果返回WSAEWOULDBLOCK错误，我们在OnSend()处等待，Receive()如果返回WSAEWOULDBLOCK错误，我们在OnReceive()处等待，以此类推。
    还有一点，也许是个难点，那就是在客户方调用Connect ()连接服务方，那么服务方如何Accept()，以建立连接的问题。简单的做法就是在监听的Socket收到OnAccept()时，用一个新的CAsyncSocket对象去建立连接，例如：

void CMySocket::OnAccept( int ErrCode )
{
      CMySocket* pSocket = new CMySocket;
      Accept( *pSocket );
}
    于是，上面的pSocket和客户方建立了连接，以后的通信就是这个pSocket对象去和客户方进行，而监听的Socket仍然继续在监听，一旦又有一 个客户方要连接服务方，则上面的OnAccept()又会被调用一次。当然pSocket是和客户方通信的服务方，它不会触发OnAccept()事件， 因为它不是监听Socket。

三、CSocket
    CSocket是MFC在CAsyncSocket基础上派生的一个同步阻塞Socket的封装类。它是如何又把CAsyncSocket变成同步的，而且还能响应同样的Socket事件呢？
   其实很简单，CSocket在Connect()返回WSAEWOULDBLOCK错误时，不是在OnConnect()，OnReceive()这些事件终端函数里去等待。你先必须明白Socket事件是如何到达这些事件函数里的。这些事件处理函数是靠CSocketWnd窗口对象回调的，而窗口对象收到来自Socket的事件，又是靠线程消息队列分发过来的。总之，Socket事件首先是作为一个消息发给CSocketWnd窗口对象，这个消息肯定需要经过线程消息队列的分发，最终CSocketWnd窗口对象收到这些消息就调用相应的回调函数(OnConnect()等)。
    所以，CSocket在调用Connect()之后，如果返回一个WSAEWOULDBLOCK错误时，它马上进入一个消息循环，就是从当前线程的消息队列里取关心的消息，如果取到了WM_PAINT消息则刷新窗口，如果取到的是Socket发来的消息，则根据Socket是否有操作错误码，调用相应的回调函数。

BOOL CSocket::Connect( ... )
        {
         if( !CAsyncSocket::Connect( ... ) )
         {
                 if( WSAGetLastError() == WSAEWOULDBLOCK ) file: //由于异步操作需要时间，不能立即完成，所以Socket返回这个错误
                {
                 file: //进入消息循环，以从线程消息队列里查看FD_CONNECT消息，直到收到FD_CONNECT消息，认为连接成功。
                 while( PumpMessages( FD_CONNECT ) );
                }
         }
        }
        BOOL CSocket::PumpMessages( UINT uEvent )
        {
                        CWinThread* pThread = AfxGetThread();
                         while( bBlocking ) file: //bBlocking仅仅是一个标志，看用户是否取消对Connect()的调用
                        {
                                        MSG msg;
                                         if( PeekMessage( &msg, WM_SOCKET_NOTIFY ) )
                                        {
                                                 if( msg.message == WM_SOCKET_NOTIFY && WSAGETSELECTEVENT(msg.lParam) == uStopFlag )
                                                 {
                                                                 CAsyncSocket::DoCallBack( msg.wParam, msg.lParam );
                                                                 return TRUE;
                                                 }                
                                 }
                                 else
                                {
                                                 OnMessagePending(); file: //处理消息队列里的其它消息
                                                 pThread->OnIdle(-1);
                                }
                 }
        }
        BOOL CSocket::OnMessagePending()
        {
                        MSG msg;
                         if( PeekMessage( &msg, NULL, WM_PAINT, WM_PAINT, PM_REMOVE ) )
                         { file: //这里仅关心WM_PAINT消息，以处理阻塞期间的主窗口重画
                                         ::DispatchMessage( &msg );
                                         return FALSE;
                         }
                         return FALSE;
        }

    其它的CSocket函数，诸如Send()，Receive()，都在收到WSAEWOULDBLOCK错误时，进入 PumpMessages()消息循环，这样一个原本异步的CAsyncSocket，到了派生类CSocket，就变成同步的了。
    明白之后，我们可以对CSocket应用自如了。比如有些程序员将CSocket的操作放入一个线程，以实现多线程的异步Socket(通常，同步+多线程 相似于 异步 )。

四、CSocketFile
    另外，进行Socket编程，不能不提到CSocketFile类，其实它并不是用来在Socket双方发送文件的，而是将需要序列化的数据，比如一些结 构体数据，传给对方，这样，程序的CDocument()的序列化函数就完全可以和CSocketFile 联系起来。例如你有一个CMyDocument实现了Serialize()，你可以这样来将你的文档数据传给Socket的另一方：

 CSocketFile file( pSocket );
 CArchive ar( &file, CArchive::store );
 pDocument->Serialize( ar );
 ar.Close();

    同样，接收一方可以只改变上面的代码为CArchive ar( &file, CArchive::load );即可。
    注意到，CSocketFile类虽然从CFile派生，但它屏蔽掉了CFile::Open()等函数，而函数里仅扔出一个例外。那么也就是说，你不能 调用CSocketFile的Open函数来打开一个实实在在的文件，否则会导致例外，如果你需要利用CSocketFile来传送文件，你必须提供 CSocketFile类的这些函数的实现。
    再一点，CArchive不支持在datagram的Socket连接上序列化数据。