Zwischenspeichern (Windows Internet)

Die WinINet-Funktionen verfügen über eine einfache, aber flexible integrierte Zwischenspeicherungsunterstützung. Alle aus dem Netzwerk abgerufenen Daten werden auf der Festplatte zwischengespeichert und für nachfolgende Anforderungen abgerufen. Die Anwendung kann die Zwischenspeicherung für jede Anforderung steuern. Bei HTTP-Anforderungen vom Server werden die meisten empfangenen Header ebenfalls zwischengespeichert. Wenn eine HTTP-Anforderung aus dem Cache erfüllt wird, werden auch die zwischengespeicherten Header an den Aufrufer zurückgegeben. Dadurch wird der Datendownload nahtlos, unabhängig davon, ob die Daten aus dem Cache oder aus dem Netzwerk stammen.

Anwendungen müssen einen Puffer ordnungsgemäß zuordnen, um die gewünschten Ergebnisse bei Verwendung der Zwischenspeicherungsfunktionen für persistente URL zu erzielen. Weitere Informationen finden Sie unter Verwenden von Puffern.

Cacheverhalten während der Antwortverarbeitung

Der WinINet-Cache ist mit den HTTP-Cachesteuerungsdirektiven kompatibel, die in RFC 2616 beschrieben sind. Die Cachesteuerungsdirektiven und Anwendungssatzflags bestimmen, was zwischengespeichert werden kann. WinINet bestimmt jedoch anhand des folgenden Kriteriums, was tatsächlich zwischengespeichert wird:

• WinINet speichert nur HTTP- und FTP-Antworten zwischen.
• Nur gut verhaltende Antworten können von einem Cache gespeichert und in einer Antwort auf eine nachfolgende Anforderung verwendet werden. Gut verhaltende Antworten werden als Antworten definiert, die erfolgreich zurückgegeben werden.
• Standardmäßig zwischenspeichert WinINet erfolgreiche Antworten, es sei denn, eine Cachesteuerungsdirektive vom Server oder ein anwendungsdefiniertes Flag gibt ausdrücklich an, dass die Antwort möglicherweise nicht zwischengespeichert wird.
• Im Allgemeinen werden Antworten auf das GET-Verb zwischengespeichert, wenn die oben aufgeführten Anforderungen erfüllt sind. Antworten auf PUT- und POST-Verben werden unter keinen Umständen zwischengespeichert.
• Elemente werden auch dann zwischengespeichert, wenn der Cache voll ist. Wenn ein hinzugefügtes Element den Cache über das Größenlimit legt, wird der Cache-Scavenger geplant. Standardmäßig ist nicht garantiert, dass Elemente länger als 10 Minuten im Cache verbleiben. Weitere Informationen finden Sie weiter unten im Abschnitt Cache Scavenger .
• Https wird standardmäßig zwischengespeichert. Dies wird durch eine globale Einstellung verwaltet, die nicht durch anwendungsdefinierte Cachedirektiven überschrieben werden kann. Um die globale Einstellung zu überschreiben, wählen Sie in der Systemsteuerung das Applet Internetoptionen aus, und wechseln Sie zur Registerkarte Erweitert. Aktivieren Sie das Kontrollkästchen "Verschlüsselte Seiten nicht auf Datenträger speichern" im Abschnitt "Sicherheit".

Cache Scavenger

Der Cache-Abscheider bereinigt regelmäßig Elemente aus dem Cache. Wenn dem Cache ein Element hinzugefügt wird und der Cache voll ist, wird das Element dem Cache hinzugefügt, und die Cache-Abscheidung wird geplant. Wenn der Cache-Scavenger eine Runde des Auffangens abgeschlossen hat und der Cache das Cachelimit nicht erreicht hat, wird der Scavenger für eine weitere Runde geplant, wenn dem Cache ein weiteres Element hinzugefügt wird. Im Allgemeinen wird der Scavenger geplant, wenn ein hinzugefügtes Element den Cache über sein Größenlimit legt. Standardmäßig ist die Mindestdauer für das Leben im Cache auf 10 Minuten festgelegt, sofern in einer Cachesteuerungsdirektive nichts anderes angegeben ist. Wenn der Cachefänger initiiert wird, gibt es keine Garantie dafür, dass die ältesten Elemente die ersten sind, die aus dem Cache gelöscht werden.

Der Cache wird für alle WinINet-Anwendungen auf dem Computer für denselben Benutzer freigegeben. Ab Windows Vista und Windows Server 2008 wird die Cachegröße auf 1/32 der Größe des Datenträgers festgelegt, mit einer Mindestgröße von 8 MB und einer maximalen Größe von 50 MB.

Verwenden von Flags zum Steuern der Zwischenspeicherung

Mithilfe der Zwischenspeicherungsflags kann eine Anwendung steuern, wann und wie sie den Cache verwendet. Diese Flags können allein oder in Kombination mit dem dwFlags-Parameter in Funktionen verwendet werden, die auf Informationen oder Ressourcen im Internet zugreifen. Standardmäßig speichern die Funktionen alle aus dem Internet heruntergeladenen Daten.

Die folgenden Flags können zum Steuern der Zwischenspeicherung verwendet werden.

Persistente Zwischenspeicherungsfunktionen

Clients, die dienste für persistentes Zwischenspeichern benötigen, verwenden die Funktionen für die persistente Zwischenspeicherung, damit ihre Anwendungen Daten für die spätere Verwendung im lokalen Dateisystem speichern können, z. B. in Situationen, in denen eine Verbindung mit geringer Bandbreite den Zugriff auf die Daten einschränkt oder der Zugriff überhaupt nicht verfügbar ist.

Die Cachefunktionen bieten dauerhaftes Zwischenspeichern und Offline-Browsen. Sofern das Flag INTERNET_FLAG_NO_CACHE_WRITE nicht explizit keine Zwischenspeicherung angibt, speichern die Funktionen alle aus dem Netzwerk heruntergeladenen Daten zwischen. Die Antworten auf POST-Daten werden nicht zwischengespeichert.

Verwenden der Cachefunktionen für persistente URL

Die folgenden Cachefunktionen für persistente URL ermöglichen es einer Anwendung, auf im Cache gespeicherte Informationen zuzugreifen und diese zu bearbeiten.

Auflisten des Caches

Die Funktionen FindFirstUrlCacheEntry und FindNextUrlCacheEntry listen die im Cache gespeicherten Informationen auf. FindFirstUrlCacheEntry startet die Enumeration, indem ein Suchmuster, ein Puffer und eine Puffergröße verwendet werden, um ein Handle zu erstellen und den ersten Cacheeintrag zurückzugeben. FindNextUrlCacheEntry verwendet das von FindFirstUrlCacheEntry erstellte Handle, einen Puffer und eine Puffergröße, um den nächsten Cacheeintrag zurückzugeben.

Beide Funktionen speichern eine INTERNET_CACHE_ENTRY_INFO-Struktur im Puffer. Die Größe dieser Struktur variiert für jeden Eintrag. Wenn die an eine Funktion übergebene Puffergröße nicht ausreicht, schlägt die Funktion fehl, und GetLastError gibt ERROR_INSUFFICIENT_BUFFER zurück. Die Puffergrößenvariable enthält die Puffergröße, die zum Abrufen dieses Cacheeintrags benötigt wurde. Ein Puffer der größe, die durch die Puffergrößenvariable angegeben ist, sollte zugeordnet werden, und die Funktion sollte mit dem neuen Puffer erneut aufgerufen werden.

Die INTERNET_CACHE_ENTRY_INFO-Struktur enthält die Strukturgröße, die URL der zwischengespeicherten Informationen, den lokalen Dateinamen, den Cacheeintragstyp, die Anzahl der Verwendung, die Trefferrate, die Größe der letzten Änderung, den Ablauf, den letzten Zugriff, die uhrzeit der letzten Synchronisierung, headerinformationen, die Größe der Headerinformationen und die Dateinamenerweiterung.

Die FindFirstUrlCacheEntry-Funktion verwendet ein Suchmuster, einen Puffer, in dem die INTERNET_CACHE_ENTRY_INFO-Struktur und die Puffergröße gespeichert werden. Derzeit ist nur das Standardsuchmuster implementiert, das alle Cacheeinträge zurückgibt.

Nachdem der Cache aufgezählt wurde, sollte die Anwendung FindCloseUrlCache aufrufen, um das Handle für die Cacheenumeration zu schließen.

Im folgenden Beispiel wird die URL jedes Cacheeintrags in einem Listenfeld IDC_CacheList angezeigt. Es verwendet MAX_CACHE_ENTRY_INFO_SIZE, um zunächst einen Puffer zuzuweisen, da frühe Versionen der WinINet-API den Cache andernfalls nicht ordnungsgemäß auflisten. In späteren Versionen wird der Cache ordnungsgemäß aufgelistet, und es gibt keine Größenbeschränkung für den Cache. Alle Anwendungen, die auf Computern mit der Version der WinINet-API von Internet Explorer 4.0 ausgeführt werden, müssen einen Puffer der erforderlichen Größe zuweisen. Weitere Informationen finden Sie unter Verwenden von Puffern.

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;        
}

Abrufen von Cacheeintragsinformationen

Mit der GetUrlCacheEntryInfo-Funktion können Sie die INTERNET_CACHE_ENTRY_INFO-Struktur für die angegebene URL abrufen. Diese Struktur enthält die Strukturgröße, die URL der zwischengespeicherten Informationen, den lokalen Dateinamen, den Cacheeintragstyp, die Anzahl der Verwendung, die Trefferrate, die Größe, die Zeit der letzten Änderung, den Ablauf, den letzten Zugriff, die letzte synchronisierte Zeit, Headerinformationen, die Größe der Headerinformationen und die Dateinamenerweiterung.

GetUrlCacheEntryInfo akzeptiert eine URL, einen Puffer für eine INTERNET_CACHE_ENTRY_INFO-Struktur und die Puffergröße. Wenn die URL gefunden wird, werden die Informationen in den Puffer kopiert. Andernfalls schlägt die Funktion fehl, und GetLastError gibt ERROR_FILE_NOT_FOUND zurück. Wenn die Puffergröße nicht ausreicht, um die Cacheeintragsinformationen zu speichern, schlägt die Funktion fehl, und GetLastError gibt ERROR_INSUFFICIENT_BUFFER zurück. Die zum Abrufen der Informationen erforderliche Größe wird in der Puffergrößenvariablen gespeichert.

GetUrlCacheEntryInfo führt keine URL-Analyse durch, sodass eine URL, die einen Anker (#) enthält, nicht im Cache gefunden wird, auch wenn die Ressource zwischengespeichert ist. Beispielsweise, wenn die URL "https://example.com/example.htm#sample" wird übergeben, gibt die Funktion ERROR_FILE_NOT_FOUND zurück, auch wenn "https://example.com/example.htm" befindet sich im Cache.

Im folgenden Beispiel werden die Cacheeintragsinformationen für die angegebene URL abgerufen. Die Funktion zeigt dann die Kopfzeileninformationen im IDC_CacheDump Bearbeitungsfeld an.

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;
    }
        
}

Erstellen eines Cacheeintrags

Eine Anwendung verwendet die Funktionen CreateUrlCacheEntry und CommitUrlCacheEntry , um einen Cacheeintrag zu erstellen.

CreateUrlCacheEntry akzeptiert die URL, die erwartete Dateigröße und die Dateinamenerweiterung. Die Funktion erstellt dann einen lokalen Dateinamen zum Speichern des Cacheeintrags, der der URL und der Dateinamenerweiterung entspricht.

Schreiben Sie die Daten mithilfe des lokalen Dateinamens in die lokale Datei. Nachdem die Daten in die lokale Datei geschrieben wurden, sollte die Anwendung CommitUrlCacheEntry aufrufen.

CommitUrlCacheEntry akzeptiert die URL, den lokalen Dateinamen, den Ablauf, die Uhrzeit der letzten Änderung, den Cacheeintragstyp, die Headerinformationen, die Größe der Headerinformationen und die Dateinamenerweiterung. Die Funktion speichert dann Daten in der im Cachespeicher angegebenen Datei zwischen und ordnet sie der angegebenen URL zu.

Im folgenden Beispiel wird der lokale Dateiname verwendet, der durch einen vorherigen Aufruf von CreateUrlCacheEntry erstellt wurde und im Textfeld IDC_LocalFile gespeichert wurde, um den Text aus dem Textfeld IDC_CacheDump im Cacheeintrag zu speichern. Nachdem die Daten mithilfe von fopen, fprintf und fclose in die Datei geschrieben wurden, wird der Eintrag mit CommitUrlCacheEntry committet.

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;
    }
}

Löschen eines Cacheeintrags

Die DeleteUrlCacheEntry-Funktion akzeptiert eine URL und entfernt die ihr zugeordnete Cachedatei. Wenn die Cachedatei nicht vorhanden ist, schlägt die Funktion fehl, und GetLastError gibt ERROR_FILE_NOT_FOUND zurück. Wenn die Cachedatei derzeit gesperrt oder verwendet wird, schlägt die Funktion fehl, und GetLastError gibt ERROR_ACCESS_DENIED zurück. Die Datei wird gelöscht, wenn sie entsperrt wird.

Abrufen von Cacheeintragsdateien

Verwenden Sie für Anwendungen, die den Dateinamen einer Ressource erfordern, die Funktionen RetrieveUrlCacheEntryFile und UnlockUrlCacheEntryFile . Anwendungen, die den Dateinamen nicht benötigen, sollten die Funktionen RetrieveUrlCacheEntryStream, ReadUrlCacheEntryStream und UnlockUrlCacheEntryStream verwenden, um die Informationen im Cache abzurufen.

RetrieveUrlCacheEntryStream führt keine URL-Analyse durch, sodass eine URL, die einen Anker (#) enthält, nicht im Cache gefunden wird, auch wenn die Ressource zwischengespeichert ist. Beispielsweise, wenn die URL "https://example.com/example.htm#sample" wird übergeben, gibt die Funktion ERROR_FILE_NOT_FOUND zurück, auch wenn "https://example.com/example.htm" befindet sich im Cache.

RetrieveUrlCacheEntryFile akzeptiert eine URL, einen Puffer, in dem die INTERNET_CACHE_ENTRY_INFO-Struktur und die Puffergröße gespeichert werden. Die Funktion wird für den Aufrufer abgerufen und gesperrt.

Nachdem die Informationen in der Datei verwendet wurden, sollte die Anwendung UnlockUrlCacheEntryFile aufrufen, um die Datei zu entsperren.

Cachegruppen

Um eine Cachegruppe zu erstellen, muss die CreateUrlCacheGroup-Funktion aufgerufen werden, um eine GROUPID für die Cachegruppe zu generieren. Einträge können der Cachegruppe hinzugefügt werden, indem die URL des Cacheeintrags und das INTERNET_CACHE_GROUP_ADD-Flag für die Funktion SetUrlCacheEntryGroup angegeben werden. Um einen Cacheeintrag aus einer Gruppe zu entfernen, übergeben Sie die URL des Cacheeintrags und das INTERNET_CACHE_GROUP_REMOVE-Flag an SetUrlCacheEntryGroup.

Die Funktionen FindFirstUrlCacheEntryEx und FindNextUrlCacheEntryEx können verwendet werden, um die Einträge in einer angegebenen Cachegruppe aufzulisten. Nach Abschluss der Enumeration sollte die Funktion FindCloseUrlCache aufrufen.

Behandeln von Strukturen mit Variablengrößeninformationen

Der Cache kann Variablengrößeninformationen für jede gespeicherte URL enthalten. Dies spiegelt sich in der INTERNET_CACHE_ENTRY_INFO-Struktur wider. Wenn die Cachefunktionen diese Struktur zurückgeben, erstellen sie einen Puffer, der immer die Größe von INTERNET_CACHE_ENTRY_INFO und alle Variablengrößeninformationen aufweist. Wenn ein Zeigermember nicht NULL ist, zeigt es auf den Speicherbereich unmittelbar nach der Struktur. Beim Kopieren des von einer Funktion zurückgegebenen Puffers in einen anderen Puffer sollten die Zeigermember so festgelegt werden, dass sie auf die entsprechende Stelle im neuen Puffer zeigen, wie das folgende Beispiel zeigt.

lpDstCEInfo->lpszSourceUrlName = 
    (LPINTERNET_CACHE_ENTRY_INFO) ((LPBYTE) lpSrcCEInfo + 
       ((DWORD)(lpOldCEInfo->lpszSourceUrlName) - (DWORD)lpOldCEInfo));

Einige Cachefunktionen schlagen mit der ERROR_INSUFFICIENT_BUFFER Fehlermeldung fehl, wenn Sie einen Puffer angeben, der zu klein ist, um die von der Funktion abgerufenen Cacheeintragsinformationen zu enthalten. In diesem Fall gibt die Funktion auch die erforderliche Größe des Puffers zurück. Anschließend können Sie einen Puffer der entsprechenden Größe zuordnen und die Funktion erneut aufrufen.