c++ windows网络编程之异步选择模型WSAAsyncSelect函数使用说明

select与WSAAsyncSelect的区别

在windows socket编程，如果多个客户端和服务端通信，在服务端为每一个连接创建线程，可以解决这类问题，线程的创建是比较消耗内存，对于这类问题，如果不创建线程，用select模型可以解决，select模型可以管理多个套接字，但是它需要一个死循环不停的去遍历所有的客户端套接字集合，询问是否有数据到来，如果连接的客户端很多则处理客户端请求的效率会大幅度降低，如果有一个模型，可以不用去轮询客户端套接字集合，当有客户端数据到来时，系统自动的通知我们的程序，这就解决了select模型带来的问题了，所以windows就写了个新的select模型：WsaAsy/ncSelect模型。

关于WSAAsyncSelect的使用说明可以参考微软文档，链接：WSAAsyncSelect

如何使用WSAAsyncSelect

WSAAsyncSelect需要依赖windows窗口，需要自定义windows消息，在创建项目时，项目类型的是win32桌面程序。下面介绍如何编写基于WSAAsyncSelect的C/S程序。

server代码

用vs21019创建一个windows桌面程序，server全部代码如下：

/*

异步select，tcp server

*/

#include "framework.h"
#include "WSAAsyncSelect_tcp_server.h"
#include 
#include  
#include   

#pragma comment(lib,"ws2_32.lib") 

#define MAX_LOADSTRING 100


//自定义winodws消息, 使用异步select时，需要windows窗口
#define     WM_MY_SOCKET      WM_USER + 1234 

// 全局变量:
HINSTANCE hInst;                                // 当前实例
WCHAR szTitle[MAX_LOADSTRING];                  // 标题栏文本
WCHAR szWindowClass[MAX_LOADSTRING];            // 主窗口类名

// 此代码模块中包含的函数的前向声明:
ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);

HWND  hwndEdit = NULL;//全局编辑框句柄

int WSAAsyncSelect_Server(HWND hwnd);
void Set_Edit_Text(const char* strOutputString, ...);


int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
                     _In_opt_ HINSTANCE hPrevInstance,
                     _In_ LPWSTR    lpCmdLine,
                     _In_ int       nCmdShow)
{
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);

    // TODO: 在此处放置代码。

    // 初始化全局字符串
    LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadStringW(hInstance, IDC_WSAASYNCSELECTTCPSERVER, szWindowClass, MAX_LOADSTRING);
    MyRegisterClass(hInstance);

    // 执行应用程序初始化:
    if (!InitInstance (hInstance, nCmdShow))
    {
        return FALSE;
    }

    HACCEL hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_WSAASYNCSELECTTCPSERVER));

    MSG msg;

    // 主消息循环:
    while (GetMessage(&msg, nullptr, 0, 0))
    {
        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }

    return (int) msg.wParam;
}



//
//  函数: MyRegisterClass()
//
//  目标: 注册窗口类。
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
    WNDCLASSEXW wcex;

    wcex.cbSize = sizeof(WNDCLASSEX);

    wcex.style          = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc    = WndProc;
    wcex.cbClsExtra     = 0;
    wcex.cbWndExtra     = 0;
    wcex.hInstance      = hInstance;
    wcex.hIcon          = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_WSAASYNCSELECTTCPSERVER));
    wcex.hCursor        = LoadCursor(nullptr, IDC_ARROW);
    wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
    wcex.lpszMenuName   = MAKEINTRESOURCEW(IDC_WSAASYNCSELECTTCPSERVER);
    wcex.lpszClassName  = szWindowClass;
    wcex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));

    return RegisterClassExW(&wcex);
}

BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   hInst = hInstance; // 将实例句柄存储在全局变量中

   HWND hWnd = CreateWindowW(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, nullptr, nullptr, hInstance, nullptr);

   if (!hWnd)
   {
      return FALSE;
   }

   ShowWindow(hWnd, nCmdShow);
   UpdateWindow(hWnd);

   //WSAAsyncSelect的基本使用
   WSAAsyncSelect_Server(hWnd);

   return TRUE;
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    RECT rect;
    WINDOWINFO windowInfo;
    windowInfo.cbSize = sizeof(WINDOWINFO);
    GetWindowInfo(hWnd, &windowInfo);
    rect = windowInfo.rcWindow;

    int win_w = abs(rect.left - rect.right);
    int win_h = abs(rect.top - rect.bottom);

    switch (message)
    {
    case WM_CREATE:
        // 创建编辑框, 用于显示程序中的提示信息  
        hwndEdit = CreateWindow(L"EDIT", NULL, WS_VISIBLE | WS_CHILD | WS_BORDER | ES_MULTILINE | ES_AUTOVSCROLL,
            10, 10, win_w - 20, win_h - 20, hWnd, (HMENU)10010, ((LPCREATESTRUCT)lParam)->hInstance, NULL);
        break;

    //自定义消息处理
    case WM_MY_SOCKET:
    {
        SOCKET ss = wParam;   //wParam参数标志了网络事件发生的套接口 

        int error = WSAGETSELECTERROR(lParam); // 错误码    
        if (error)
        {
            closesocket(ss);
            Set_Edit_Text("%d   离开聊天室！", ss);
            return 0;
        }

        long event = WSAGETSELECTEVENT(lParam); // 事件    

        switch (event)
        {
        // 有客户端请求到来
        case FD_ACCEPT:
        {
            sockaddr_in Cadd;
            int Cadd_len = sizeof(Cadd);
            SOCKET sClient = accept(ss, (sockaddr*)&Cadd, &Cadd_len);
            if (sClient != INVALID_SOCKET)
            {
                Set_Edit_Text("欢迎%d连接异步select server!", sClient);

                char tmp[64];
                sprintf(tmp, "欢迎%d连接异步select server！", sClient);
                send(sClient, tmp, strlen(tmp), 0);

                // 将与客户端通讯的套接字注册消息(读取)
                WSAAsyncSelect(sClient, hWnd, WM_MY_SOCKET, FD_READ | FD_CLOSE);
            }
        }  break;


        // 有数据可以接受
        case FD_READ:
        {
            char cbuf[256];
            memset(cbuf, 0, 256);
            int cRecv = recv(ss, cbuf, 256, 0);
            if ((cRecv == SOCKET_ERROR && WSAGetLastError() == WSAECONNRESET) || cRecv == 0)
            {
                Set_Edit_Text("recv  error: %d", WSAGetLastError());
                closesocket(ss);
            }
            else if (cRecv > 0)
            {
                Set_Edit_Text("%d   说   %s", ss, cbuf);
            }
        }break;

        // 关闭连接 
        case  FD_CLOSE:
        {
            closesocket(ss);
        }break;
        }
    } 
    break;

    case WM_COMMAND:
        {
            int wmId = LOWORD(wParam);
            // 分析菜单选择:
            switch (wmId)
            {
            case IDM_ABOUT:
                DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
                break;
            case IDM_EXIT:
                DestroyWindow(hWnd);
                break;
            default:
                return DefWindowProc(hWnd, message, wParam, lParam);
            }
        }
        break;
    case WM_PAINT:
        {
            PAINTSTRUCT ps;
            HDC hdc = BeginPaint(hWnd, &ps);
            // TODO: 在此处添加使用 hdc 的任何绘图代码...
            EndPaint(hWnd, &ps);
        }
        break;
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}

// “关于”框的消息处理程序。
INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    UNREFERENCED_PARAMETER(lParam);
    switch (message)
    {
    case WM_INITDIALOG:
        return (INT_PTR)TRUE;

    case WM_COMMAND:
        if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
        {
            EndDialog(hDlg, LOWORD(wParam));
            return (INT_PTR)TRUE;
        }
        break;
    }
    return (INT_PTR)FALSE;
}

//异步select的使用
int WSAAsyncSelect_Server(HWND hwnd)
{
    // 初始化socket环境 
    WSADATA wsaData;
    WORD wVersionRequested = MAKEWORD(2, 2);
    if (WSAStartup(wVersionRequested, &wsaData) != 0)
    {
        Set_Edit_Text("WSAStartup() Failed: %d", WSAGetLastError());
        return 1;
    }

    // 创建监听套接字
    SOCKET s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (s == INVALID_SOCKET)
    {
        Set_Edit_Text("socket() Failed: %d", WSAGetLastError());
        return 1;
    }

    // 绑定到ip与端口
    sockaddr_in sin;
    sin.sin_family = AF_INET;
    sin.sin_port = htons(8000);
    sin.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
    if (bind(s, (sockaddr*)&sin, sizeof(sin)) == SOCKET_ERROR)
    {
        Set_Edit_Text("bind() Failed: %d", WSAGetLastError());
        return 1;
    }

    // 监听
    if (listen(s, 5) == SOCKET_ERROR)
    {
        Set_Edit_Text("listen() Failed: %d", WSAGetLastError());
        return 1;
    }
    else
    {
        Set_Edit_Text("进入监听状态！");
    }

    // 用WSAAsyncSelect将监听套接字注册消息，在消息处理函数接到消息通知
    int ret = WSAAsyncSelect(s, hwnd, WM_MY_SOCKET, FD_ACCEPT | FD_CLOSE);
    if (ret != 0)
    {
        Set_Edit_Text("WSAAsyncSelect Failed: %d", WSAGetLastError());
        return 1;
    }
    else
    {
        Set_Edit_Text("WSAAsyncSelect succes！");
    }
}

void Set_Edit_Text(const char* strOutputString, ...)
{
    char strBuffer[4096] = { 0 };
    va_list vlArgs;
    va_start(vlArgs, strOutputString);
    _vsnprintf(strBuffer, sizeof(strBuffer) - 1, strOutputString, vlArgs);
    va_end(vlArgs);

    strcat_s(strBuffer, "\r\n");

    // 以下两条语句为在edit中追加字符串
    SendMessageA(hwndEdit, EM_SETSEL, -2, -1);
    SendMessageA(hwndEdit, EM_REPLACESEL, true, (long)strBuffer);

    // 设置滚轮到末尾，这样就可以看到最新信息
    SendMessageA(hwndEdit, WM_VSCROLL, SB_BOTTOM, 0);
}

异步select主要在函数WSAAsyncSelect_Server实现，在窗口显示后，消息循环之前调用该函数，该程序和其它tcp, udp程序类似，也是分为如下几步

1 首先需要包含windows socket头文件，包含socket库，如下：

#include 
#pragma comment(lib,"ws2_32.lib")

2 初始化socket

// 初始化socket环境 
WSADATA wsaData;
WORD wVersionRequested = MAKEWORD(2, 2);
if (WSAStartup(wVersionRequested, &wsaData) != 0)
{
    Set_Edit_Text("WSAStartup() Failed: %d", WSAGetLastError());
    return 1;
}

3 创建socket

// 创建监听套接字
SOCKET s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (s == INVALID_SOCKET)
{
    Set_Edit_Text("socket() Failed: %d", WSAGetLastError());
    return 1;
}

4 绑定ip和端口

// 绑定到ip与端口
sockaddr_in sin;
sin.sin_family = AF_INET;
sin.sin_port = htons(8000);
sin.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
if (bind(s, (sockaddr*)&sin, sizeof(sin)) == SOCKET_ERROR)
{
    Set_Edit_Text("bind() Failed: %d", WSAGetLastError());
    return 1;
}

5 监听

if (listen(s, 5) == SOCKET_ERROR)
{
    Set_Edit_Text("listen() Failed: %d", WSAGetLastError());
    return 1;
}
else
{
    Set_Edit_Text("进入监听状态！");
}

6 使用异步select

// 用WSAAsyncSelect将监听套接字注册消息，在消息处理函数接到消息通知
int ret = WSAAsyncSelect(s, hwnd, WM_MY_SOCKET, FD_ACCEPT | FD_CLOSE);
if (ret != 0)
{
    Set_Edit_Text("WSAAsyncSelect Failed: %d", WSAGetLastError());
    return 1;
}
else
{
    Set_Edit_Text("WSAAsyncSelect succes！");
}

7 关闭socket

closesocket(ss);

编译时能会有_WINSOCK_DEPRECATED_NO_WARNINGS、_CRT_SECURE_NO_WARNINGS这两个报错，需要在C++预处理器添加这两个宏，这是由于新老API不兼容，类似与fopen之类的，需要在预处理器里说明。

client代码

#include
#include

using  namespace std;

#pragma comment(lib, "ws2_32.lib")

int  main()
{
	// 初始化socket
	WSADATA  wd;
	if (WSAStartup(MAKEWORD(2, 2), &wd) != 0)
	{
		cout

c++ windows网络编程之异步选择模型WSAAsyncSelect函数使用说明

最近更新

热门博客

[ 申请 ]友情链接：