*****网络**编程学习 *MFC**

*******网络**编程学习 ***
**MFC**

要学习好网路编程，主要看以下几个方面：

1、掌握概念，诸如：同步(Sync)/异步(Async)，阻塞(Block)/ 

非阻塞(Unblock)等。

2、在实际Windows网络通信软件开发中，异步非阻塞套接字是用的 

最多的。平常所说的C/S（客户端/服务器）结构的软件就是异步 

非阻塞模式的。

3、在异步非阻塞模式下的通信，要借助于多线程来开发。

4、许多文章都曾经介绍过用VC++进行Socket编程的方法，直接 

利用动态连接库wsock32.dll进行操作，实现比较繁琐。但实际上 

网络编程概括为三种套接字方法：流式套接字（SOCK_STREAM）

和数据报式套接字（SOCK_DGRAM）和原始套接字。流式套接字 

基于TCP协议，数据报式套接字基于UDP协议实现  .

　　网络编程，当然要用到Windows Socket(套接字)技术。

Socket相关的操作由一系列API函数来完成，比如socket、

bind、listen、connect、accept、send、sendto、recv、

recvfrom等。调用这些API函数有一定的先后次序，有些

函数的参数还比较复杂，对于开发者来说，不是很好用。

于是，微软的MFC提供了两个类：CAsyncSocket和CSocket，

极大地方便了Socket功能的使用。　

　CAsyncSocket类在较低层次上封装了Windows Socket API，

并且通过内建一个(隐藏的)窗口，实现了适合Windows应用的

异步机制(Windows Socket API默认情况下工作在阻塞模式，

不方便直接在消息驱动的Windows程序上使用)。CSocket类从

CAsyncSocket类派生，进一步简化了Socket功能的应用。

不过很遗憾，正因为这两个类都内建了一个窗口，它们并不

是线程安全的(thread-safe)；如果要在多线程环境下应用

Socket功能，建议自行封装Socket API函数。

基于TCP的socket编程的服务器端程序流程如下：
1、创建套接字
2、将套接字绑定到一个本地地址和端口号上（bind）
3、将套接字设为监听模式，准备接受客户请求（listen）
4、等待客户请求，请求到来时接受请求，建立链接，并返回 一

个新的基于此次通信的套接字（accept）
5、用返回的套接字和客户端进行通信（send、recv）
6、返回，等待另一客户请求
7、关闭套接字
基于TCP的socket编程的客户端程序流程如下：
1、创建套接字
2、向服务器端发送请求（connect）
3、和服务器端进行通信（send、recv）
4、关闭套接字

基于UDP的socket编程的服务器端程序流程如下：
1、创建套接字
2、将套接字绑定到本地地址和端口号上（bind）
3、等待接收数据（recvfrom）
4、关闭套接字
基于UDP的socket编程的客户端程序流程如下：
1、创建套接字
2、和服务器端进行通信（sendto）
3、关闭套接字

异步方式指的是发送方不等接收方响应，便接着发下个数据包

的通信方式；而同步指发送方发出数据后，等收到接收方发回

的响应，才发下一个数据包的通信方式。
　　阻塞套接字是指执行此套接字的网络调用时，直到成功才返回，

否则一直阻塞在此网络调用上，比如调用recv()函数读取网络缓冲区

中的数据，如果没有数据到达，将一直挂在recv()这个函数调用上，

直到读到一些数据，此函数调用才返回；而非阻塞套接字是指执行

此套接字的网络调用时，不管是否执行成功，都立即返回。比如

调用recv()函数读取网络缓冲区中数据，不管是否读到数据都立即

返回，而不会一直挂在此函数调用上。在实际Windows网络通信软件

开发中，异步非阻塞套接字是用的最多的。平常所说的C/S

（客户端/服务器）结构的软件就是异步非阻塞模式的。
　　对于这些概念，初学者的理解也许只能似是而非，我将用一个

最简单的例子说明异步非阻塞Socket的基本原理和工作机制。

目的是让初学者不仅对Socket异步非阻塞的概念有个非常透彻

的理解，而且也给他们提供一个用Socket开发网络通信应用程序

的快速入门方法。操作系统是Windows 98（或NT4.0），开发工

具是Visual C++6.0。
　　MFC提供了一个异步类CAsyncSocket，它封装了异步、非阻塞

Socket的基本功能，用它做常用的网络通信软件很方便。

但它屏蔽了Socket的异步、非阻塞等概念，开发人员无需了

解异步、非阻塞Socket的原理和工作机制。因此，建议初学

者学习编网络通信程序时，暂且不要用MFC提供的类，而先用 

Winsock2     API，这样有助于对异步、非阻塞Socket编程

机制的理解。
　　为了简单起见，服务器端和客户端的应用程序均是基于MFC的

标准对话框，网络通信部分基于Winsock2 API实现。
　　先做服务器端应用程序。
　　用MFC向导做一个基于对话框的应用程序SocketSever，

注意第三步中不要选上Windwos Sockets选项。在做好工程后，

创建一个SeverSock，将它设置为异步非阻塞模式，并为它注册各

种网络异步事件，然后与自定义的网络异步事件联系上，最后

还要将它设置为监听模式。在自定义的网络异步事件的回调函数中，

你可以得到各种网络异步事件，根据它们的类型，做不同的处理。

下面将详细介绍如何编写相关代码。
　　在SocketSeverDlg.h文件的类定义之前增加如下定义：
#define     NETWORK_EVENT     WM_USER+166     file://定义网络事件
  
SOCKET ServerSock; file://服务器端Socket
在类定义中增加如下定义：
class CSocketSeverDlg : CDialog
{
public:
       SOCKET ClientSock[CLNT_MAX_NUM]; file://存储与

客户端通信的Socket的数组

       /*各种网络异步事件的处理函数*/
       void OnClose(SOCKET CurSock);      file://对端Socket断开
       void OnSend(SOCKET CurSock);      file://发送网络数据包
       void OnReceive(SOCKET CurSock); file://网络数据包到达
       void OnAccept(SOCKET CurSock);     file://客户端连接请求

       BOOL InitNetwork();     file://初始化网络函数
       void OnNetEvent(WPARAM wParam, LPARAM lParam); file:

//异步事件回调函数
                   …
};
       
在SocketSeverDlg.cpp文件中增加消息映射，其中OnNetEvent是

异步事件回调函数名：
       ON_MESSAGE(NETWORK_EVENT,OnNetEvent)
定义初始化网络函数，在SocketSeverDlg.cpp文件的OnInitDialog

（）中调此函数即可。
BOOL CSocketSeverDlg::InitNetwork()
{
       WSADATA wsaData;

       //初始化TCP协议
       BOOL ret = WSAStartup(MAKEWORD(2,2), &wsaData);
       if(ret != 0)
       {
           MessageBox('初始化网络协议失败!');
           return FALSE;
       }

       //创建服务器端套接字
       ServerSock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
       if(ServerSock == INVALID_SOCKET)
       {
           MessageBox('创建套接字失败!');
           closesocket(ServerSock);
           WSACleanup();
           return FALSE;
       }

       //绑定到本地一个端口上
       sockaddr_in localaddr;
       localaddr.sin_family = AF_INET;
       localaddr.sin_port = htons(8888);     //端口号不要与其他应用程序冲突
       localaddr.sin_addr.s_addr = 0;
       if(bind(ServerSock ,(struct sockaddr*)&localaddr,sizeof(sockaddr))
                                             = = SOCKET_ERROR)
       {
           MessageBox('绑定地址失败!');
           closesocket(ServerSock);
           WSACleanup();
           return FALSE;
       }
       //将SeverSock设置为异步非阻塞模式，并为它注册各种网络异步事件，其中m_hWnd     
       //为应用程序的主对话框或主窗口的句柄
       if(WSAAsyncSelect(ServerSock, m_hWnd, NETWORK

_EVENT, FD_ACCEPT | FD_CLOSE | FD_READ | FD_

WRITE) == SOCKET_ERROR)
       {
           MessageBox('注册网络异步事件失败!');
           WSACleanup();
           return FALSE;
       }
       listen(ServerSock, 5); file://设置侦听模式
       return TRUE;
}

下面定义网络异步事件的回调函数
void CSocketSeverDlg::OnNetEvent(WPARAM wParam, 

LPARAM lParam)
{
       //调用Winsock API函数，得到网络事件类型
       int iEvent = WSAGETSELECTEVENT(lParam);
       //调用Winsock API函数，得到发生此事件的客户端套接字
       SOCKET CurSock= (SOCKET)wParam;

       switch(iEvent)
       {
           case FD_ACCEPT:         //客户端连接请求事件
               OnAccept(CurSock);
               break;
           case FD_CLOSE:          //客户端断开事件:
               OnClose(CurSock);
               break;
           case FD_READ:           //网络数据包到达事件
               OnReceive(CurSock);
               break;
            case FD_WRITE:         //发送网络数据事件
               OnSend(CurSock);
               break;
            default: break;
        }
}
  
　　以下是发生在相应Socket上的各种网络异步事件的处理函数，

其中OnAccept传进来的参数是服务器端创建的套接字，OnClose()、

OnReceive()和OnSend()传进来的参数均是服务器端在接受

客户端连接时新创建的用与此客户端通信的Socket。
void CSocketSeverDlg::OnAccept(SOCKET CurSock)
{
       //接受连接请求，并保存与发起连接请求的客户端进行通信Socket
       //为新的socket注册异步事件，注意没有Accept事件
}
void CSocketSeverDlg::OnClose(SOCET CurSock)
{
       //结束与相应的客户端的通信，释放相应资源
}

void CSocketSeverDlg::OnSend(SOCET CurSock)
{
       //在给客户端发数据时做相关预处理
}

void CSocketSeverDlg::OnReceive(SOCET CurSock)
{
       //读出网络缓冲区中的数据包
}      
      
　　用同样的方法建立一个客户端应用程序。初始化网络部分，不需要将套接字设置为监听模式。注册异步事件时，没有FD_ACCEPT，但增加了FD_CONNECT事件，因此没有OnAccept()函数，但增加了OnConnect()函数。向服务器发出连接请求时，使用connect()函数，连接成功后，会响应到OnConnect()函数中。下面是OnConnect()函数的定义，传进来的参数是客户端Socket和服务器端发回来的连接是否成功的标志。
void CSocketClntDlg::OnConnect(SOCKET CurSock, int error)
{
       if(0 = = error)
       {
           if(CurSock = = ClntSock)
           MessageBox('连接服务器成功!');
       }
}
　　定义OnReceive()函数，处理网络数据到达事件;
　　定义OnSend()函数，处理发送网络数据事件;
　　定义OnClose()函数，处理服务器的关闭事件。
           
　　以上就是用基于Windows消息机制的异步I/O模型做服务器和

客户端应用程序的基本方法。另外还可以用事件模型、重叠

模型或完成端口模型，读者可以参考有关书籍。
　　在实现了上面的例子后，你将对Winsock编网络通信程序的

机制有了一定的了解。接下来你可以进行更精彩的编程, 不仅

可以在网上传输普通数据，而且还以传输语音、视频数据，你还

可以自己做一个网络资源共享的服务器软件，和你的同学

在实验室的局域网里可以共同分享你的成果。

同步服务器套接字挂起应用程序的执行，直到套接字上接收到

连接请求。同步服务器套接字不适用于在操作中大量使用网络

的应用程序，但它们可能适用于简单的网络应用程序。使用 

 Bind 和 Listen 方法设置 Socket 以在终结点上侦听之后，Socket 

 就可以随时使用 Accept 方法接受传入的连接请求了。应用程序

被挂起，直到调用 Accept 方法时接收到连接请求。

接收到连接请求时，Accept 返回一个与连接客户端关联的新 

 Socket 实例。下面的示例读取客户端数据，在控制台上显示

该数据，然后将该数据回显到客户端。Socket 不指定任何

消息协议，因此字符串“<EOF>”标记消息数据的结尾。

它假定一个名为 listener 的 Socket 已初始化，并绑

定到一个终结点。

Console.WriteLine("Waiting for a connection...");
Socket handler = listener.Accept();
String data = null;

while (true) {
     bytes = new byte[1024];
     int bytesRec = handler.Receive(bytes);
     data += Encoding.ASCII.GetString(bytes,0,bytesRec);
     if (data.IndexOf("<EOF>") > -1) {
         break;
     }
}

Console.WriteLine( "Text received : {0}", data);

byte[] msg = Encoding.ASCII.GetBytes(data);
handler.Send(msg);
handler.Shutdown(SocketShutdown.Both);
handler.Close();

CAsyncSocket网络编程(MFC)

     随着计算机网络化的深入，计算机网络编程在程序设计的过程中

变得日益重要。由于C++语言对底层操作的优越性，许多文章都曾经

介绍过用VC++进行Socket编程的方法。但由于都是直接利用动态连

接库wsock32.dll进行操作，实现比较繁琐。其实，VC++的MFC类

库中提供了CAsyncSocket这样一个套接字类，用他来实现Socket编程，

是非常方便的。

---- 本文将用一个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_MSGIDC_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 MemberIDC_Addr
CString m_AddrIDC_Port Int m_Port

---- 8． 在CSockClientDlg.ccp中添加代码 #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; //默认端口1088m_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>10SetTimer(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() { 
//关闭Socketm_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端那样，

对所有的连接进行读写控制。

----三． 总结

----CAsyncSocket类为我们使用Socket提供了极大方便。

建立Socket的WSAStartup过程和bind过程被简化成为Create过程，

IP地址类型转换、主机名和IP地址转换的过程中许多复杂的变量类型

都被简化成字符串和整数操作，特别是CAsyncSocket类的异步特点，

完全可以替代繁琐的线程操作。MFC提供了大量的类库，

我们若能灵活的使用他们，便会大大提高编程的效率

MFC下的网络编程

Visual C++的MFC提供了CSocket类用来实现网络通信。

下图给出了CSocket 类的继承关系。


　　下面介绍VC++在Windows 95中实现Socket的 CSocket 类相

关成员函数(这些成员函数实际上是从CAsyncSocket 类继承来的)的使用。 

（1） BOOL Create( UINT nSocketPort = 0, int nSocketType = 

 SOCK_STREAM, long lEvent = FD_READ |FD_WRITE|FD_

OOB|FD_ACCEPT|FD_CONNECT| FD_CLOSE，

LPCTSTR lpszSocketAddress = NULL ) 
　　该函数用来建立Socket。 其中，nSocketPort 为所选择的Socket 端口，
一般要大于 1023， 如果该参数为0，则由系统选定一端口，默认值为0 ；
nSocketType 为套接字类型：SOCK_STREAM 表示为流套接字，
SOCK_DGRAM 表示为数据报套接字，默认值为SOCK_STREAM ；
lEvent 标识该Socket 要完成哪种工作，默认值为FD_READ|FD_
WRITE|FD_OOB| FD_ACCEPT|FD_CONNECT|FD_CLOSE ；
lpszSockAddress 为网络地址信息结构指针，包含网络地址， 默认值为NULL 。 

（2）BOOL Bind( UINT nSocketPort, LPCTSTR lpszSocketAddress = NULL ) 
　　该函数的作用是将Socket 端口与网络地址连接起来。参数含义同上 。 
（3）BOOL Listen( int nConnectionBacklog = 5 ) 
　　该函数的作用是等待Socket请求。其中，nConnec-tionBacklog

表示等待队列的长度，默认值为最大值5 。 

（4）virtual BOOL Accept( CAsyncSocket＆ rConnectedSocket,

SOCKADDR* lpSockAddr = NULL, int* lpSockAddrLen = NULL ) 
　　该函数的作用是取得队列上第一个连接请求并建立一个具有

与Socket相同特性的套接字。其中，rConnectedSocket 表示一

个新的Socket 。 

（5）BOOL Connect( LPCTSTR lpszHostAddress, UINT nHostPort ) 
　　该函数的作用是提出请求。其中，lpszHostAddress 和 nHostPort 

为接受请求进程的网络地址和Socket 端口号。 

（6）virtual void Close( ) 
　　该函数的作用是关闭该Socket 。 

　　利用CSocket类直接进行数据通信有两种方式：一种是利用

CSocketFile 类和Archive 类去实现，另一种是利用CSocket的成员

函数 Receive、Send、ReceiveFrom、SendTo、Listen 和 Accept

等来实现（这些成员函

数实际上也是从CAsyncSocket 类继承的）。 
　　两种方法的实现步骤如下 ： 

　　Server : Construct－> Creat－> Bind －> Listen－> 

 Accept－> Send－>Close ； 

　　Cilent : Construct －>Creat－> Connect－> Receive－> Close。 

　　 下面就用VC++的代码分别介绍如何运用上述两种

方法来实现Socket 编程。 

　　1、 利用CSocketFile类和Archive 类实现

　　（1）服务器程序流程
　　// 创建一个套接字对象
　　CSocket sockSrvr; 

　　//为上述套接字对象创建一个套接字

　　sockSrvr.Create(nPort); 

　　//开始侦听
　　sockSrvr.Listen( ); 

　　//创建一个新的套接字对象
　　CSocket sockRecv; 

　　//接受连接
　　sockSrvr.Accept( sockRecv ); 

// 创建文件对象
CSocketFile file(&sockRecv); 

　　//创建一个archive对象
　　CArchive arIn(&file, CArchive::load); 

　　/*or*/_CArchive arOut(&file, CArchive::store); 

　　//使用archive对象传输数据
　　arIn >> dwValue; 

　　/*or*/ arOut < < dwValue; 

　　（2）客户端程序流程
　　//创建一个套接字对象
　　CSocket sockClient; 

　　//为这个对象创建一个套接字
　　sockClient.Create( ); 

　　//寻找一个连接
　　sockClient.Connect(strAddr, nPort); 

　　//创建一个文件对象
　　CSocketFile file(&sockClient); 

　　//创建一个archive对象
　　CArchive arIn(&file, CArchive::load); 

　　/*or*/_CArchive arOut(&file, CArchive::store); 

　　//使用这个对象传输数据
　　arOut < < dwValue; 

　　/*or*/ arIn >> dwValue; 

　　上述程序中， nPort 是Socket 的端口号，strAddr 是该

机器的IP地址（如202.197.1.3 或FTP://RedAlert.com等），这两个

变量在Server和Client中要一致。当Server进程运行至Listen 后便

处于睡眠状态直到Client进程执行Connect 时才被唤醒，而后两

个进程便开始传输数据了。 

　　2、利用CSocket的成员函数实现 
　　（1）服务器流程
　　//套接字初始化
　　if(!AfxSocketInit()){ 
　　 MessageBox("WindowsSocket initial failed!","Send",MB_ICONSTOP); 
　　 Return; 
　　}

　　// 创建两个套接字对象
　　CSocket ChatSend,server; 

　　// 创建一个套接字
　　if(!ChatSend.Create(nPort)) // nPort=1025 
　　 MessageBox("SendSocket create failed!", "Send",MB_ICONSTOP); 
　　else{ 
　　 // 把本地地址给套接字
ChatSend.Bind(nProt,strAddr); 
　　// strAddr="202.196.111.1" 
　　 // 开始侦听
　　 ChatSend.Listen(); 

　　 // 创建一个新的套接字并和他相连
　　 ChatSend.Accept(Server); 
　　}
　　//发送一个CString 对象
　　Server.SendTo(csSendText,csCounts,nPort,strAddr); 

　　// 关闭这两个套接字
　　Server.Close(); 
　　ChatSend.Close(); 

　　（2）客户端程序流程

　　// 套接字初始化
　　if(!AfxSocketInit()){ 
　　 MessageBox("WindowsSocket initial failed!", "Receive",MB_ICONSTOP); 
　　 return; 
　　}

　　// 创建一个套接字对象
　　CSocket ChatRecieve; 

　　// 创建一个套接字
　　if(!ChatReceive.Create()){ 
　　 MessageBox("ReceiveSocket create failed!","Receive",MB_ICONSTOP); 
　　 return; 
　　}
　　else{ 
　　 // 创建一个对等套接字
　　 ChatReceive.Connect(strAddr,nPort); 
　　}

　　//接受一个CString 对象
　　ChatReceive.ReceiveFrom(csReceiveText,csCounts,strAddr,nPort); 

　　// 关闭套接字
　　ChatReceive.Close(); 

　　上述两个进程完成的工作是：由Server 进程发送一字符串，

Client 进程

接收。 strAddr 和 nPort 的含义与方法1 中的相同 ；csSendText 和 

 csReceiveText 为发送与接收的字符串；csCounts为字串长度，

这一长度

在两个进程中要求接收长度小于或等于发送长度，否则会

导致数据传输错误。另外，在程序中要加入头文件afxsock.h，

 CSocket 类

的有关说明均在afxsock.h 中。

方法1 适合于对多个不同类型数据的通信，方法2 适合于对字符串

的通信，具体选用何种方法则取决于具体应用的需求。

&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&