csocket編程教程
㈠ mfc socket 編程的流程是怎麼樣的
初始化socket
首先需要調用AfxSocketInit()函數來初始化我們的socket環境。
為了初始化sockets，我們需要調用AfxSocketInit()函數。它通常是在MFC中的InitInstance()函數中被調用的。如果我們用程序向導來創建socket程序的話，查看「use Windows Sockets」這個選項，然後選中它。它將會自動的為我們創建這個步驟了。（如果我們沒有選中這個選項的話，我們也可以手動添加這些代碼的。）這個函數的返回值顯示這個函數的調用成功或失敗。
BOOL CServerApp::InitInstance()
{....
if( AfxSocketInit() == FALSE)
{
AfxMessageBox("Sockets Could Not Be Initialized");
return FALSE;
}
...
}
創建Server Sockets
為了創建一個Server Socket，我們需要聲明一個CAyncSocket的變數或者我們自己定製的一個從AyncSocket或是Cscket繼承來的類的類型的變數。然後調用Create()函數，同時指定監聽的埠。這個函數的返回值顯示這個函數的調用成功或失敗。
UpdateData(TRUE);
m_sListener.Create(m_port);
if(m_sListener.Listen()==FALSE)
{
AfxMessageBox("Unable to Listen on that port,please try another port");
m_sListener.Close();
return;
}
創建Client Sockets
為了創建Client socket類，我們需要聲明一個CAyncSocket的變數或者我們自己定製的一個從AyncSocket或是Cscket繼承來的類的類型的變數。然後調用Create()函數，同時指定監聽的埠。這個函數的返回值顯示這個函數的調用成功或失敗。
m_sConnected.Create();
m_sConnected.Connect("server ip",port);
監聽客戶端的連接
創建了server socket以後，我們要進行監聽。調用Listen()函數。這個函數的返回值顯示這個函數的調用成功或失敗。
if( m_sListener.Listen()== FALSE)
{
AfxMessageBox("Unable to Listen on that port,please try another port");
m_sListener.Close();
return;
}
接受連接
連接請求要被接受accept，是用另外的socket，不是正在監聽的socket。請參看代碼。
void CXXXDlg::OnAccept()
{
CString strIP;
UINT port;
if(m_sListener.Accept(m_sConnected))
{
m_sConnected.GetSockName(strIP,port); //應該是GetPeerName，獲取對方的IP和port
m_status="Client Connected,IP :"+ strIP;
m_sConnected.Send("Connected To Server",strlen("Connected To Server"));
UpdateData(FALSE);
}
else
{
AfxMessageBox("Cannoot Accept Connection");
}
}
發送數據
數據放在一個buffer中或是結構體中，調用send()函數發送。
m_sConnected.Send(pBuf,iLen);
接受數據
調用receive()接受數據。
void CXXXrDlg::OnReceive()
{
char *pBuf =new char [1025];
CString strData;
int iLen;
iLen=m_sConnected.Receive(pBuf,1024);
if(iLen == SOCKET_ERROR)
{
AfxMessageBox("Could not Recieve");
}
else
{
pBuf[iLen]=NULL;
strData=pBuf;
m_recieveddata.Insert(m_recieveddata.GetLength(),strData);
//display in server
UpdateData(FALSE);
m_sConnected.Send(pBuf,iLen); //send the data back to the Client
delete pBuf;
}
}
關閉連接
m_sConnected.ShutDown(0); 停止發送數據
m_sConnected.ShutDown(1); 停止接受數據
m_sConnected.ShutDown(2); 停止發送接受數據
m_sConnected.Close();
編寫自己的socket類
在class view中選擇添加一個新類，設置它的基類為CAsyncSocket，在類向導的幫助下添加如下的一些函數。
class MySocket : public CAsyncSocket
{ // Attributes
public:
// Operations
public:
MySocket();
virtual ~MySocket();
// Overrides
public:
void SetParentDlg(CDialog *pDlg);// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(MySocket)
public:
virtual void OnAccept(int nErrorCode);
virtual void OnClose(int nErrorCode);
virtual void OnConnect(int nErrorCode);
virtual void OnOutOfBandData(int nErrorCode);
virtual void OnReceive(int nErrorCode);
virtual void OnSend(int nErrorCode);
//}}AFX_VIRTUAL // Generated message map functions
//{{AFX_MSG(MySocket)
// NOTE - the ClassWizard will add and remove member functions here. //}}AFX_MSG
protected:
private:
CDialog * m_pDlg;
};
設置「Parent Dialog」
調用這個socket類的SetParentDlg函數，保證當socket事件發生的時候這個窗體能接收到。
m_sListener.SetParentDlg(this);
m_sConnected.SetParentDlg(this);
建立Socket 事件和窗體成員函數之間的聯系
在這個窗體類中添加一些函數，比如void OnReceive(); void OnClose(); void OnAccept(); void OnConnect()等，它們會在我們編寫的的socket類中調用到。
void MySocket::OnAccept(int nErrorCode)
{
// TODO: Add your specialized code here and/or call the base class
if(nErrorCode==0)
{
((CServerDlg*)m_pDlg)->OnAccept();
}
CAsyncSocket::OnAccept(nErrorCode);
}
㈡ UDP和Socket通信步驟
這是在網上找到的，希望對你有所幫助。
sockets（套接字）編程有三種，流式套接字（SOCK_STREAM），數據報套接字（SOCK_DGRAM），原始套接字（SOCK_RAW）；
WINDOWS環境下TCP/UDP編程步驟：
1. 基於TCP的socket編程是採用的流式套接字。
在這個程序中，將兩個工程添加到一個工作區。要鏈接一個ws2_32.lib的庫文件。
伺服器端編程的步驟：
1：載入套接字型檔，創建套接字(WSAStartup()/socket())；
2：綁定套接字到一個IP地址和一個埠上(bind())；
3：將套接字設置為監聽模式等待連接請求(listen())；
4：請求到來後，接受連接請求，返回一個新的對應於此次連接的套接字(accept())；
5：用返回的套接字和客戶端進行通信(send()/recv())；
6：返回，等待另一連接請求；
7：關閉套接字，關閉載入的套接字型檔(closesocket()/WSACleanup())。
伺服器端代碼如下：
#include <stdio.h>
#include <Winsock2.h>
void main()
{
WORD wVersionRequested;
WSADATA wsaData;
int err;
wVersionRequested = MAKEWORD( 1, 1 );
err = WSAStartup( wVersionRequested, &wsaData );
if ( err != 0 ) {
return;
}
if ( LOBYTE( wsaData.wVersion ) != 1 ||
HIBYTE( wsaData.wVersion ) != 1 ) {
WSACleanup( );
return;
}
SOCKET sockSrv=socket(AF_INET,SOCK_STREAM,0);
SOCKADDR_IN addrSrv;
addrSrv.sin_addr.S_un.S_addr=htonl(INADDR_ANY);
addrSrv.sin_family=AF_INET;
addrSrv.sin_port=htons(6000);
bind(sockSrv,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));
listen(sockSrv,5);
SOCKADDR_IN addrClient;
int len=sizeof(SOCKADDR);
while(1)
{
SOCKET sockConn=accept(sockSrv,(SOCKADDR*)&addrClient,&len);
char sendBuf[50];
sprintf(sendBuf,"Welcome %s to here!",inet_ntoa(addrClient.sin_addr));
send(sockConn,sendBuf,strlen(sendBuf)+1,0);
char recvBuf[50];
recv(sockConn,recvBuf,50,0);
printf("%s\n",recvBuf);
closesocket(sockConn);
}
}
客戶端編程的步驟：
1：載入套接字型檔，創建套接字(WSAStartup()/socket())；
2：向伺服器發出連接請求(connect())；
3：和伺服器端進行通信(send()/recv())；
4：關閉套接字，關閉載入的套接字型檔(closesocket()/WSACleanup())。
客戶端的代碼如下：
#include <stdio.h>
#include <Winsock2.h>
void main()
{
WORD wVersionRequested;
WSADATA wsaData;
int err;
wVersionRequested = MAKEWORD( 1, 1 );
err = WSAStartup( wVersionRequested, &wsaData );
if ( err != 0 ) {
return;
}
if ( LOBYTE( wsaData.wVersion ) != 1 ||
HIBYTE( wsaData.wVersion ) != 1 ) {
WSACleanup( );
return;
}
SOCKET sockClient=socket(AF_INET,SOCK_STREAM,0);
SOCKADDR_IN addrSrv;
addrSrv.sin_addr.S_un.S_addr=inet_addr("127.0.0.1");
addrSrv.sin_family=AF_INET;
addrSrv.sin_port=htons(6000);
connect(sockClient,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));
char recvBuf[50];
recv(sockClient,recvBuf,50,0);
printf("%s\n",recvBuf);
send(sockClient,"hello",strlen("hello")+1,0);
closesocket(sockClient);
WSACleanup();
}
2.基於UDP的socket編程是採用的數據報套接字。
在這個程序中，將兩個工程添加到一個工作區。同時還要鏈接一個ws2_32.lib的庫文件。
伺服器端編程的步驟：
1：載入套接字型檔，創建套接字(WSAStartup()/socket())；
2：綁定套接字到一個IP地址和一個埠上(bind())；
3：等待和接收數據(sendto()/recvfrom())；
4：關閉套接字，關閉載入的套接字型檔(closesocket()/WSACleanup())。
伺服器端代碼如下：
#include <winsock2.h>
#include <stdio.h>
void main()
{
WORD wVersionRequested;
WSADATA wsaData;
int err;
wVersionRequested = MAKEWORD( 1, 1 );
err = WSAStartup( wVersionRequested, &wsaData );
if ( err != 0 )
{
return;
}
if ( LOBYTE( wsaData.wVersion ) != 1 ||
HIBYTE( wsaData.wVersion ) != 1 )
{
WSACleanup( );
return;
}
SOCKET sockSrv=socket(AF_INET,SOCK_DGRAM,0);
SOCKADDR_IN addrSrv;
addrSrv.sin_addr.S_un.S_addr=htonl(INADDR_ANY);
addrSrv.sin_family=AF_INET;
addrSrv.sin_port=htons(7003);
bind(sockSrv,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));
char recvBuf[50];
SOCKADDR addrClient;
int len=sizeof(SOCKADDR);
recvfrom(sockSrv,recvBuf,50,0,(SOCKADDR*)&addrClient,&len);
printf("%s\n",recvBuf);
closesocket(sockSrv);
WSACleanup();
}
對於基於UDP的socket客戶端來說，要進行如下步驟：
1：創建一個套接字(socket)；
2：向伺服器發送數據(sendto);
3：關閉套接字；
代碼如下：
#include <winsock2.h>
#include <stdio.h>
void main()
{
WORD wVersionRequested;
WSADATA wsaData;
int err;
wVersionRequested = MAKEWORD( 2, 2 );
err = WSAStartup( wVersionRequested, &wsaData );
if ( err != 0 ) {
return;
}
if ( LOBYTE( wsaData.wVersion ) != 2 ||
HIBYTE( wsaData.wVersion ) != 2 ) {
WSACleanup( );
return;
}
SOCKET sockClient=socket(AF_INET,SOCK_DGRAM,0);
SOCKADDR_IN addrClient;
addrClient.sin_addr.S_un.S_addr=inet_addr("127.0.0.1");
addrClient.sin_family=AF_INET;
addrClient.sin_port=htons(8889);
SOCKADDR_IN addrSrv;
sendto(sockClient,"hi",3,0,(SOCKADDR*)&addrClient,sizeof(SOCKADDR));
}
LINUX環境下TCP/UDP編程步驟：
TCP編程步驟：
一. 服務端：
1.socket(int domain,int type,int protocol):建立套接字；
2 .bind(int sockid,struct sockaddr *addrp,socklen_t addrlen):把本機地址和埠跟上一步建立的socket綁定在一起；
3.listen(int sockid,int qsize):監聽某套接字;
4.fd=accept(int sockid,struct sockaddr *callerid,socklen_t *addrlenp):等待某套接字接收信息；
5.recv(int fd,void *buf,size_t nbytes,int flags):從套接字接收數據;
6.close(fd) 和close(sockid)
二.客戶端：
1. socket():建立套接字；
2.connect(int sockid,struct sockaddr *serv_addrp,socklen_t addrlen):連接到伺服器；
3. send(int sockfd,const void *buf,size_t nbytes,int flags):發送數據到伺服器.
4. close(sockid);
UDP編程步驟：
一，服務端：
1. socket():同上；
2. bind():同上；
3. recvfrom(int sockfd,void*buff,size_t nbytes,int flags,struct sockaddr*from,socklen_t*addrlen):在套接字口接收數據，並且記錄下接收到的數據來源;一定要注意這里的參數addrlen，它不僅是函數的輸出，也是函數的輸入！所以要在調用該函數之前對addrlen賦值sizeof(struct sockaddr)。否則返回的地址from將會出錯！
4. close(sockfd);
二. 客戶端：
1. socket();同上；
2. sendto(int sockfd,const void*buff,size_t nbytes,int flags,const struct sockaddr*to,socklen_t addrlen):往指定的地址發送數據；
3. close(sockfd);
㈢ 在C#中利用Socket進行網路通信編程的一般步驟是
1.創建socket
2.確定本地計算機端點（ip和埠號）
3.socket綁定端點
4.socket.receive(); 接收數據
5.socket.send();發送數據
6.socket.close();關閉socket
㈣ c# socket編程
private void button2_Click(object sender, EventArgs e)
if (s.Connected == true)
try
string abc = textBox3.Text;
s.Send(Encoding.ASCII.GetBytes(abc));
MesageBox.Show("向伺服器發送:" + abc);
catcMessageBox.Show("發送失敗");
接收：
System.Timers.Timer aTimer = new System.Timers.Timer();
byte[] res = new byte[1024];
private void Form1_Load(object sender, EventArgs e)
{
Control.CheckForIll
aTimer.Elapsed += new ElapsedEventHandler(socket_rev); //定時事件的方法
aimer.Interval = 100;
private void socket_rev(object sender, EventArgs e)
int receiveLength = s.Receive(res, res.Length, SocketFlags.None);
if (receiveLength > 0)
textBox4.Text = Encoding.ASCII.GetString(res, 0, receiveLength);
string abc = "HaveReceive";
s.Send(Encoding.ASCII.GetBytes(abc));
(4)csocket編程教程擴展閱讀：C#Socket非同步通訊學習
思路
1、Socket分為面向連接協議(如TCP)和無連接協議(如UDP)
2、Socket通信分為同步操作模式和非同步操作模式，同步模式在建立連接之前/收到消息之前會阻塞當前進程，非同步模式不會阻塞當前進程
綜合以上兩點，考慮到體驗，當然是選擇非同步Socket啦，另外，這里使用的是面向連接的協議，那麼實現思路大致如下：
1、創建Socket對象
2、綁定IP和埠
3、偵聽連接
4、開始一個非同步操作來接收一個接入的連接請求
5、處理接入的請求
6、向客戶端發送消息
㈤ socket非阻塞方式下的Linux c++編程步驟是怎樣的
Windows用以下方法將socket設置為非阻塞方式 ：
unsigned long ul=1;
SOCKET s=socket(AF_INET,SOCK_STREAM,0);
int ret=ioctlsocket(s, FIONBIO, (unsigned long *)&ul);//設置成非阻塞模式。
if(ret==SOCKET_ERROR)//設置失敗。
{
}
Linux用以下方法將socket設置為非阻塞方式
int flags = fcntl(socket, F_GETFL, 0);
fcntl(socket, F_SETFL, flags | O_NONBLOCK);
用以下方法將socket設置為非阻塞方式
int flags = fcntl(socket, F_GETFL, 0);
fcntl(socket, F_SETFL, flags | O_NONBLOCK);
將非阻塞的設置回阻塞可以用
int flags = fcntl(socket, F_GETFL, 0);
fcntl(socket, F_SETFL, flags & ~O_NONBLOCK);
功能描述：根據文件描述詞來操作文件的特性。
用法：
int fcntl(int fd, int cmd);
int fcntl(int fd, int cmd, long arg);
int fcntl(int fd, int cmd, struct flock *lock);
參數：
fd：文件描述詞。
cmd：操作命令。
arg：供命令使用的參數。
lock：同上。
有以下操作命令可供使用
一. F_DUPFD ：復制文件描述詞 。
二. FD_CLOEXEC ：設置close-on-exec標志。如果FD_CLOEXEC位是0，執行execve的過程中，文件保持打開。反之則關閉。
三. F_GETFD ：讀取文件描述詞標志。
四. F_SETFD ：設置文件描述詞標志。
五. F_GETFL ：讀取文件狀態標志。
六. F_SETFL ：設置文件狀態標志。
其中O_RDONLY， O_WRONLY， O_RDWR， O_CREAT， O_EXCL， O_NOCTTY 和 O_TRUNC不受影響，
可以更改的標志有 O_APPEND，O_ASYNC， O_DIRECT， O_NOATIME 和 O_NONBLOCK。
七. F_GETLK, F_SETLK 和 F_SETLKW ：獲取，釋放或測試記錄鎖，使用到的參數是以下結構體指針：
F_SETLK：在指定的位元組范圍獲取鎖(F_RDLCK, F_WRLCK)或者釋放鎖(F_UNLCK)。如果與另一個進程的鎖操作發生沖突，返回 -1並將errno設置為EACCES或EAGAIN。
F_SETLKW：行為如同F_SETLK，除了不能獲取鎖時會睡眠等待外。如果在等待的過程中接收到信號，會立即返回並將errno置為EINTR。
F_GETLK：獲取文件鎖信息。
F_UNLCK：釋放文件鎖。
為了設置讀鎖，文件必須以讀的方式打開。為了設置寫鎖，文件必須以寫的方式打開。為了設置讀寫鎖，文件必須以讀寫的方式打開。
㈥ CSocket之UDP編程
#include <stdio.h>
#include <Winsock2.h>
#pragma comment(lib,"ws2_32.lib")
void main()
{
WORD wVersionRequested;
WSADATA wsaData;
int err;
wVersionRequested = MAKEWORD( 1, 1);
err = WSAStartup( wVersionRequested, &wsaData );
if ( err != 0 )
{
return;
}
if ( LOBYTE( wsaData.wVersion ) != 1 ||
HIBYTE( wsaData.wVersion ) != 1 )
{
WSACleanup( );
return;
}
SOCKET sersocket=socket(AF_INET,SOCK_DGRAM,0);
SOCKADDR_IN seraddr;
seraddr.sin_addr.S_un.S_addr=htonl(INADDR_ANY);
seraddr.sin_family=AF_INET;
seraddr.sin_port=htons(5000);
bind(sersocket,(SOCKADDR*)&seraddr,sizeof(SOCKADDR));
SOCKADDR clientaddr;
int len=sizeof(SOCKADDR);
char revbuf[100];
char sendbuf[100];
recvfrom(sersocket,revbuf,100,0,(SOCKADDR*)&clientaddr,&len);
printf("%s\n",revbuf);
scanf("%s",&sendbuf);
sendto(sersocket,sendbuf,strlen(sendbuf)+1,0,(SOCKADDR*)&clientaddr,len);
closesocket(sersocket);
WSACleanup();
}
#include <stdio.h>
#include <Winsock2.h>
#pragma comment(lib,"ws2_32.lib")
void main()
{
WORD wVersionRequested;
WSADATA wsaData;
int err;
wVersionRequested = MAKEWORD( 1, 1);
err = WSAStartup( wVersionRequested, &wsaData );
if ( err != 0 )
{
return;
}
if ( LOBYTE( wsaData.wVersion ) != 1 ||
HIBYTE( wsaData.wVersion ) != 1 )
{
WSACleanup( );
return;
}
SOCKET sockclient=socket(AF_INET,SOCK_DGRAM,0);
SOCKADDR_IN clientaddr;
clientaddr.sin_addr.S_un.S_addr=inet_addr("127.0.0.1");
clientaddr.sin_family=AF_INET;
clientaddr.sin_port=htons(5000);
int len=sizeof(SOCKADDR);
char revbuf[100];
char sendbuf[100];
printf("請輸入內容：\n");
while(1)
{
scanf("%s",&sendbuf);
sendto(sockclient,sendbuf,strlen(sendbuf)+1,0,(SOCKADDR*)&clientaddr,len);
recvfrom(sockclient,revbuf,100,0,(SOCKADDR*)&clientaddr,&len);
printf("%s\n",revbuf);
}
closesocket(sockclient);
WSACleanup();
}
大同小異，CSocket只是進行了封裝而已，原理是一樣的，編程要思路靈活才行。
㈦ C++的socket方法
C++中Socket方法主要用於網路通信，常用到的函數如下：
CSocket::Socket初始化
CSocket::SetSockOpt設置socket選項
CSocket::Bind綁定地址埠
CSocket::Connect連接
CSocket::Listen監聽
CSocket::Accept接收外部連接的socket
CSocket::Send發送內容
CSocket::Receive接收內容
CSocket::Close關閉(不等於delete)
下面是C++編程下用Socket方法做一個客服端和服務端通信的案例：
1、服務端代碼
//初始化Winscok
if(!AfxSocketInit())
{
AfxMessageBox(IDP_SOCKETS_INIT_FAILED);
return1;
}
m_exit=false;
CServerDlg*aDlg=(CServerDlg*)lParam;
//獲取埠
CStringstrPort;
aDlg->GetDlgItemText(IDC_EDIT_PORT,strPort);
UINTnPort=atoi(strPort);
//socket----創建2個socket--------------------------------------------
CSocketaSocket,serverSocket;
//最好不要使用aSocket.Create創建，因為容易會出現10048錯誤
if(!aSocket.Socket())
{
charszError[256]={0};
sprintf(szError,"CreateFaild:%d",GetLastError());
AfxMessageBox(szError);
return1;
}
BOOLbOptVal=TRUE;
intbOptLen=sizeof(BOOL);
//設置Socket的選項,解決10048錯誤必須的步驟
aSocket.SetSockOpt(SO_REUSEADDR,(void*)&bOptVal,bOptLen,SOL_SOCKET);
//綁定
if(!aSocket.Bind(nPort))
{
charszError[256]={0};
sprintf(szError,"BindFaild:%d",GetLastError());
AfxMessageBox(szError);
return1;
}
//監聽
if(!aSocket.Listen(10))
{
charszError[256]={0};
sprintf(szError,"ListenFaild:%d",GetLastError());
AfxMessageBox(szError);
return1;
}
CStringstrText;
aDlg->GetDlgItemText(IDC_EDIT_LOG,strText);
strText+="服務已經開啟! ";
aDlg->SetDlgItemText(IDC_EDIT_LOG,strText);
while(!m_exit)
{
//接收外部連接
if(!aSocket.Accept(serverSocket))
{
continue;
}
else
{
charszRecvMsg[256]={0};
charszOutMsg[256]={0};
serverSocket.Receive(szRecvMsg,256);//接收客戶端內容:阻塞
sprintf(szOutMsg,"接受到的參數是:%s ",szRecvMsg);
aDlg->GetDlgItemText(IDC_EDIT_LOG,strText);
strText+=szOutMsg;
aDlg->SetDlgItemText(IDC_EDIT_LOG,strText);
serverSocket.Send("伺服器已經收到，已經做出操作！",50);//發送內容給客戶端
serverSocket.Close();//關閉
}
}
aSocket.Close();
serverSocket.Close();
aDlg->GetDlgItemText(IDC_EDIT_LOG,strText);
strText+="HaveClose!";
aDlg->SetDlgItemText(IDC_EDIT_LOG,strText);
return0;
2、客戶端代碼
//初始化CSocket對象,客戶端可以是用Create因為客戶端不需要綁定任何埠和地址,所以用默認參數即可
//連接指定的地址和埠是用函數Connect函數
//發送內容給伺服器是用send函數
//接收服務端發送的內容使用Receive函數
AfxSocketInit();
CSocketaSocket;
CStringstrIP;
CStringstrPort;
CStringstrText;
this->GetDlgItem(IDC_EDIT_IP)->GetWindowText(strIP);
this->GetDlgItem(IDC_EDIT_PORT)->GetWindowText(strPort);
this->GetDlgItem(IDC_EDIT_TEXT)->GetWindowText(strText);
//初始化CSocket對象,因為客戶端不需要綁定任何埠和地址,所以用默認參數即可
if(!aSocket.Create())
{
charszMsg[1024]={0};
sprintf(szMsg,"createfaild:%d",aSocket.GetLastError());
AfxMessageBox(szMsg);
return;
}
//轉換需要連接的埠內容類型
intnPort=atoi(strPort);
//連接指定的地址和埠
if(aSocket.Connect(strIP,nPort))
{
charszRecValue[1024]={0};
aSocket.Send(strText,strText.GetLength());//發送內容給伺服器
aSocket.Receive((void*)szRecValue,1024);//接收伺服器發送回來的內容(該方法會阻塞,在此等待有內容接收到才繼續向下執行)
AfxMessageBox(szRecValue);
}
else
{
charszMsg[1024]={0};
sprintf(szMsg,"createfaild:%d",aSocket.GetLastError());
AfxMessageBox(szMsg);
}
aSocket.Close();
㈧ 求C# Socket編程的 教程 最好是視頻教程 920572719 qq
Socket 編程，建議先了解一下 Socket 基礎知識，還有各個語言的差異，比如 C# 的 byte 取值范圍是 0-255，而 JAVA 的確實 -127 至 128，中間要進行一些轉換等。
基礎方面的還包或目標如何接收數據還有一些脈搏通訊等。
這些了解之後，開發方面隨便網路幾個文章就足夠開發了。
不要小看基礎性的東西，有可能你完成實例後的代碼是完全沒有問題的，只是在底層基礎某些部分沒有太注意而導致發送或接受數據失敗。最後饒了一個很大的彎子才恍然大悟。