MFC CAsyncSocket

MFC CAsyncSocket

由于都是直接利用动态连接库wsock32.dll进行操作，实现比较繁琐。其实，为简化套接字编程，MFC 定义了两个套接字类：CAsyncSocket、CSocket。CAsyncSocket类在低层次上对 Windows Sockets API 进行了封装，其成员函数和 Windows Sockets API 函数直接相对应 。一个CAsyncSocket对 象 就 代 表 了一 个 套 接 字。而CSocket继承于CAsyncSocket 类，是对 Windows Sockets API 的高级封装。
    建立Socket的WSAStartup过程和bind过程被简化成为Create过程， IP地址类型转换、主机名和IP地址转换的过程中许多复杂的变量类型都被简化成字符串和整数操作，特别是CAsyncSocket类的异步特点，完全可以替代繁琐的线程操作。
一、1.CAsyncSocket 类直接派生于CObject类，称为异步套接字对象。由于 CAsyncSocket类的构造函数不带参数 ，需要调用起成员函数 Create 来创建底层的套接字句柄， 决定套接字对象的具体特性，并绑定它的地址。
BOOL Create( UINT nSocketPort=0，
    Int nSocketType = SOCK_STREAM,
    Long Ievent=FD_READ|FD_WRITE|FD_OOB|FD_ACCEPT|FD_CONNECT|FD_CLOSE,
    LPCTSTR lpszSocketAddress = NULL );

CAsyncSocket 类的 6 种网络事件
事 件     涵    义                           对应处理函数
FD_ACCEPT 通知侦听套接字当前有连接请求可以接受    OnAccept(int nErrorCode);
FD_CONNECT 通知请求连接的套接字，连接要求已被处理 OnConnect(int nErrorCode);
FD_CLOSE   通知套接字与其连接的套接字已关闭        OnClose(int nErrorCode);
FD_READ    通知有数据到达                          OnReceive(int nErrorCode);
FD_WRITE   通知可以发送数据                        OnSend(int nErrorCode);
FD_OOB     通知将有外带数据到达                    OnOutOfBandData(int ErrorCode);

      当某个网络事件发生时，MFC 框架把消息发送给相应的套接字对象，相当于给了该对象一个通知，告诉它某个重 要的事件已经发生，接着自动调用 该对象的事件处理函数。

2.如果从 CAsyncSocket 类派生了自己的套接字类，则必须重载某些网络事件所对应的通知函数。
3.服务器端
   与Winsock不同，CAsyncSocket服务端不用绑定(Bind)，不用连接(Connect)。
   正常情况下，服务器端必须首先创建一个 CAsyncSocket 套接字对象，并调用它的 Create成员函数创建底层套接字 句柄。这个套接字对象专门用来侦听来自客户机的连接请求，所以称它为侦听套接字对象。再调用侦听套接字对象的

Listen 函数，使侦听套接字对象开始侦听来自客户端的连接请求。
(1) 当 Listen 函数确认并接纳了一个客户端连接请求后，触发 FD_ACCEPT 事件，侦听套接字收到通知，MFC 框 架自动调用 侦听套接字的 OnAccept 事件处理函数。一般需要重载 OnAccept 函数，再在其中调用侦听套接字对象的

Accept 函数。
(2) 创建一个新的空套接字对象，专门用来与客户端连接并进行数据的传输，一般称为连接套接字，并作为参数传 递给下一步的 Accept 成员函数。m_sListenSocket.Accept(m_sConnectSocket);
4.客户端
   客户端请求连接到服务器端，在服务器端套接字对象已经进入侦听状态之后，客户应用程序可以调用CAsyncSocket类的 Connect 成员函数，向服务器发出一个连接请求。调用结束返回时发生FD_CONNECT事件，MFC 框架会自动调用 客 户端套接字的 OnConnect 事件处理函数。
CSocket 类是 CAsyncSocket 的派生类。创建 CSocket 对象时，首先要调用 CSocket 类
的构造函数创建一个空的 CSocket 对象，再调用其 Create 成员函数，创建对象的底层套
接字。

BOOL Create(
      UINT nSocketPort = 端口号，
      Int nSocketPort = SOCK_STREAM | SOCK_DGRAM，
      LPCTSTR lpszSocketAddress = 套接字所用的网络地址 )；
二、CSocket 类使用基类 CAsyncSocket 的同名成员函数 Connect、Listen、Accept 来建立服务器和客户机套接字之 间的连接，使用方法基本相同。在创建 CSocket 类对象后，对于流式套接字，首先在服务器和客户机之间建立连接，然后使用 Send 函数、Receive 函数来发送和接收数据。
    需要注意的是，CSocket对象从不调用OnConnect和OnSend事件处理函数。CSocket类继承了 CAsyncSocket 类的许 多成员函数，用法基本一致。CSocket类的高级性主要表现在3个方面。
(1) CSocket 结合 CArchive 类来使用套接字。
(2) CSocket 管理了通信的许多方面，比如字节顺序问题和字符串转换问题。
(3) CSocket 类为 Windows 消息的后台处理提供了阻塞的工作模式。有关阻塞的概念读者可参阅相关文献资料，此处 不再赘述。
因此，一般将 CSocket 与 CArchive、CSocketFile 类相结合，来发送和接收数据，这将使编程更为简单。

===============================================================================
---- 一个Echo例程来介绍CAsyncSocket类的用法。

---- 一． 客户端

---- 1． 创建一个Dialog Based项目：CSockClient。

---- 2． 设计对话框

---- 去掉Ok和Cancle两个按钮，增加ID_Connect（连接）、ID_Send（发送）、ID_Exit（关闭）按钮，增加ListBox控 件IDC_LISTMSG和Edit控件IDC_EDITMSG，并按下表在ClassWizard中为CCSockClientDlg类添加变量。

Control ID Type Member
   
IDC_EDITMSG CEdit m_MSG
IDC_LISTMSG ClistBox m_MSGS

---- 3． CAsyncSocket类用DoCallBack函数处理MFC消息，当一个网络事件发生时，DoCallBack函数按网络事件类型： FD_READ、FD_WRITE、FD_ACCEPT、FD_CONNECT分别调用OnReceive、OnSend、OnAccept、OnConnect函数。由于MFC把这 些事件处理函数定义为虚函数，所以要生成一个新的C++类，以重载这些函数，做法如下：

---- 以Public方式继承CAsyncSocket类，生成新类MySock；

---- 为MySock类添加虚函数OnReceive、OnConnect、OnSend

---- 4． 在MySock.ccp中添加以下代码

#include "CSockClient.h"
#include "CSockClientDlg.h"

---- 5． 在MySock.h中添加以下代码

public:
      BOOL m_bConnected;    //是否连接
      UINT m_nLength;        //消息长度
      char m_szBuffer[4096];    //消息缓冲区

---- 6． 在MySock.ccp中重载各函数

MySock::MySock()
{
m_nLength=0;
memset(m_szBuffer,0,sizeof(m_szBuffer));
m_bConnected=FALSE;
}

MySock::~MySock()
{
//关闭套接字
if(m_hSocket!=INVALID_SOCKET)
      Close();
}

void MySock::OnReceive(int nErrorCode)
{
m_nLength=Receive(m_szBuffer,sizeof(m_szBuffer),0);
//下面两行代码用来获取对话框指针
CCSockClientApp* pApp=(CCSockClientApp*)AfxGetApp();
CCSockClientDlg* pDlg=(CCSockClientDlg*)pApp- >m_pMainWnd;
pDlg- >m_MSGS.InsertString(0,m_szBuffer);
memset(m_szBuffer,0,sizeof(m_szBuffer));
CAsyncSocket::OnReceive(nErrorCode);
}

void MySock::OnSend(int nErrorCode)
{
Send(m_szBuffer,m_nLength,0);
m_nLength=0;
memset(m_szBuffer,0,sizeof(m_szBuffer));
//继续提请一个“读”的网络事件，接收Server消息
AsyncSelect(FD_READ);
CAsyncSocket::OnSend(nErrorCode);
}

void MySock::OnConnect(int nErrorCode)
{
if (nErrorCode==0)
{
      m_bConnected=TRUE;
      CCSockClientApp* pApp=(CCSockClientApp*)AfxGetApp();
      CCSockClientDlg* pDlg=(CCSockClientDlg*)pApp- >m_pMainWnd;
      memcpy(m_szBuffer,"Connected to ",13);
      strncat(m_szBuffer,pDlg- >m_szServerAdr,
          sizeof(pDlg- >m_szServerAdr));
      pDlg- >m_MSGS.InsertString(0,m_szBuffer);
      AsyncSelect(FD_READ);    提请一个“读”的网络事件，准备接收
}
CAsyncSocket::OnConnect(nErrorCode);
}

---- 7． 新建对话框IDD_Addr，用来输入IP地址和Port；生成新类CAddrDlg。增加两个Edit控件：IDC_Addr、 IDC_Port按下表在ClassWizard中为CAddrDlg类添加变量。

Control ID Type Member

IDC_Addr CString m_Addr
IDC_Port Int m_Port

---- 8． 在CSockClientDlg.h中添加代码

#include "AddrDlg.h"
protected:
int TryCount;
MySock m_clientSocket;
UINT m_szPort;
public:
char m_szServerAdr[256];

---- 9． 双击IDD_CSOCKCLIENT_DIALOG对话框中的“连接”按钮，添加以下代码

void CCSockClientDlg::OnConnect()
{
m_clientSocket.ShutDown(2);
m_clientSocket.m_hSocket=INVALID_SOCKET;
m_clientSocket.m_bConnected=FALSE;
CAddrDlg m_Dlg;
//默认端口1088
m_Dlg.m_Port=1088;
if (m_Dlg.DoModal()==IDOK && !m_Dlg.m_Addr.IsEmpty())
{
      memcpy(m_szServerAdr,m_Dlg.m_Addr,sizeof(m_szServerAdr));
      m_szPort=m_Dlg.m_Port;
      //建立计时器，每1秒尝试连接一次，直到连上或TryCount>10
SetTimer(1,1000,NULL);
      TryCount=0;
}
}

---- 10． 添加Windows消息WM_TIMER响应函数OnTimer

void CCSockClientDlg::OnTimer(UINT nIDEvent)
{
if (m_clientSocket.m_hSocket==INVALID_SOCKET)
{
      BOOL bFlag=m_clientSocket.Create(0,SOCK_STREAM,FD_CONNECT);
      if(!bFlag)
      {
       AfxMessageBox("Socket Error!");
       m_clientSocket.Close();
       PostQuitMessage(0);
       return;
      }
}
m_clientSocket.Connect(m_szServerAdr,m_szPort);
TryCount++;
if (TryCount >=10 || m_clientSocket.m_bConnected)
{
      KillTimer(1);
      if (TryCount >=10)
       AfxMessageBox("Connect Failed!");
      return;
}
CDialog::OnTimer(nIDEvent);
}

---- 11． 双击IDD_CSOCKCLIENT_DIALOG对话框中的“发送”按钮，添加以下代码

void CCSockClientDlg::OnSend()
{
if (m_clientSocket.m_bConnected)
{
m_clientSocket.m_nLength=m_MSG.GetWindowText
(m_clientSocket.m_szBuffer, sizeof(m_clientSocket.m_szBuffer));
      m_clientSocket.AsyncSelect(FD_WRITE);
      m_MSG.SetWindowText("");
}
}

---- 12． 双击IDD_CSOCKCLIENT_DIALOG对话框中的“关闭”按钮，添加以下代码

void CCSockClientDlg::OnExit()
{
//关闭Socket
m_clientSocket.ShutDown(2);
//关闭对话框
EndDialog(0);
}

----
12．运行此项目，连接时输入主机名或IP均可，CAsyncSocket类会自动处理。
----
二． 服务端
----
Server端的编程与Client端的类似，下面主要介绍他的Listen及Accept函数
----
1． 建立一个CNewSocket类，重载CAsyncSocket类的OnReceive、OnSend函数，如何进行信息的显示和发送可以参考 Client程序。本例中采用将收到信息原封不动发回的方法来实现Echo功能，代码如下
CNewSocket：：OnReceive（int nErrorCOde）
{
m_nLength=Receive（m_szBuffer，sizeof（m_szBuffer），0）；
// 直接转发消息
AsyncSelect（FD_WRITE）；
}

CNewSocket：：OnSend（int nErrorCode）
{
Send（m_szBuffer，m_nLength，0）；
}

----
2． 建立一个CMyServerSocket类，重载CAsyncSocket类的OnAccept函数代码如下
----
在MyServerSocket.h中声明变量
public:：
CNewSocket*    m_pSocket；

void CMyServerSocket：：OnAccept（int nErrorCode）
{
//侦听到连接请求，调用Accept函数
CNewSocket* pSocket = new CNewSocket（）；
if （Accept（*pSocket））
{
      pSocket- >AsyncSelect（FD_READ）；
m_pSocket=pSocket；
}
else
      delete pSocket；
}

----
3． 为对话框添加一个“侦听”按钮，添加如下代码
----
在CsockServerDlg.ccp中声明变量
public：
CMyServerSocket    m_srvrSocket;
void CCSockServerDlg：：OnListen（）
{
if （m_srvrSocket.m_hSocket==INVALID_SOCKET）
{
      BOOL bFlag=m_srvrSocket.Create
         (UserPort，SOCK_STREAM，FD_ACCEPT)；
      if （！bFlag）
      {
       AfxMessageBox（“Socket Error！”）；
       M_srvrSocket.Close（）；
       PostQuitMessage（0）；
       Return；
      }
}
//“侦听”成功，等待连接请求
if （！m_srvrSocket。Listen（1））
{
      int nErrorCode = m_srvrSocket.GetLastError（）；
      if （nError！=WSAEWOULDBLOCK）
      {
       AfxMessageBox（“Socket Error！”）；
       M_srvrSocket.Close（）；
       PostQuitMessage（0）；
       Return；
      }
}
}

----
4． 目前程序只能实现Echo功能，将信息原封不动的转发，若能将Accept中由CNewSocket* pSocket =    new CNewSocket（）；得到的Socket指针存入一个CList或一个数组中，便像Client端那样，对所有的连接进行读写控制。