Benjamin

静以修身,俭以养德,非澹薄无以明志,非宁静无以致远。
随笔 - 195, 文章 - 0, 评论 - 197, 引用 - 0
数据加载中……

WinInet编程中如何使用异步

在WinInet编程中,同步的使用方法如下:
InternetOpen->InternetOpenUrl->HttpQueryInfo->InternetReadFile->InternetCloseHandle;在InternetOpenUrl和InternetReadFile时会导致程序阻塞,知道操作完成,同步的好处就是比较简单,调试方便。
异步的使用方法如下:
1)InternetOpen,需指定是异步;
2)InternetSetStatusCallback,设置回调;
3)InternetOpenUrl,需指定回调参数;
4)WaitForSingObject或WaitForMultipleObjects,接收信号量;
5)HttpQueryInfo;
6)InternetReadFileEx,需指定回调参数(CE或mobile下是InternetReadFileExA);
7)WaitForSingObject或WaitForMultipleObjects,接收信号量;
8)InternetSetStatusCallback,卸载回调;
9)InternetCloseHandle。
异步比同步要复杂了不少,重点在于回调函数。在回调中,系统会及时返回各种系统定义的HTTP消息,我们根据这些消息来设置某些信号量。在WaitForSingObject或WaitForMultipleObjects里,等待这些信号(当然也可以等待用户的取消动作)。当有正确的信号返回时,继续往下的操作。下面一个例子代码:上面的理论同样适用于wince或windows mobile平台

#include<windows.h>
#include
<wininet.h>
#include
<iostream.h>

DWORD dwNumKSent;
DWORD dwNumKToSend;
DWORD dwNumBytesComplete 
= 0;
char lpOutBuf[1024];
HANDLE hConnectedEvent, hRequestCompleteEvent;
HINTERNET hInstance, hConnect, hRequest;
char *lpszUrl, *lpszServer;

BOOL bAllDone 
= FALSE;

void __stdcall Callback(HINTERNET hInternet,
              DWORD dwContext,
              DWORD dwInternetStatus,
              LPVOID lpStatusInfo,
              DWORD dwStatusInfoLen);

void main(int argc, char *argv[])
{
    
if (argc != 4)
    {
        cout 
<< "Usage: sendreqexasync <server> <url> <size in kilobytes>" << endl;
        cout 
<< "   Example: sendreqexasync www.foo.com /postfolder/upload.exe 256" << endl;
        
return;
    }

    lpszServer 
= argv[1];
    lpszUrl 
= argv[2];
    dwNumKToSend 
= atoi(argv[3]);

    FillMemory(lpOutBuf, 
1024'A');
    hConnectedEvent 
= CreateEvent(NULL, FALSE, FALSE, NULL);
    hRequestCompleteEvent 
= CreateEvent(NULL, FALSE, FALSE, NULL);

    hInstance 
= InternetOpen("sendreqexasync"
                                       INTERNET_OPEN_TYPE_PRECONFIG,
                                       NULL,
                                       NULL,
                                       INTERNET_FLAG_ASYNC);

    
if (hInstance == NULL)
    {
        cout 
<< "InternetOpen failed, error " << GetLastError();
        
return;
    }

    
if (InternetSetStatusCallback(hInstance,
                                  (INTERNET_STATUS_CALLBACK)
&Callback) == INTERNET_INVALID_STATUS_CALLBACK)
    {
        cout 
<< "InternetSetStatusCallback failed, error " << GetLastError();
        
return;
    }

    hConnect 
= InternetConnect(hInstance, 
                               lpszServer, 
                               INTERNET_DEFAULT_HTTP_PORT,
                               NULL,
                               NULL,
                               INTERNET_SERVICE_HTTP,
                               
0,
                               
1);
    
if (hConnect == NULL)
    {
        
if (GetLastError() != ERROR_IO_PENDING)
        {
            cout 
<< "InternetConnect failed, error " << GetLastError();
            
return;
        }
        WaitForSingleObject(hConnectedEvent, INFINITE);
    }

    hRequest 
= HttpOpenRequest(hConnect, 
                               
"POST"
                               lpszUrl,
                               NULL,
                               NULL,
                               NULL,
                               INTERNET_FLAG_RELOAD 
| INTERNET_FLAG_NO_CACHE_WRITE,
                               
2);
    
if (hRequest == NULL)
    {
        
if (GetLastError() != ERROR_IO_PENDING)
        {
            cout 
<< "HttpOpenRequest failed, error " << GetLastError();
            
return;
        }
        WaitForSingleObject(hRequestCompleteEvent, INFINITE);
    }

    INTERNET_BUFFERS IntBuff;

    FillMemory(
&IntBuff, sizeof(IntBuff), 0);
    IntBuff.dwStructSize
= sizeof(IntBuff);
    IntBuff.dwBufferTotal 
= 1024*dwNumKToSend;
    IntBuff.lpcszHeader 
= "Content-Type: text/text\r\n";
    IntBuff.dwHeadersLength 
= lstrlen(IntBuff.lpcszHeader);

    
if (!HttpSendRequestEx(hRequest, 
                           
&IntBuff, 
                           NULL, 
                           
0,
                           
2))
    {
        
if (GetLastError() != ERROR_IO_PENDING)
        {
            cout 
<< "HttpSendRequestEx failed, error " << GetLastError();
            
return;
        }
        cout 
<< "HttpSendRequestEx called successfully" << endl;
        cout.flush();

        WaitForSingleObject(hRequestCompleteEvent, INFINITE);
    }

    
for (dwNumKSent = 0; dwNumKSent < dwNumKToSend; dwNumKSent++)
    {
        DWORD dwBytesWritten;

        
if(!InternetWriteFile(hRequest,
                               lpOutBuf,
                               
1024,
                               
&dwBytesWritten))
        {
            
if (GetLastError() != ERROR_IO_PENDING)
            {
                cout 
<< "InternetWriteFile failed, error " << GetLastError();
                
return;
            }
            
else
            {
                cout 
<< "InternetWriteFile completing asynchronously" << endl;
                cout.flush();
                WaitForSingleObject(hRequestCompleteEvent, INFINITE);
            }
        }
    }

    cout 
<< "Calling HttpEndRequest" << endl;
    cout.flush();
    
if (!HttpEndRequest(hRequest, NULL, HSR_INITIATE, 2))
    {
        
if (GetLastError() == ERROR_IO_PENDING)
        {
            cout 
<< "HttpEndRequest called" << endl;
            cout.flush();
            WaitForSingleObject(hRequestCompleteEvent, INFINITE);
        }
        
else
        {
            cout 
<< "HttpEndRequest failed, error " << GetLastError() << endl;
            
return;
        }
    }


    cout 
<< "------------------- Read the response -------------------" << endl;
    
char lpReadBuff[256];

    
do
    {
        INTERNET_BUFFERS InetBuff;
        FillMemory(
&InetBuff, sizeof(InetBuff), 0);
        InetBuff.dwStructSize 
= sizeof(InetBuff);
        InetBuff.lpvBuffer 
= lpReadBuff;
        InetBuff.dwBufferLength 
= sizeof(lpReadBuff) - 1;
        
        cout 
<< "Calling InternetReadFileEx" << endl;
        cout.flush();

        
if (!InternetReadFileEx(hRequest,
                              
&InetBuff,
                              
02))
        {
            
if (GetLastError() == ERROR_IO_PENDING)
            {
                cout 
<< "Waiting for InternetReadFile to complete" << endl;
                cout.flush();
                WaitForSingleObject(hRequestCompleteEvent, INFINITE);
            }
            
else
            {
                cout 
<< "InternetReadFileEx failed, error " << GetLastError();
                cout.flush();
                
return;
            }
        }

        lpReadBuff[InetBuff.dwBufferLength] 
= 0;
        cout 
<< lpReadBuff;
        cout.flush();

        
if (InetBuff.dwBufferLength == 0
            bAllDone 
= TRUE;

    } 
while (bAllDone == FALSE);

    cout 
<< endl << endl << "------------------- Request Complete ----------------" << endl;

}

void __stdcall Callback(HINTERNET hInternet,
              DWORD dwContext,
              DWORD dwInternetStatus,
              LPVOID lpStatusInfo,
              DWORD dwStatusInfoLen)
{
    cout 
<< "Callback dwInternetStatus: " << dwInternetStatus << " Context: " << dwContext << endl;
    cout.flush();

    
switch(dwContext)
    {
    
case 1// Connection handle
        if (dwInternetStatus == INTERNET_STATUS_HANDLE_CREATED)
        {
            INTERNET_ASYNC_RESULT 
*pRes = (INTERNET_ASYNC_RESULT *)lpStatusInfo;
            hConnect 
= (HINTERNET)pRes->dwResult;
            cout 
<< "Connect handle created" << endl;
            cout.flush();
            SetEvent(hConnectedEvent);
        }
        
break;
    
case 2// Request handle
        switch(dwInternetStatus)
        {
        
case INTERNET_STATUS_HANDLE_CREATED:
            {
                INTERNET_ASYNC_RESULT 
*pRes = (INTERNET_ASYNC_RESULT *)lpStatusInfo;
                hRequest 
= (HINTERNET)pRes->dwResult;
                cout 
<< "Request handle created" << endl;
                cout.flush();
            }
            
break;
        
case INTERNET_STATUS_REQUEST_SENT:
            {
                DWORD 
*lpBytesSent = (DWORD*)lpStatusInfo;
                cout 
<< "Bytes Sent: " << *lpBytesSent << endl;
                dwNumBytesComplete 
+= *lpBytesSent;
            }
            
break;
        
case INTERNET_STATUS_REQUEST_COMPLETE:
            {
                INTERNET_ASYNC_RESULT 
*pAsyncRes = (INTERNET_ASYNC_RESULT *)lpStatusInfo;
                cout 
<< "Function call finished" << endl;
                cout 
<< "dwResult: " << pAsyncRes->dwResult << endl;
                cout 
<< "dwError:  " << pAsyncRes->dwError << endl;
                cout.flush();
                SetEvent(hRequestCompleteEvent);
            }
            
break;
        
case INTERNET_STATUS_RECEIVING_RESPONSE:
            cout 
<< "Receiving Response" << endl;
            cout.flush();
            
break;
        
case INTERNET_STATUS_RESPONSE_RECEIVED:
            {
                DWORD 
*dwBytesReceived = (DWORD*)lpStatusInfo;
                cout 
<< "Received " << *dwBytesReceived << endl;
                cout.flush();
            }

        }

    }

}

参考的异步类:
 1 include <wininet.h>
 2 #include <mmsystem.h>
 3 
 4 class AsyncWinINet
 5 {
 6 public:
 7    typedef void (*notify_fp)(const StringMap&);
 8   
 9    class thread_info
10    {
11    public:
12     thread_info(const String& _url,     //请求下载的地址(in)
13      const StringMap& _request_headrs,   //请求头request_headrs(in)
14      const notify_fp& _pfp,      //下载进度通知回调函数指针
15      const StringMap& _pfp_param,
16      String& _response_headrs,     //返回头response_headrs(out)  
17      const String& _saved_filename,    //下载内容保存文件名(in)
18      String& _response_content,     //返回内容(out)
19      size_t _read_content_size)     //控制保存在response_content中内容的长度(in)) : 
20      : request_headrs(_request_headrs), pfp(_pfp),
21      pfp_param(_pfp_param),      //pfp函数传回参数
22      response_headrs(_response_headrs), saved_filename(_saved_filename),
23      response_content(_response_content), read_content_size(_read_content_size) 
24     {
25      this->response_headrs.clear();
26      this->response_content.clear();
27      this->url = StringUtil::EncodeURIComponent(_url);
28      for(int i = 0; i < 3++i)
29      {
30       this->hEvent[i] = CreateEvent(NULL,TRUE,FALSE,NULL);
31      }
32     }
33 
34     HANDLE hThread;
35     DWORD dwThreadID;
36     HANDLE hCallbackThread;
37     DWORD dwCallbackThreadID;
38     HANDLE hEvent[3];
39     LPVOID hInternet;
40     LPVOID hFile;
41     DWORD dwStatusCode;
42     DWORD dwContentLength;
43 
44     String url;         //请求下载的地址(in)
45     const StringMap& request_headrs;   //请求头request_headrs(in)
46     const notify_fp& pfp;      //下载进度通知回调函数指针
47     const StringMap& pfp_param;     //pfp函数传回参数
48 
49     String& response_headrs;     //返回头response_headrs(out)  
50     const String& saved_filename;    //下载内容保存文件名(in)
51     String& response_content;     //返回内容(out)
52     size_t read_content_size;     //控制保存在response_content中内容的长度(in)
53    };
54 
55    /*******************************************************************************
56    * 函数:download
57    * 功能:下载,返回WinINet_ERR_CODE值
58    *   说明:关于notify_fp 类型说明: 函数的参数为StringMap类型,传回的变量名与变量值
59    * 2007-12
60    *******************************************************************************/
61    static DWORD download(const String& url, //请求下载的地址(in)
62     const StringMap& request_headrs,   //请求头request_headrs(in)
63     const notify_fp& pfp,      //下载进度通知回调函数指针
64     const StringMap& pfp_param,     //pfp函数传回参数
65     String& response_headrs,     //返回头response_headrs(out)  
66     const String& saved_filename,    //下载内容保存文件名(in)
67     String& response_content,     //返回内容(out)
68     size_t read_content_size = 0);    //控制保存在response_content中内容的长度(in)
69 
70 protected:
71    static BOOL WaitExitEvent(thread_info *p);
72    static DWORD WINAPI AsyncThread(LPVOID lpParameter);
73    static DWORD WINAPI AsyncCallbackThread(LPVOID lpParameter);
74    static VOID CALLBACK AsyncInternetCallback(HINTERNET hInternet,
75     DWORD dwContext,
76     DWORD dwInternetStatus,
77     LPVOID lpvStatusInformation,
78     DWORD dwStatusInformationLength);
79 
80 };
81 

  1 #include "AsyncWinINet.h"
  2 
  3 #include "stdafx.h"
  4 
  5 #pragma comment(lib, "Winmm.lib")
  6 #pragma comment(lib, "Wininet.lib")
  7 
  8 DWORD AsyncWinINet::download(const Fagex::String &url, const Fagex::StringMap &request_headrs, 
  9    const Fagex::AsyncWinINet::notify_fp &pfp, const Fagex::StringMap &pfp_param, Fagex::String &response_headrs, 
 10    const Fagex::String &saved_filename, Fagex::String &response_content, size_t read_content_size)
 11 {
 12    thread_info info(url, request_headrs, pfp,
 13     pfp_param, response_headrs, saved_filename,
 14     response_content, read_content_size);
 15 
 16    info.hThread = CreateThread(NULL, 
 17     0,
 18     AsyncWinINet::AsyncThread,
 19     &info,
 20     NULL,
 21     &info.dwThreadID);
 22 
 23    WaitForSingleObject(info.hThread, INFINITE); //等待子线程安全退出
 24    CloseHandle(info.hThread);//关闭线程句柄
 25 
 26    return TRUE;
 27 }
 28 
 29 //---------------------------------------------------------------------
 30 DWORD WINAPI AsyncWinINet::AsyncThread(LPVOID lpParameter)
 31 {
 32    thread_info* p = (thread_info*)lpParameter;
 33 
 34    //a. 使用标记 INTERNET_FLAG_ASYNC 初始化 InternetOpen
 35    String user_agent("Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; TencentTraveler ; .NET CLR 2.0.50727)");
 36    StringMap iheadrs(p->request_headrs.begin(), p->request_headrs.end());
 37    StringMap::iterator it = iheadrs.find("User-Agent");
 38    if(it == iheadrs.end()) iheadrs["User-Agent"= user_agent;
 39    else user_agent = it->second;
 40 
 41    p->hInternet = InternetOpen(user_agent.c_str(),
 42     INTERNET_OPEN_TYPE_PRECONFIG,
 43     NULL,
 44     NULL,
 45     INTERNET_FLAG_ASYNC);
 46 
 47    //ResetEvent(p->hEvent[0]);
 48    //p->hCallbackThread = CreateThread(NULL,
 49    // 0,
 50    // AsyncWinINet::AsyncCallbackThread,
 51    // p,
 52    // NULL,
 53    // &p->dwCallbackThreadID);
 54    //WaitForSingleObject(p->hEvent[0], INFINITE);//等待回调函数设置成功事件
 55    InternetSetStatusCallback(p->hInternet, AsyncWinINet::AsyncInternetCallback);
 56 
 57    String sheadrs;
 58    for(it = iheadrs.begin(); it != iheadrs.end(); ++it)
 59    {
 60     sheadrs += it->first + ":" + it->second;
 61     if(it->second.find(StringUtil::enter) == String::npos) { sheadrs += StringUtil::enter; }
 62    }
 63    sheadrs += StringUtil::enter;
 64   
 65    DWORD start_time = timeGetTime();
 66    ResetEvent(p->hEvent[0]); //重置句柄被创建事件
 67    p->hFile = InternetOpenUrl(p->hInternet, p->url.c_str(), sheadrs.c_str(), sheadrs.length(), 
 68     INTERNET_FLAG_DONT_CACHE | INTERNET_FLAG_RELOAD, (DWORD)p);
 69 
 70    FILE *fp = fopen(p->saved_filename.c_str(), "w+");
 71    while(true)
 72    {
 73     if (NULL == p->hFile)
 74     {
 75      DWORD dwError = ::GetLastError();
 76      if (ERROR_IO_PENDING == dwError || ERROR_SUCCESS == dwError)
 77      {
 78       if (WaitExitEvent(p)) { break; }
 79      }
 80      else break;
 81     }
 82 
 83     //读取返回文件头
 84     DWORD dwLength = 0;
 85     LPVOID lpOutBuffer = NULL;
 86     while(true//读取response_headrs数据
 87     {
 88      if(!HttpQueryInfo(p->hFile, HTTP_QUERY_RAW_HEADERS_CRLF,
 89         lpOutBuffer, &dwLength, NULL))
 90      {
 91       DWORD err_code = GetLastError();
 92       if (err_code == ERROR_HTTP_HEADER_NOT_FOUND) break
 93       else if(err_code == ERROR_INSUFFICIENT_BUFFER)
 94       {
 95        lpOutBuffer = new char[dwLength];
 96        continue
 97       }
 98       else break;
 99      }
100      break;
101     }
102     if(lpOutBuffer != NULL)
103     {
104      p->response_headrs.append((char*)lpOutBuffer,dwLength);
105      delete [] lpOutBuffer;
106     }
107 
108     //e. 使用 HttpQueryInfo 分析头信息 HttpQueryInfo 使用非阻塞方式,所以不用等待
109     DWORD dwStatusSize = sizeof(p->dwStatusCode);
110     if (FALSE == HttpQueryInfo(p->hFile, //获取返回状态码
111      HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER,
112      &p->dwStatusCode, &dwStatusSize, NULL)) { break; }
113    
114     //判断状态码是不是 200
115     if (HTTP_STATUS_OK != p->dwStatusCode) break;
116    
117     StringMap msgMap(p->pfp_param.begin(), p->pfp_param.end());
118     msgMap["url"= p->url;
119 
120     //获取返回的Content-Length
121     //DWORD dwLengthSize = sizeof(p->dwContentLength); 
122     //if (FALSE == HttpQueryInfo(p->hFile,
123     //HTTP_QUERY_CONTENT_LENGTH | HTTP_QUERY_FLAG_NUMBER,
124     //&p->dwContentLength, &dwLengthSize, NULL)) { p->dwContentLength = 0; }
125 
126     //f. 使用标记 IRF_ASYNC 读数据 InternetReadFileEx
127     //为了向主线程报告进度,我们设置每次读数据最多 1024 字节
128 
129     char lpvBuffer[1024];
130     p->dwContentLength = 0//Content-Length: 202749
131     while(true)
132     {
133      INTERNET_BUFFERS i_buf = {0};
134      i_buf.dwStructSize = sizeof(INTERNET_BUFFERS);
135      i_buf.lpvBuffer = lpvBuffer;
136      i_buf.dwBufferLength = 1024;
137        
138      //重置读数据事件
139      ResetEvent(p->hEvent[0]);
140      if (FALSE == InternetReadFileEx(p->hFile, &i_buf, IRF_ASYNC, (DWORD)p))
141      {
142       if (ERROR_IO_PENDING == ::GetLastError())
143       {
144        if (WaitExitEvent(p)) break
145       }
146       else break
147      }
148      else
149      {
150       //在网络传输速度快,步长较小的情况下,InternetReadFileEx 经常会直接返回成功,
151       //因此要判断是否发生了用户要求终止子线程事件。
152       if (WAIT_OBJECT_0 == WaitForSingleObject(p->hEvent[2], 0))
153       {
154        ResetEvent(p->hEvent[2]);
155        break;
156       }
157      }
158 
159      if(i_buf.dwBufferLength == 0
160      {
161       DWORD time = timeGetTime() - start_time;
162       if(time != 0)
163       {
164        Real speed = (Real)p->dwContentLength;
165        speed /= ((Real)time)/1000.0f;
166        speed /= 1024.0f;
167        msgMap["speed"= StringUtil::toString((DWORD)speed);
168       }
169       if(p->pfp) p->pfp(msgMap);
170       break;
171      }
172      if(fp)
173      {
174       fwrite(i_buf.lpvBuffer, sizeof(char), i_buf.dwBufferLength, fp);
175      }
176      if(p->read_content_size > p->response_content.size())
177      {
178       p->response_content.append((char*)i_buf.lpvBuffer, i_buf.dwBufferLength);
179      }
180      p->dwContentLength += i_buf.dwBufferLength;
181     }
182     break;
183    }
184   
185    if(fp)
186    {
187     fflush(fp); fclose(fp); fp = NULL;
188    }
189 
190    if(p->hFile)
191    {
192     InternetCloseHandle(p->hFile);//关闭 m_hFile
193     while (!WaitExitEvent(p)) //等待句柄被关闭事件或者要求子线程退出事件
194     {
195      ResetEvent(p->hEvent[0]);
196     }
197    }
198 
199    //设置子线程退出事件,通知回调线程退出
200    SetEvent(p->hEvent[2]);
201   
202    //等待回调线程安全退出
203    //WaitForSingleObject(p->hCallbackThread, INFINITE);
204    //CloseHandle(p->hCallbackThread);
205   
206    //注销回调函数
207    InternetSetStatusCallback(p->hInternet, NULL);
208    InternetCloseHandle(p->hInternet);
209 
210    return TRUE;
211 }
212 
213 //------------------------------------------------------------------------------------
214 DWORD WINAPI AsyncWinINet::AsyncCallbackThread(LPVOID lpParameter)
215 {
216    thread_info *= (thread_info*)lpParameter;
217    InternetSetStatusCallback(p->hInternet, AsyncWinINet::AsyncInternetCallback);
218 
219    //通知子线程回调函数设置成功,子线程可以继续工作
220    SetEvent(p->hEvent[0]);
221 
222    //等待用户终止事件或者子线程结束事件
223    //子线程结束前需要设置子线程结束事件,并等待回调线程结束
224    WaitForSingleObject(p->hEvent[2], INFINITE);
225 
226    return 0;
227 }
228 
229 //----------------------------------------------------------------------------
230 VOID CALLBACK AsyncWinINet::AsyncInternetCallback(HINTERNET hInternet,
231     DWORD dwContext,
232     DWORD dwInternetStatus,
233     LPVOID lpvStatusInformation,
234     DWORD dwStatusInformationLength)
235 {
236    thread_info* p = (thread_info*)dwContext;
237   
238    //在我们的应用中,我们只关心下面三个状态
239    switch(dwInternetStatus)
240    {
241    //句柄被创建
242    case INTERNET_STATUS_HANDLE_CREATED:
243     p->hFile = (HINTERNET)(((LPINTERNET_ASYNC_RESULT)
244      (lpvStatusInformation))->dwResult);
245     break;
246   
247    //句柄被关闭
248    case INTERNET_STATUS_HANDLE_CLOSING:
249     SetEvent(p->hEvent[1]);
250     break;
251 
252    //一个请求完成,比如一次句柄创建的请求,或者一次读数据的请求
253    case INTERNET_STATUS_REQUEST_COMPLETE:
254     if (ERROR_SUCCESS == ((LPINTERNET_ASYNC_RESULT)
255      (lpvStatusInformation))->dwError)
256     { 
257      //设置句柄被创建事件或者读数据成功完成事件
258      SetEvent(p->hEvent[0]);
259     }
260     else
261     { 
262      //如果发生错误,则设置子线程退出事件 这里也是一个陷阱,经常会忽视处理这个错误,
263      SetEvent(p->hEvent[2]);
264     }
265     break;
266 
267    case INTERNET_STATUS_CONNECTION_CLOSED:
268     SetEvent(p->hEvent[2]);
269     break;
270 
271    }
272 }
273 
274 //--------------------------------------------------------------------
275 BOOL AsyncWinINet::WaitExitEvent(thread_info *p)
276 {
277    DWORD dwRet = WaitForMultipleObjects(3, p->hEvent, FALSE, INFINITE);
278   
279    switch (dwRet)
280    {
281    case WAIT_OBJECT_0://句柄被创建事件或者读数据请求成功完成事件
282    case WAIT_OBJECT_0+1://句柄被关闭事件
283    case WAIT_OBJECT_0+2://用户要求终止子线程事件或者发生错误事件
284     break;
285    }
286    return WAIT_OBJECT_0 != dwRet;
287 }
288 

posted on 2009-05-17 16:33 Benjamin 阅读(9911) 评论(15)  编辑 收藏 引用 所属分类: VC

评论

# 我晕就是太崇拜!!!  回复  更多评论   

暂时失去意识。
2009-09-11 20:09 | 感叹12345678

# re: WinInet编程中如何使用异步  回复  更多评论   

写的非常不错,感谢!
2009-12-18 14:53 | xuqs

# re: WinInet编程中如何使用异步  回复  更多评论   

写得很好,给我帮助很大,谢谢!
2010-08-19 17:36 | lvcayu

# re: WinInet编程中如何使用异步  回复  更多评论   

请问有代码工程吗,发给我一份好吗?267358440@qq.com,谢谢您了!
2010-08-28 17:43 | 学习

# re: WinInet编程中如何使用异步  回复  更多评论   

Wince下异步使用InternetReadFileEx就不可以,lz说可以,不知是否有试验过,应该改为InternetReadFileExA才可
2011-04-18 11:28 | 4321

# re: WinInet编程中如何使用异步  回复  更多评论   

@4321
仅仅WinCE下InternetReadFileEx未实现而已
2011-04-18 12:37 | 溪流

# re: WinInet编程中如何使用异步  回复  更多评论   

Wince下我发现句柄关闭时回调函数也没有
InternetStates:70 即INTERNET_STATUS_HANDLE_CLOSING,这个该如何解决
2011-04-18 17:13 | 4321

# re: WinInet编程中如何使用异步  回复  更多评论   

CE或mobile下的异步要用InternetReadFileExA,也可以多线程实现;
2011-04-18 22:36 | Benjamin

# re: WinInet编程中如何使用异步  回复  更多评论   

@Benjamin
多线程不是很好吧,要是在多线程的同步下读取数据的函数阻塞了会把线程给卡死,强制退出线程问题多多啊。
还是想问
Wince下句柄关闭时回调函数没有接收到
InternetStates:70 即INTERNET_STATUS_HANDLE_CLOSING 消息,这个该怎么解决
2011-04-19 10:05 | 4321

# re: WinInet编程中如何使用异步  回复  更多评论   

这些代码怎么写的啊,好难
2011-07-19 17:36 |

# re: WinInet编程中如何使用异步  回复  更多评论   

http://blog.csdn.net/achellies/article/details/4569456
2011-09-27 18:28 | daixi

# re: WinInet编程中如何使用异步  回复  更多评论   

不好意思,直接Ctrl+Enter就发出去了,悲摧。。。

http://blog.csdn.net/achellies/article/details/4569456

这篇文章里面说,直接使用InternetConenect会有问题,不知道博主有研究过吗?我想多学习一下,谢谢。。
2011-09-27 18:29 | daixi

# re: WinInet编程中如何使用异步  回复  更多评论   

作者的思路有严重问题,完全没有利用到异步的优势,用WaitForSingleObject等在那里,跟同步有啥区别啊,还不如用同步方式处理了。回调函数难道就是给你用来设置事件的?

真正的异步是不需要等的,数据的处理放在回调中进行,完全不用等待。
2012-02-20 16:14 | famu

# re: WinInet编程中如何使用异步  回复  更多评论   

@famu
可以让线程挂起,释放cpu资源。
2013-01-07 10:43 | yoooooo

# re: WinInet编程中如何使用异步  回复  更多评论   

说是异步,其实还是WAIT等同步方式,此乃非真正的异步
2015-09-08 11:01 | 无名氏

只有注册用户登录后才能发表评论。
【推荐】超50万行VC++源码: 大型组态工控、电力仿真CAD与GIS源码库
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理