wininet 异步+多线程
来源:互联网 发布:穿越火线网络环境异常 编辑:程序博客网 时间:2024/06/05 08:32
一、http://topic.csdn.net/t/20050915/17/4273306.html
异步方式并不是什么高深莫测的事物,WinInet API 更是大家耳熟能详。
如果你仔细看过 MSDN 和 internet 上关于 WinInet API 的文章,你会发现尽管在很多篇章中提到了异步方式的使用,但是大部分说明都只说可以使用,而没有说如何使用。尽管如此,还是有一些文章可以给我们很多的提示,我会在后面列出。
由于网络数据传输经常会消耗一定的时间,因此我们总是把这些可能消耗时间的操作放到一个单独的子线程,以免影响主线程正常的进行。可是当子线程发生长时间阻塞的时候,主线程由于某种原因需要退出,我们通常希望子线程能在主线程退出前正常退出。这时主线程就不得不 wait 子线程,这样就导致主线程也被阻塞了。当然,主线程可以不 wait 子线程而自行退出,还可以使用 TerminateThread 强行终止子线程,但是这样的后果通常是不可预料的,内存泄漏或许是最轻的一种危害了。
使用异步方式是解决这类问题的正确手段,下面我们根据一个实例来分析一下 WinInet API 异步方式的使用方法和注意事项。
我们的例子完成这样的功能:给定一个 URL (如:http://www.sina.com.cn/),使用 HTTP 协议下载该网页或文件。我们一共创建了三个线程:主线程负责创建下载子线程,并等待子线程返回消息;子线程则使用异步方式的 WinInet API 完成下载任务,并在各个阶段返回消息给主线程;子线程还会创建一个回调函数线程,其作用我们稍后解释。
实例代码中涉及到一些线程,消息,事件,错误处理的 API,由于不是我讨论的内容,就不仔细说明了。
1. 主线程工作流程
a. 创建下载子线程
m_hMainThread = ::CreateThread(NULL,
0,
AsyncMainThread,
this,
NULL,
&m_dwMainThreadID);
b. 等待子线程返回消息
MSG msg;
while (1)
{
::GetMessage(&msg, m_hWnd, 0, 0);
if (msg.message == WM_ASYNCGETHTTPFILE)
{ //子线程发回消息
switch(LOWORD(msg.wParam))
{
case AGHF_FAIL:
{
MessageBox(_T("下载行动失败结束!"));
return;
}
case AGHF_SUCCESS:
MessageBox(_T("下载行动成功结束!"));
return;
case AGHF_PROCESS:
//下载进度通知
break;
case AGHF_LENGTH:
//获取下载文件尺寸通知
break;
}
}
DispatchMessage(&msg);
}
2. 下载子线程工作流程
a. 使用标记 INTERNET_FLAG_ASYNC 初始化 InternetOpen
m_hInternet = ::InternetOpen(m_szAgent,
INTERNET_OPEN_TYPE_PRECONFIG,
NULL,
NULL,
INTERNET_FLAG_ASYNC);
起步并不费劲,也不难理解,MSDN 上说这样设置之后,以后所有的 API 调用都是异步的了。
警惕......
看起来好像很简单,但是会有无数的陷阱等着我们掉进去。
b. 设置状态回调函数 InternetSetStatusCallback
::InternetSetStatusCallback(m_hInternet, AsyncInternetCallback);
第一个陷阱就在这里等着你呢,文献[2]中提到使用一个单独的线程来进行这项设置,并解释说如果不这样会有潜在的影响,而在其他文档中却没有这样使用的例子。尽管看起来多余,并且增加了一些复杂度,我们还是先把这种方法写出来再讨论。子线程需要创建一个回调函数线程:
//重置回调函数设置成功事件
::ResetEvent(m_hEvent[0]);
m_hCallbackThread = ::CreateThread(NULL,
0,
AsyncCallbackThread,
this,
NULL,
&m_dwCallbackThreadID);
//等待回调函数设置成功事件
::WaitForSingleObject(m_hEvent[0], INFINITE);
回调函数线程的实现如下:
DWORD WINAPI CAsyncGetHttpFile::AsyncCallbackThread(LPVOID lpParameter)
{
CAsyncGetHttpFile * pObj = (CAsyncGetHttpFile*)lpParameter;
::InternetSetStatusCallback(pObj->m_hInternet, AsyncInternetCallback);
//通知子线程回调函数设置成功,子线程可以继续工作
::SetEvent(pObj->m_hEvent[0]);
//等待用户终止事件或者子线程结束事件
//子线程结束前需要设置子线程结束事件,并等待回调线程结束
::WaitForSingleObject(pObj->m_hEvent[2], INFINITE);
return 0;
}
确实复杂了很多吧,虽然我试验的结果发现两种设置方法都能正确工作,但是确实发现了这两种设置方法产生的一些不同效果,遗憾的是我没有弄清具体的原因。我推荐大家使用后一种方法。
c. 打断一下子线程的流程,由于回调函数和上一部分的关系如此密切,我们来看看它的实现
void CALLBACK CAsyncGetHttpFile::AsyncInternetCallback(
HINTERNET hInternet,
DWORD dwContext,
DWORD dwInternetStatus,
LPVOID lpvStatusInformation,
DWORD dwStatusInformationLength)
{
CAsyncGetHttpFile * pObj = (CAsyncGetHttpFile*)dwContext;
//在我们的应用中,我们只关心下面三个状态
switch(dwInternetStatus)
{
//句柄被创建
case INTERNET_STATUS_HANDLE_CREATED:
pObj->m_hFile = (HINTERNET)(((LPINTERNET_ASYNC_RESULT)
(lpvStatusInformation))->dwResult);
break;
//句柄被关闭
case INTERNET_STATUS_HANDLE_CLOSING:
::SetEvent(pObj->m_hEvent[1]);
break;
//一个请求完成,比如一次句柄创建的请求,或者一次读数据的请求
case INTERNET_STATUS_REQUEST_COMPLETE:
if (ERROR_SUCCESS == ((LPINTERNET_ASYNC_RESULT)
(lpvStatusInformation))->dwError)
{ //设置句柄被创建事件或者读数据成功完成事件
::SetEvent(pObj->m_hEvent[0]);
}
else
{ //如果发生错误,则设置子线程退出事件
//这里也是一个陷阱,经常会忽视处理这个错误,
::SetEvent(pObj->m_hEvent[2]);
}
break;
}
}
d. 继续子线程的流程,使用 InternetOpenUrl 完成连接并获取下载文件头信息
//重置句柄被创建事件
::ResetEvent(m_hEvent[0]);
m_hFile = ::InternetOpenUrl(m_hInternet,
m_szUrl,
NULL,
NULL,
INTERNET_FLAG_DONT_CACHE | INTERNET_FLAG_RELOAD,
(DWORD)this);
if (NULL == m_hFile)
{
if (ERROR_IO_PENDING == ::GetLastError())
{
if (WaitExitEvent())
{
return FALSE;
}
}
else
{
return FALSE;
}
}
等我们把 WaitExitEvent 函数的实现列出在来再解释发生的一切:
BOOL CAsyncGetHttpFile::WaitExitEvent()
{
DWORD dwRet = ::WaitForMultipleObjects(3, m_hEvent, FALSE, INFINITE);
switch (dwRet)
{
//句柄被创建事件或者读数据请求成功完成事件
case WAIT_OBJECT_0:
//句柄被关闭事件
case WAIT_OBJECT_0+1:
//用户要求终止子线程事件或者发生错误事件
case WAIT_OBJECT_0+2:
break;
}
return WAIT_OBJECT_0 != dwRet;
}
在这里我们终于看到异步方式的巨大优势了,InternetOpenUrl 函数要完成域名解析,服务器连接,发送请求,接收返回头信息等任务,异步方式中 InternetOpenUrl 并不等待成功创建了 m_hFile 才返回,我们看到 m_hFile 是可以在回调函数中赋值的。如果 InternetOpenUrl 的返回值为 NULL 并且 GetLastError 返回 ERROR_IO_PENDING,我们使用 WaitForMultipleObjects 来等待请求的成功完成,这样主线程就有机会在这个等待过程中终止子线程的操作。我真是迫不及待的想把主线程如何强行终止子线程的代码列出来了:
//设置要求子线程结束事件
::SetEvent(m_hEvent[2]);
//等待子线程安全退出
::WaitForSingleObject(m_hMainThread, INFINITE);
//关闭线程句柄
::CloseHandle(m_hMainThread);
哈哈,不需要使用 TerminateThread 终止线程,一切都是安全的,可预料的。
我们再考虑一种情况,这种情况好得超乎你的想象,InternetOpenUrl 返回了一个非空的 m_hFile 怎么办?呵呵,这说明 InternetOpenUrl 已经成功创建了一个 m_hFile,并且没有发生任何阻塞,都不用等待任何事件,直接继续下一步吧。
最后需要说明得是,InternetOpenUrl 的最后一个参数会被作为回调函数的第二个参数使用。并且哪怕在回调函数中不需要这个参数,这个值你也不能设置为 0,否则 InternetOpenUrl 将不会按照异步的方式工作。
到这里,我们已经将 WinInet API 的异步方式使用的关键部分都展示了,你应该可以使用 WinInet API 的异步方式写出你自己的应用了。不过还是让我们继续完成这个实例的其他部分。
e. 使用 HttpQueryInfo 分析头信息
DWORD dwStatusSize = sizeof(m_dwStatusCode);
if (FALSE == ::HttpQueryInfo(m_hFile,
HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER,
&m_dwStatusCode,
&dwStatusSize,
NULL)) //获取返回状态码
{
return FALSE;
}
//判断状态码是不是 200
if (HTTP_STATUS_OK != m_dwStatusCode)
{
return FALSE;
}
DWORD dwLengthSize = sizeof(m_dwContentLength);
if (FALSE == ::HttpQueryInfo(m_hFile,
HTTP_QUERY_CONTENT_LENGTH | HTTP_QUERY_FLAG_NUMBER,
&m_dwContentLength,
&dwLengthSize,
NULL)) //获取返回的Content-Length
{
return FALSE;
}
...//通知主线程获取文件大小成功
需要说明的是 HttpQueryInfo 并不进行网络操作,因此它不需要进行异步操作的处理。
f. 使用标记 IRF_ASYNC 读数据 InternetReadFileEx
//为了向主线程报告进度,我们设置每次读数据最多 1024 字节
for (DWORD i=0; i<m_dwContentLength; )
{
INTERNET_BUFFERS i_buf = {0};
i_buf.dwStructSize = sizeof(INTERNET_BUFFERS);
i_buf.lpvBuffer = new TCHAR[1024];
i_buf.dwBufferLength = 1024;
//重置读数据事件
::ResetEvent(m_hEvent[0]);
if (FALSE == ::InternetReadFileEx(m_hFile,
&i_buf,
IRF_ASYNC,
(DWORD)this))
{
if (ERROR_IO_PENDING == ::GetLastError())
{
if (WaitExitEvent())
{
delete[] i_buf.lpvBuffer;
return FALSE;
}
}
else
{
delete[] i_buf.lpvBuffer;
return FALSE;
}
}
else
{
//在网络传输速度快,步长较小的情况下,
//InternetReadFileEx 经常会直接返回成功,
//因此要判断是否发生了用户要求终止子线程事件。
if (WAIT_OBJECT_0 == ::WaitForSingleObject(m_hEvent[2], 0))
{
::ResetEvent(m_hEvent[2]);
delete[] i_buf.lpvBuffer;
return FALSE;
}
}
i += i_buf.dwBufferLength;
...//保存数据
...//通知主线程下载进度
delete[] i_buf.lpvBuffer;
}
这里 InternetReadFileEx 的异步处理方式同 InternetOpenUrl 的处理方式类似,我没有使用 InternetReadFile 因为它没有异步的工作方式。
g. 最后清理战场,一切都该结束了
//关闭 m_hFile
::InternetCloseHandle(m_hFile);
//等待句柄被关闭事件或者要求子线程退出事件
while (!WaitExitEvent())
{
::ResetEvent(m_hEvent[0]);
}
//设置子线程退出事件,通知回调线程退出
::SetEvent(m_hEvent[2]);
//等待回调线程安全退出
::WaitForSingleObject(m_hCallbackThread, INFINITE);
::CloseHandle(m_hCallbackThread);
//注销回调函数
::InternetSetStatusCallback(m_hInternet, NULL);
::InternetCloseHandle(m_hInternet);
...//通知主线程子线程成功或者失败退出
实例中,我们建立一个完整的 HTTP 下载程序,并且可以在主线程中对下载过程进行完全的监控。我们使用了 WinInet API 中的这些函数:
InternetOpen
InternetSetStatusCallback
InternetOpenUrl
HttpQueryInfo
InternetReadFileEx
InternetCloseHandle
其中 InternetOpenUrl 和 InternetReadFileEx 函数是按照异步方式工作的,文献[4]中列出了可以按照异步方式工作的 API:
FtpCreateDirectory
FtpDeleteFile
FtpFindFirstFile
FtpGetCurrentDirectory
FtpGetFile
FtpOpenFile
FtpPutFile
FtpRemoveDirectory
FtpRenameFile
FtpSetCurrentDirectory
GopherFindFirstFile
GopherOpenFile
HttpEndRequest
HttpOpenRequest
HttpSendRequestEx
InternetConnect
InternetOpenUrl
InternetReadFileEx
二、
http://hi.baidu.com/zhaquanmin/blog/item/c9989a2457dad16935a80f38.html
基于WININET下HTTP协议访问,不采用VC下的封装类CInternetSession,因为它的异步操作理论上可行,MSDN中说明实际代码还在完善。
WININET API下以在HTTP协议下下载一个页面的源代码信息为例,先来看看同步的流程:
1)InternetOpen;
2)InternetOpenUrl;
3)HttpQueryInfo;
4)InternetReadFile;
5)InternetCloseHandle。
在第2步和第4步,程序会一直等待,直到函数返回。如果要设置超时,可以使用InternetSetOption(不过好像没什么用)。在很多时候,这个函数是不合适的。比如用户主动要中断下载,却只能等待函数返回。还有,如果是大文件下载,无法想像一次读取上兆字节的数据,需使用断点续传,虽然也可以使用同步函数InternetSetFilePointer来定位网络文件读取位置,但很多服务器是不支持的。如果在手机上使用,还要考虑诸如移动网关的限制等等。
同步的好处是函数较少,流程清晰,调试也方便。
再采用异步方法,看看异步的总体流程:
1)InternetOpen,需指定是异步;
2)InternetSetStatusCallback,设置回调;
3)InternetOpenUrl,需指定回调参数;
4)WaitForSingObject或WaitForMultipleObjects,接收信号量;
5)HttpQueryInfo;
6)InternetReadFileEx,需指定回调参数;
7)WaitForSingObject或WaitForMultipleObjects,接收信号量;
8)InternetSetStatusCallback,卸载回调;
9)InternetCloseHandle。
可以看出,异步比同步要复杂了不少,重点在于回调函数。在回调中,系统会及时返回各种系统定义的HTTP消息,我们根据这些消息来设置某些信号量。在WaitForSingObject或WaitForMultipleObjects里,等待这些信号(当然也可以等待用户的取消动作)。当有正确的信号返回时,继续往下的操作。
异步方式下,InternetOpenUrl可以在header头里设置要读取的范围。比如读0到1024的数据,在header头里加入Range: bytes=0-1024\r\n。这种方式保证了断点续传。要注意的是,如果服务器支持断点续传,此时使用HttpQueryInfo得到的状态码是206,而不是200。
回调函数写法:
回调函数怎么写啊?看看微软提供的一个例子吧。这个例子是用POST的方式上传数据,比上述下载数据步骤更为麻烦,把InternetOpenUrl这个函数分成更多的函数来处理。有时间再挖挖这个例子。微软这个例子是在一个sendreqexasync.cpp的文件中,在微软的网站上应该可以得到。
源代码如下:
#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 http://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,
0, 2))
{
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();
}
}
}
}
三、
http://hi.baidu.com/fagex/blog/item/2999f4ce54c3953eb600c8e8.html
#include <wininet.h>
#include <mmsystem.h>
class AsyncWinINet
{
public:
typedef void (*notify_fp)(const StringMap&);
class thread_info
{
public:
thread_info(const String& _url, //请求下载的地址(in)
const StringMap& _request_headrs, //请求头request_headrs(in)
const notify_fp& _pfp, //下载进度通知回调函数指针
const StringMap& _pfp_param,
String& _response_headrs, //返回头response_headrs(out)
const String& _saved_filename, //下载内容保存文件名(in)
String& _response_content, //返回内容(out)
size_t _read_content_size) //控制保存在response_content中内容的长度(in)) :
: request_headrs(_request_headrs), pfp(_pfp),
pfp_param(_pfp_param), //pfp函数传回参数
response_headrs(_response_headrs), saved_filename(_saved_filename),
response_content(_response_content), read_content_size(_read_content_size)
{
this->response_headrs.clear();
this->response_content.clear();
this->url = StringUtil::EncodeURIComponent(_url);
for(int i = 0; i < 3; ++i)
{
this->hEvent[i] = CreateEvent(NULL,TRUE,FALSE,NULL);
}
}
HANDLE hThread;
DWORD dwThreadID;
HANDLE hCallbackThread;
DWORD dwCallbackThreadID;
HANDLE hEvent[3];
LPVOID hInternet;
LPVOID hFile;
DWORD dwStatusCode;
DWORD dwContentLength;
String url; //请求下载的地址(in)
const StringMap& request_headrs; //请求头request_headrs(in)
const notify_fp& pfp; //下载进度通知回调函数指针
const StringMap& pfp_param; //pfp函数传回参数
String& response_headrs; //返回头response_headrs(out)
const String& saved_filename; //下载内容保存文件名(in)
String& response_content; //返回内容(out)
size_t read_content_size; //控制保存在response_content中内容的长度(in)
};
/*******************************************************************************
* 函数:download
* 功能:下载,返回WinINet_ERR_CODE值
* 说明:关于notify_fp 类型说明: 函数的参数为StringMap类型,传回的变量名与变量值
* 2007-12
*******************************************************************************/
static DWORD download(const String& url, //请求下载的地址(in)
const StringMap& request_headrs, //请求头request_headrs(in)
const notify_fp& pfp, //下载进度通知回调函数指针
const StringMap& pfp_param, //pfp函数传回参数
String& response_headrs, //返回头response_headrs(out)
const String& saved_filename, //下载内容保存文件名(in)
String& response_content, //返回内容(out)
size_t read_content_size = 0); //控制保存在response_content中内容的长度(in)
protected:
static BOOL WaitExitEvent(thread_info *p);
static DWORD WINAPI AsyncThread(LPVOID lpParameter);
static DWORD WINAPI AsyncCallbackThread(LPVOID lpParameter);
static VOID CALLBACK AsyncInternetCallback(HINTERNET hInternet,
DWORD dwContext,
DWORD dwInternetStatus,
LPVOID lpvStatusInformation,
DWORD dwStatusInformationLength);
};
- wininet 异步+多线程
- wininet 异步+多线程,http下载类。
- 异步WinInet
- wininet异步
- 异步方式调用WinInet
- WinInet异步处理
- WinINet的异步调用方式
- wininet异步代理的编程
- Wininet异步读取类CHttpClient
- WinInet API 的异步方式使用
- WinInet API 的异步方式使用
- 在WinInet中使用异步方式
- 使用WinInet API 进行异步编程
- WinInet API 的异步方式使用
- Windows Mobile下WinInet的异步使用方法
- WinInet开发中的同步和异步区别
- Windows Mobile下WinInet的异步使用方法
- WinInet开发中的同步和异步区别
- 学习Android的一些网站
- Hibernate原理与应用
- 分享Silverlight/WPF/Windows Phone/HTML5一周学习导读(11月28日-12月4日)
- session会话的底层实现方式
- C++ 遍历文件夹
- wininet 异步+多线程
- 推荐23款超赞超实用的CSS3小工具
- 用Aspose.Words for .NET动态生成word文档中的数据表格
- outlook搜索不到历史邮件内容
- C++基本注意事项
- 使用WPF实现MDI窗体的方法
- 动态代理
- 如何为嵌入式开发建立交叉编译环境
- 项目总结