Nota
O acesso a esta página requer autorização. Podes tentar iniciar sessão ou mudar de diretório.
O acesso a esta página requer autorização. Podes tentar mudar de diretório.
As funções WinINet têm suporte de cache simples, mas flexível. Todos os dados recuperados da rede são armazenados em cache no disco rígido e recuperados para solicitações subsequentes. O aplicativo pode controlar o cache em cada solicitação. Para solicitações http do servidor, a maioria dos cabeçalhos recebidos também são armazenados em cache. Quando uma solicitação http é satisfeita a partir do cache, os cabeçalhos armazenados em cache também são retornados ao chamador. Isso torna o download de dados perfeito, quer os dados sejam provenientes do cache ou da rede.
Os aplicativos devem alocar corretamente um buffer para obter os resultados desejados ao usar as funções de cache de URL persistente. Para obter mais informações, consulte Usando Buffers.
Comportamento do cache durante o processamento de resposta
O cache WinINet é compatível com as diretivas de controle de cache HTTP descritas na RFC 2616. As diretivas de controle de cache e os sinalizadores do conjunto de aplicativos determinam o que pode ser armazenado em cache; no entanto, WinINet determina o que é realmente armazenado em cache com base no seguinte critério:
- WinINet apenas armazena em cache respostas HTTP e FTP.
- Somente respostas bem comportadas podem ser armazenadas por um cache e utilizadas numa resposta a um pedido subsequente. Respostas bem comportadas são definidas como respostas que retornam com êxito.
- Por padrão, o WinINet armazenará em cache as respostas bem-sucedidas, a menos que uma diretiva de controle de cache do servidor ou um sinalizador definido pelo aplicativo denote especificamente que a resposta pode não ser armazenada em cache.
- Em geral, as respostas ao verbo GET são armazenadas em cache se os requisitos listados acima forem atendidos. As respostas aos verbos PUT e POST não são armazenadas em cache em nenhuma circunstância.
- Os itens serão armazenados em cache mesmo quando o cache estiver cheio. Se um item adicionado colocar a cache acima do limite de tamanho, o limpador de cache será agendado. Por padrão, não é garantido que os itens permaneçam mais de 10 minutos no cache. Para obter mais informações, consulte a seção Cache Scavenger abaixo.
- Https é armazenado em cache por padrão. Isso é gerenciado por uma configuração global que não pode ser substituída por diretivas de cache definidas pelo aplicativo. Para substituir a configuração global, selecione o miniaplicativo Opções da Internet no painel de controle e vá para a guia avançado. Marque a caixa "Não salvar páginas criptografadas no disco" na seção "Segurança".
Eliminador de cache
O limpador de cache limpa periodicamente os itens do cache. Se um item for adicionado ao cache e o cache estiver cheio, o item será adicionado ao cache e o limpador de cache será agendado. Se o eliminador de cache concluir uma rodada de eliminação e o cache não tiver atingido o limite de cache, o eliminador será agendado para outra rodada quando outro item for adicionado ao cache. Em geral, o processo de limpeza é agendado quando um item adicionado coloca o cache acima do seu limite de tamanho. Por padrão, o tempo mínimo de vida no cache é definido como 10 minutos, a menos que especificado de outra forma em uma diretiva de controle de cache. Quando o sequestrador de cache é iniciado, não há garantia de que os itens mais antigos sejam os primeiros a serem excluídos do cache.
O cache é compartilhado em todos os aplicativos WinINet no computador para o mesmo usuário. A partir do Windows Vista e do Windows Server 2008, o tamanho do cache é definido como 1/32 do tamanho do disco, com um tamanho mínimo de 8MB e um tamanho máximo de 50MB.
Usando sinalizadores para controlar o cache
Os sinalizadores de cache permitem que um aplicativo controle quando e como ele usa o cache. Esses sinalizadores podem ser usados sozinhos ou em combinação com o parâmetro dwFlags em funções que acessam informações ou recursos na Internet. Por padrão, as funções armazenam todos os dados baixados da Internet.
Os sinalizadores a seguir podem ser usados para controlar o cache.
| Valor | Significado |
|---|---|
| INTERNET_FLAG_CACHE_ASYNC | Esta bandeira não tem efeito. |
| INTERNET_FLAG_CACHE_IF_NET_FAIL | Retorna o recurso do cache se a solicitação de rede para o recurso falhar devido a um erro de ERROR_INTERNET_CONNECTION_RESET ou ERROR_INTERNET_CANNOT_CONNECT. Este sinalizador é usado por HttpOpenRequest. |
| INTERNET_FLAG_DONT_CACHE | Não armazena os dados em cache, seja localmente ou em qualquer gateway. Idêntico ao valor preferido, INTERNET_FLAG_NO_CACHE_WRITE. |
| Indica que este é um envio de formulários. | |
| INTERNET_FLAG_FROM_CACHEINTERNET_FLAG_FORMS_SUBMIT | Não faz solicitações de rede. Todas as entidades são retornadas do cache. Se o item solicitado não estiver no cache, um erro adequado, como ERROR_FILE_NOT_FOUND, será retornado. Somente a função InternetOpen usa esse sinalizador. |
| INTERNET_FLAG_FWD_BACK | Indica que a função deve usar a cópia do recurso que está atualmente no cache da Internet. A data de expiração e outras informações sobre o recurso não são verificadas. Se o item solicitado não for encontrado no cache da Internet, o sistema tentará localizar o recurso na rede. Esse valor foi introduzido no Microsoft Internet Explorer 5 e está associado às operações de Avançar e Retroceder do Internet Explorer. |
| INTERNET_FLAG_HYPERLINK | Força o aplicativo a recarregar um recurso se nenhum tempo de expiração e nenhum tempo de última modificação foram retornados quando o recurso foi armazenado no cache. |
| INTERNET_FLAG_MAKE_PERSISTENT | Não há mais suporte. |
| INTERNET_FLAG_MUST_CACHE_REQUEST | Faz com que um arquivo temporário seja criado se o arquivo não puder ser armazenado em cache. Este é idêntico ao valor preferido, INTERNET_FLAG_NEED_FILE. |
| INTERNET_FLAG_NEED_FILE | Faz com que um arquivo temporário seja criado se o arquivo não puder ser armazenado em cache. |
| INTERNET_FLAG_NO_CACHE_WRITE | Rejeita qualquer tentativa da função de armazenar dados baixados da Internet no cache. Esse sinalizador é necessário se o aplicativo não quiser que nenhum recurso baixado seja armazenado localmente. |
| INTERNET_FLAG_NO_UI | Desativa a caixa de diálogo de cookies. Esse sinalizador pode ser usado por HttpOpenRequest e InternetOpenUrl (somente solicitações HTTP). |
| INTERNET_FLAG_OFFLINE | Impede que o aplicativo envie solicitações para a rede. Todas as solicitações são resolvidas usando os recursos armazenados no cache. Se o recurso não estiver no cache, um erro adequado, como ERROR_FILE_NOT_FOUND, será retornado. |
| INTERNET_FLAG_PRAGMA_NOCACHE | Força a solicitação a ser resolvida pelo servidor de origem, mesmo que exista uma cópia em cache no proxy. A função InternetOpenUrl (somente em solicitações HTTP e HTTPS) e função HttpOpenRequest usam esse sinalizador. |
| INTERNET_FLAG_RELOAD | Força a função a recuperar o recurso solicitado diretamente da Internet. As informações baixadas são armazenadas no cache. |
| INTERNET_FLAG_RESYNCHRONIZE | Faz com que um aplicativo execute um download condicional do recurso da Internet. Se a versão armazenada no cache for atual, as informações serão baixadas do cache. Caso contrário, as informações serão recarregadas do servidor. |
Funções de cache persistente
Os clientes que precisam de serviços de cache persistente usam as funções de cache persistente para permitir que seus aplicativos salvem dados no sistema de arquivos local para uso subsequente, como em situações em que um link de baixa largura de banda limita o acesso aos dados ou o acesso não está disponível.
As funções de cache fornecem cache persistente e navegação offline. A menos que o sinalizador INTERNET_FLAG_NO_CACHE_WRITE especifique explicitamente que não há cache, as funções armazenam em cache todos os dados baixados da rede. As respostas aos dados POST não são armazenadas em cache.
Usando as funções de caches persistentes de URL
As seguintes funções de cache de URL persistente permitem que um aplicativo acesse e manipule informações armazenadas no cache.
| Função | Descrição |
|---|---|
| CommitUrlCacheEntryA | Armazena em cache os dados no arquivo especificado no armazenamento de cache e os associa à URL fornecida. |
| CommitUrlCacheEntryW | Armazena em cache os dados no arquivo especificado no armazenamento de cache e os associa à URL fornecida. |
| CreateUrlCacheEntry | Aloca o armazenamento de cache solicitado e cria um nome de arquivo local para salvar a entrada de cache que corresponde ao nome de origem. |
| CreateUrlCacheGroup | Gera uma identificação de grupo de cache. |
| ExcluirEntradaCacheUrl | Remove o arquivo associado ao nome de origem do cache, se o arquivo existir. |
| DeleteUrlCacheGroup | Liberta um GROUPID e qualquer estado associado no ficheiro de índice de cache. |
| FindCloseUrlCache | Fecha o identificador de enumeração especificado. |
| FindFirstUrlCacheEntry | Inicia a enumeração do cache. |
| FindFirstUrlCacheEntryEx | Inicia uma enumeração filtrada do cache. |
| FindNextUrlCacheEntry | Recupera a próxima entrada na cache. |
| FindNextUrlCacheEntryEx | Recupera a próxima entrada em uma enumeração de cache filtrada. |
| GetUrlCacheEntryInfo | Recupera informações sobre uma entrada de cache. |
| GetUrlCacheEntryInfoEx | Procura a URL após traduzir todos os redirecionamentos em cache que seriam aplicados no modo offline pelo HttpSendRequest. |
| ReadUrlCacheEntryStream | Lê os dados armazenados em cache de um fluxo que foi aberto usando RetrieveUrlCacheEntryStream. |
| RetrieveUrlCacheEntryFile | Recupera uma entrada de cache do cache na forma de um arquivo. |
| RetrieveUrlCacheEntryStream | Fornece a maneira mais eficiente e independente de implementação de acessar os dados de cache. |
| SetUrlCacheEntryGroup | Adiciona ou remove entradas de um grupo de cache. |
| SetUrlCacheEntryInfo | Define os membros especificados da estrutura INTERNET_CACHE_ENTRY_INFO. |
| DesbloquearFicheiroDeEntradaNaCacheDeURL | Desbloqueia a entrada de cache que foi bloqueada quando o arquivo foi recuperado para uso do cache pelo RetrieveUrlCacheEntryFile. |
| UnlockUrlCacheEntryStream | Fecha o fluxo que foi recuperado usando RetrieveUrlCacheEntryStream. |
Enumerando o cache
As funções FindFirstUrlCacheEntry e FindNextUrlCacheEntry enumeram as informações armazenadas no cache. FindFirstUrlCacheEntry inicia a enumeração usando um padrão de pesquisa, um buffer e um tamanho de buffer para criar um identificador e retornar a primeira entrada de cache. FindNextUrlCacheEntry usa o identificador criado por FindFirstUrlCacheEntry, um buffer e um tamanho de buffer para retornar a próxima entrada de cache.
Ambas as funções armazenam uma estrutura INTERNET_CACHE_ENTRY_INFO em buffer. O tamanho desta estrutura varia para cada entrada. Se o tamanho do buffer passado para qualquer uma das funções for insuficiente, a função falhará e GetLastError retornará ERROR_INSUFFICIENT_BUFFER. A variável de tamanho do buffer contém o tamanho do buffer necessário para recuperar essa entrada de cache. Um buffer do tamanho indicado pela variável de tamanho do buffer deve ser alocado e a função deve ser chamada novamente com o novo buffer.
A estrutura INTERNET_CACHE_ENTRY_INFO contém o tamanho da estrutura, URL das informações armazenadas em cache, nome do arquivo local, tipo de entrada de cache, contagem de uso, taxa de acertos, tamanho, hora da última modificação, expiração, último acesso, última hora sincronizada, informações de cabeçalho, tamanho das informações de cabeçalho e extensão de nome de arquivo.
A funçãoFindFirstUrlCacheEntry usa um padrão de pesquisa, um buffer que armazena a estrutura INTERNET_CACHE_ENTRY_INFO e o tamanho do buffer. Atualmente, apenas o padrão de pesquisa padrão, que retorna todas as entradas de cache, é implementado.
Depois que o cache é enumerado, o aplicativo deve chamar FindCloseUrlCache para fechar o identificador de enumeração de cache.
O exemplo a seguir exibe a URL de cada entrada de cache em uma caixa de listagem, IDC_CacheList. Ele usa MAX_CACHE_ENTRY_INFO_SIZE para alocar inicialmente um buffer, uma vez que as versões anteriores da API WinINet não enumeram o cache corretamente de outra forma. Versões posteriores enumeram o cache corretamente e não há limite de tamanho de cache. Todos os aplicativos executados em computadores com a versão da API WinINet do Internet Explorer 4.0 devem alocar um buffer do tamanho necessário. Para obter mais informações, consulte Usando Buffers.
int WINAPI EnumerateCacheOld(HWND hX)
{
DWORD dwEntrySize;
LPINTERNET_CACHE_ENTRY_INFO lpCacheEntry;
DWORD MAX_CACHE_ENTRY_INFO_SIZE = 4096;
HANDLE hCacheDir;
int nCount=0;
SendDlgItemMessage(hX,IDC_CacheList,LB_RESETCONTENT,0,0);
SetCursor(LoadCursor(NULL,IDC_WAIT));
dwEntrySize = MAX_CACHE_ENTRY_INFO_SIZE;
lpCacheEntry = (LPINTERNET_CACHE_ENTRY_INFO) new char[dwEntrySize];
lpCacheEntry->dwStructSize = dwEntrySize;
again:
hCacheDir = FindFirstUrlCacheEntry(NULL,
lpCacheEntry,
&dwEntrySize);
if (!hCacheDir)
{
delete[]lpCacheEntry;
switch(GetLastError())
{
case ERROR_NO_MORE_ITEMS:
TCHAR tempout[80];
_stprintf_s(tempout,
80,
TEXT("The number of cache entries = %d \n"),
nCount);
MessageBox(hX,tempout,TEXT("Cache Enumeration"),MB_OK);
FindCloseUrlCache(hCacheDir);
SetCursor(LoadCursor(NULL,IDC_ARROW));
return TRUE;
break;
case ERROR_INSUFFICIENT_BUFFER:
lpCacheEntry = (LPINTERNET_CACHE_ENTRY_INFO)
new char[dwEntrySize];
lpCacheEntry->dwStructSize = dwEntrySize;
goto again;
break;
default:
ErrorOut( hX,GetLastError(),
TEXT("FindNextUrlCacheEntry Init"));
FindCloseUrlCache(hCacheDir);
SetCursor(LoadCursor(NULL,IDC_ARROW));
return FALSE;
}
}
SendDlgItemMessage(hX,IDC_CacheList,LB_ADDSTRING,
0,(LPARAM)(lpCacheEntry->lpszSourceUrlName));
nCount++;
delete (lpCacheEntry);
do
{
dwEntrySize = MAX_CACHE_ENTRY_INFO_SIZE;
lpCacheEntry = (LPINTERNET_CACHE_ENTRY_INFO) new char[dwEntrySize];
lpCacheEntry->dwStructSize = dwEntrySize;
retry:
if (!FindNextUrlCacheEntry(hCacheDir,
lpCacheEntry,
&dwEntrySize))
{
delete[]lpCacheEntry;
switch(GetLastError())
{
case ERROR_NO_MORE_ITEMS:
TCHAR tempout[80];
_stprintf_s(tempout,
80,
TEXT("The number of cache entries = %d \n"),nCount);
MessageBox(hX,
tempout,
TEXT("Cache Enumeration"),MB_OK);
FindCloseUrlCache(hCacheDir);
return TRUE;
break;
case ERROR_INSUFFICIENT_BUFFER:
lpCacheEntry =
(LPINTERNET_CACHE_ENTRY_INFO)
new char[dwEntrySize];
lpCacheEntry->dwStructSize = dwEntrySize;
goto retry;
break;
default:
ErrorOut(hX,
GetLastError(),
TEXT("FindNextUrlCacheEntry Init"));
FindCloseUrlCache(hCacheDir);
return FALSE;
}
}
SendDlgItemMessage(hX,
IDC_CacheList,LB_ADDSTRING,
0,
(LPARAM)(lpCacheEntry->lpszSourceUrlName));
nCount++;
delete[] lpCacheEntry;
} while (TRUE);
SetCursor(LoadCursor(NULL,IDC_ARROW));
return TRUE;
}
Recuperando informações de entrada de cache
A funçãoGetUrlCacheEntryInfopermite recuperar a estrutura INTERNET_CACHE_ENTRY_INFO para a URL especificada. Essa estrutura contém o tamanho da estrutura, URL das informações armazenadas em cache, nome do arquivo local, tipo de entrada de cache, contagem de uso, taxa de acertos, tamanho, hora da última modificação, expiração, último acesso, última hora sincronizada, informações de cabeçalho, tamanho das informações de cabeçalho e extensão de nome de arquivo.
GetUrlCacheEntryInfo aceita uma URL, um buffer para uma estrutura INTERNET_CACHE_ENTRY_INFO e o tamanho do buffer. Se o URL for encontrado, as informações serão copiadas para o buffer. Caso contrário, a função falhará e GetLastError retornará ERROR_FILE_NOT_FOUND. Se o tamanho do buffer for insuficiente para armazenar as informações de entrada do cache, a função falhará e GetLastError retornará ERROR_INSUFFICIENT_BUFFER. O tamanho necessário para recuperar as informações é armazenado na variável de tamanho do buffer.
GetUrlCacheEntryInfo não faz nenhuma análise de URL, portanto, uma URL que contenha uma âncora (#) não será encontrada no cache, mesmo que o recurso esteja armazenado em cache. Por exemplo, se o URL "https://example.com/example.htm#sample" é passado, a função retorna ERROR_FILE_NOT_FOUND mesmo se "https://example.com/example.htm" está no cache.
O exemplo a seguir recupera as informações de entrada de cache para a URL especificada. Em seguida, a função exibe as informações do cabeçalho na caixa de edição IDC_CacheDump.
int WINAPI GetCacheEntryInfo(HWND hX,LPTSTR lpszUrl)
{
DWORD dwEntrySize=0;
LPINTERNET_CACHE_ENTRY_INFO lpCacheEntry;
SetCursor(LoadCursor(NULL,IDC_WAIT));
if (!GetUrlCacheEntryInfo(lpszUrl,NULL,&dwEntrySize))
{
if (GetLastError()!=ERROR_INSUFFICIENT_BUFFER)
{
ErrorOut(hX,GetLastError(),TEXT("GetUrlCacheEntryInfo"));
SetCursor(LoadCursor(NULL,IDC_ARROW));
return FALSE;
}
else
lpCacheEntry = (LPINTERNET_CACHE_ENTRY_INFO)
new char[dwEntrySize];
}
else
return FALSE; // should not be successful w/ NULL buffer
// and 0 size
if (!GetUrlCacheEntryInfo(lpszUrl,lpCacheEntry,&dwEntrySize))
{
ErrorOut(hX,GetLastError(),TEXT("GetUrlCacheEntryInfo"));
SetCursor(LoadCursor(NULL,IDC_ARROW));
return FALSE;
}
else
{
if ((lpCacheEntry->dwHeaderInfoSize)!=0)
{
LPSTR(lpCacheEntry->lpHeaderInfo)
[lpCacheEntry->dwHeaderInfoSize]=TEXT('\0');
SetDlgItemText(hX,IDC_Headers,
lpCacheEntry->lpHeaderInfo);
}
else
{
SetDlgItemText(hX,IDC_Headers,TEXT("None"));
}
SetCursor(LoadCursor(NULL,IDC_ARROW));
return TRUE;
}
}
Criando uma entrada de cache
Um aplicativo usa as funções CreateUrlCacheEntry e CommitUrlCacheEntry para criar uma entrada de cache.
CreateUrlCacheEntry aceita a URL, o tamanho esperado do arquivo e a extensão do nome do arquivo. Em seguida, a função cria um nome de arquivo local para salvar a entrada de cache que corresponde à URL e à extensão de nome de arquivo.
Usando o nome do arquivo local, escreva os dados no arquivo local. Depois que os dados tiverem sido gravados no arquivo local, o aplicativo deve chamar CommitUrlCacheEntry.
CommitUrlCacheEntry aceita a URL, o nome do arquivo local, a validade, a hora da última modificação, o tipo de entrada de cache, as informações do cabeçalho, o tamanho das informações do cabeçalho e a extensão do nome do arquivo. Em seguida, a função armazena em cache os dados no arquivo especificado no armazenamento em cache e os associa à URL fornecida.
O exemplo a seguir usa o nome do arquivo local, criado por uma chamada anterior para CreateUrlCacheEntry, armazenado na caixa de texto, IDC_LocalFile, para armazenar o texto da caixa de texto, IDC_CacheDump, na entrada de cache. Depois que os dados tiverem sido gravados no arquivo usando fopen, fprintfe fclose, a entrada será confirmada usando CommitUrlCacheEntry.
int WINAPI CommitEntry(HWND hX)
{
LPTSTR lpszUrl, lpszExt, lpszFileName;
LPTSTR lpszData,lpszSize;
DWORD dwSize;
DWORD dwEntryType=0;
FILE *lpfCacheEntry;
LPFILETIME lpdtmExpire, lpdtmLastModified;
LPSYSTEMTIME lpdtmSysTime;
errno_t err;
if( SendDlgItemMessage(hX,IDC_RBNormal,BM_GETCHECK,0,0) )
{
dwEntryType = dwEntryType + NORMAL_CACHE_ENTRY;
}
else if( SendDlgItemMessage(hX,IDC_RBSticky, BM_GETCHECK,0,0) )
{
dwEntryType = dwEntryType + STICKY_CACHE_ENTRY;
}
else if(SendDlgItemMessage( hX,IDC_RBSparse, BM_GETCHECK,0,0) )
{
dwEntryType = dwEntryType + SPARSE_CACHE_ENTRY;
}
if( SendDlgItemMessage(hX,IDC_RBCookie, BM_GETCHECK,0,0))
{
dwEntryType = dwEntryType + COOKIE_CACHE_ENTRY;
}
else if( SendDlgItemMessage(hX,IDC_RBUrl, BM_GETCHECK,0,0) )
{
dwEntryType = dwEntryType + URLHISTORY_CACHE_ENTRY;
}
if( SendDlgItemMessage(hX,IDC_RBNone, BM_GETCHECK,0,0) )
{
dwEntryType=0;
}
lpdtmSysTime = new SYSTEMTIME;
lpdtmExpire = new FILETIME;
lpdtmLastModified = new FILETIME;
GetLocalTime(lpdtmSysTime);
SystemTimeToFileTime(lpdtmSysTime,lpdtmExpire);
SystemTimeToFileTime(lpdtmSysTime,lpdtmLastModified);
delete(lpdtmSysTime);
lpszUrl = new TCHAR[MAX_PATH];
lpszFileName = new TCHAR[MAX_PATH];
lpszExt = new TCHAR[5];
lpszSize = new TCHAR[10];
GetDlgItemText(hX,IDC_SourceURL,lpszUrl,MAX_PATH);
GetDlgItemText(hX,IDC_LocalFile,lpszFileName,MAX_PATH);
GetDlgItemText(hX,IDC_FileExt,lpszExt,5);
GetDlgItemText(hX,IDC_SizeLow,lpszSize,10);
dwSize = (DWORD)_ttol(lpszSize);
delete(lpszSize);
if (dwSize==0)
{
if((MessageBox(hX,
TEXT("Incorrect File Size.\nUsing 8000 characters, Okay?\n"),
TEXT("Commit Entry"),MB_YESNO))
==IDYES)
{
dwSize = 8000;
}
else
{
return FALSE;
}
}
lpszData = new TCHAR[dwSize];
GetDlgItemText(hX,IDC_CacheDump,lpszData,dwSize);
err = _tfopen_s(&lpfCacheEntry,lpszFileName,_T("w"));
if (err)
return FALSE;
fprintf(lpfCacheEntry,"%s",lpszData);
fclose(lpfCacheEntry);
delete(lpszData);
if ( !CommitUrlCacheEntry( lpszUrl,
lpszFileName,
*lpdtmExpire,
*lpdtmLastModified,
dwEntryType,
NULL,
0,
lpszExt,
0) )
{
ErrorOut(hX,GetLastError(),TEXT("Commit Cache Entry"));
delete(lpszUrl);
delete(lpszFileName);
delete(lpszExt);
delete(lpdtmExpire);
delete(lpdtmLastModified);
return FALSE;
}
else
{
delete(lpszUrl);
delete(lpszFileName);
delete(lpszExt);
delete(lpdtmExpire);
delete(lpdtmLastModified);
return TRUE;
}
}
Excluindo uma entrada de cache
A funçãoDeleteUrlCacheEntry usa uma URL e remove o arquivo de cache associado a ela. Se o arquivo de cache não existir, a função falhará e GetLastError retornará ERROR_FILE_NOT_FOUND. Se o arquivo de cache estiver bloqueado ou em uso, a função falhará e GetLastError retornará ERROR_ACCESS_DENIED. O arquivo é excluído quando desbloqueado.
Recuperando arquivos de entrada de cache
Para aplicações que exigem o nome de ficheiro de um recurso, use as funções RetrieveUrlCacheEntryFile e UnlockUrlCacheEntryFile. Os aplicativos que não exigem o nome do arquivo devem usar as funções RetrieveUrlCacheEntryStream, ReadUrlCacheEntryStreame UnlockUrlCacheEntryStream para recuperar as informações no cache.
RetrieveUrlCacheEntryStream não faz nenhuma análise de URL, portanto, uma URL que contém uma âncora (#) não será encontrada no cache, mesmo que o recurso esteja armazenado em cache. Por exemplo, se o URL "https://example.com/example.htm#sample" é passado, a função retorna ERROR_FILE_NOT_FOUND mesmo se "https://example.com/example.htm" está no cache.
RetrieveUrlCacheEntryFile aceita uma URL, um buffer que armazena a estrutura INTERNET_CACHE_ENTRY_INFO e o tamanho do buffer. A função é recuperada e bloqueada para o chamador.
Depois que as informações no arquivo tiverem sido usadas, o aplicativo deve chamar UnlockUrlCacheEntryFile para desbloquear o arquivo.
Grupos de cache
Para criar um grupo de cache, a funçãoCreateUrlCacheGroup deve ser chamada para gerar um GROUPID para o grupo de cache. As entradas podem ser adicionadas ao grupo de cache fornecendo a URL da entrada de cache e o sinalizador INTERNET_CACHE_GROUP_ADD para a função SetUrlCacheEntryGroup. Para remover uma entrada de cache de um grupo, passe a URL da entrada de cache e o sinalizador INTERNET_CACHE_GROUP_REMOVE para SetUrlCacheEntryGroup.
As funções FindFirstUrlCacheEntryEx e FindNextUrlCacheEntryEx podem ser usadas para enumerar as entradas em um grupo de cache especificado. Depois que a enumeração for concluída, a função deve chamar FindCloseUrlCache.
Gestão de estruturas com tamanho variável de informação
O cache pode conter informações de tamanho variável para cada URL armazenado. Isto reflete-se na estrutura INTERNET_CACHE_ENTRY_INFO. Quando as funções de cache retornam essa estrutura, elas criam um buffer que é sempre do tamanho de INTERNET_CACHE_ENTRY_INFO mais qualquer informação de tamanho variável. Se um membro do ponteiro não estiver NULL , ele apontará para a área de memória imediatamente após a estrutura. Ao copiar o buffer retornado por uma função para outro buffer, os membros do ponteiro devem ser fixados para apontar para o local apropriado no novo buffer, como mostra o exemplo a seguir.
lpDstCEInfo->lpszSourceUrlName =
(LPINTERNET_CACHE_ENTRY_INFO) ((LPBYTE) lpSrcCEInfo +
((DWORD)(lpOldCEInfo->lpszSourceUrlName) - (DWORD)lpOldCEInfo));
Algumas funções de cache falham com a mensagem de erro ERROR_INSUFFICIENT_BUFFER se você especificar um buffer que é muito pequeno para conter as informações de entrada de cache recuperadas pela função. Nesse caso, a função também retorna o tamanho necessário do buffer. Em seguida, você pode alocar um buffer do tamanho apropriado e chamar a função novamente.
Observação
WinINet não suporta implementações de servidor. Além disso, não deve ser usado num serviço. Para implementações ou serviços de servidor, use Microsoft Windows HTTP Services (WinHTTP).