Freigeben über

Zwischenspeichern (Windows Internet)

  • Artikel

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.

Wert Bedeutung
INTERNET_FLAG_CACHE_ASYNC Dieses Flag hat keine Wirkung.
INTERNET_FLAG_CACHE_IF_NET_FAIL Gibt die Ressource aus dem Cache zurück, wenn die Netzwerkanforderung für die Ressource aufgrund eines ERROR_INTERNET_CONNECTION_RESET- oder ERROR_INTERNET_CANNOT_CONNECT-Fehlers fehlschlägt. Dieses Flag wird von HttpOpenRequest verwendet.
INTERNET_FLAG_DONT_CACHE Speichert die Daten weder lokal noch in Gateways zwischen. Identisch mit dem bevorzugten Wert , INTERNET_FLAG_NO_CACHE_WRITE.
Gibt an, dass es sich um eine Formularübermittlung handelt.
INTERNET_FLAG_FROM_CACHEINTERNET_FLAG_FORMS_SUBMIT Stellt keine Netzwerkanforderungen. Alle Entitäten werden aus dem Cache zurückgegeben. Wenn sich das angeforderte Element nicht im Cache befindet, wird ein geeigneter Fehler wie ERROR_FILE_NOT_FOUND zurückgegeben. Nur die InternetOpen-Funktion verwendet dieses Flag.
INTERNET_FLAG_FWD_BACK Gibt an, dass die Funktion die Kopie der Ressource verwenden soll, die sich derzeit im Internetcache befindet. Das Ablaufdatum und andere Informationen zur Ressource werden nicht überprüft. Wenn das angeforderte Element nicht im Internetcache gefunden wird, versucht das System, die Ressource im Netzwerk zu suchen. Dieser Wert wurde in Microsoft Internet Explorer 5 eingeführt und ist den Schaltflächenvorgängen Vorwärts und Zurück von Internet Explorer zugeordnet.
INTERNET_FLAG_HYPERLINK Erzwingt die Anwendung, eine Ressource neu zu laden, wenn keine Ablaufzeit und keine Zeit der letzten Änderung zurückgegeben wurde, als die Ressource im Cache gespeichert wurde.
INTERNET_FLAG_MAKE_PERSISTENT Wird nicht mehr unterstützt.
INTERNET_FLAG_MUST_CACHE_REQUEST Bewirkt, dass eine temporäre Datei erstellt wird, wenn die Datei nicht zwischengespeichert werden kann. Dies ist identisch mit dem bevorzugten Wert , INTERNET_FLAG_NEED_FILE.
INTERNET_FLAG_NEED_FILE Bewirkt, dass eine temporäre Datei erstellt wird, wenn die Datei nicht zwischengespeichert werden kann.
INTERNET_FLAG_NO_CACHE_WRITE Lehnt jeden Versuch der Funktion ab, aus dem Internet heruntergeladene Daten im Cache zu speichern. Dieses Flag ist erforderlich, wenn die Anwendung nicht möchte, dass heruntergeladene Ressourcen lokal gespeichert werden.
INTERNET_FLAG_NO_UI Deaktiviert das Cookie-Dialogfeld. Dieses Flag kann von HttpOpenRequest und InternetOpenUrl (nur HTTP-Anforderungen) verwendet werden.
INTERNET_FLAG_OFFLINE Verhindert, dass die Anwendung Anforderungen an das Netzwerk sendet. Alle Anforderungen werden mithilfe der im Cache gespeicherten Ressourcen aufgelöst. Wenn sich die Ressource nicht im Cache befindet, wird ein geeigneter Fehler wie ERROR_FILE_NOT_FOUND zurückgegeben.
INTERNET_FLAG_PRAGMA_NOCACHE Erzwingt, dass die Anforderung vom Ursprungsserver aufgelöst wird, auch wenn eine zwischengespeicherte Kopie auf dem Proxy vorhanden ist. Die InternetOpenUrl-Funktion (nur für HTTP- und HTTPS-Anforderungen) und die HttpOpenRequest-Funktion verwenden dieses Flag.
INTERNET_FLAG_RELOAD Erzwingt die Funktion, die angeforderte Ressource direkt aus dem Internet abzurufen. Die heruntergeladenen Informationen werden im Cache gespeichert.
INTERNET_FLAG_RESYNCHRONIZE Bewirkt, dass eine Anwendung einen bedingten Download der Ressource aus dem Internet durchführt. Wenn die im Cache gespeicherte Version aktuell ist, werden die Informationen aus dem Cache heruntergeladen. Andernfalls werden die Informationen vom Server neu geladen.

 

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.

Funktion Beschreibung
CommitUrlCacheEntryA Speichert Daten in der angegebenen Datei im Cachespeicher zwischen und ordnet sie der angegebenen URL zu.
CommitUrlCacheEntryW Speichert Daten in der angegebenen Datei im Cachespeicher zwischen und ordnet sie der angegebenen URL zu.
CreateUrlCacheEntry Ordnet den angeforderten Cachespeicher zu und erstellt einen lokalen Dateinamen zum Speichern des Cacheeintrags, der dem Quellnamen entspricht.
CreateUrlCacheGroup Generiert eine Cachegruppenidentifikation.
DeleteUrlCacheEntry Entfernt die Datei, die dem Quellnamen zugeordnet ist, aus dem Cache, sofern die Datei vorhanden ist.
DeleteUrlCacheGroup Gibt eine GROUPID und jeden zugeordneten Zustand in der Cacheindexdatei frei.
FindCloseUrlCache Schließt das angegebene Enumerationshandle.
FindFirstUrlCacheEntry Beginnt mit der Enumeration des Caches.
FindFirstUrlCacheEntryEx Startet eine gefilterte Enumeration des Caches.
FindNextUrlCacheEntry Ruft den nächsten Eintrag im Cache ab.
FindNextUrlCacheEntryEx Ruft den nächsten Eintrag in einer gefilterten Cacheaufzählung ab.
GetUrlCacheEntryInfo Ruft Informationen zu einem Cacheeintrag ab.
GetUrlCacheEntryInfoEx Sucht nach der URL, nachdem zwischengespeicherte Umleitungen übersetzt wurden, die im Offlinemodus von HttpSendRequest angewendet würden.
ReadUrlCacheEntryStream Liest die zwischengespeicherten Daten aus einem Stream, der mit RetrieveUrlCacheEntryStream geöffnet wurde.
RetrieveUrlCacheEntryFile Ruft einen Cacheeintrag aus dem Cache in Form einer Datei ab.
RetrieveUrlCacheEntryStream Bietet die effizienteste und implementierungsunabhängige Methode für den Zugriff auf die Cachedaten.
SetUrlCacheEntryGroup Fügt Einträge aus einer Cachegruppe hinzu oder entfernt sie.
SetUrlCacheEntryInfo Legt die angegebenen Member der INTERNET_CACHE_ENTRY_INFO-Struktur fest.
UnlockUrlCacheEntryFile Entsperrt den Cacheeintrag, der gesperrt wurde, als die Datei von RetrieveUrlCacheEntryFile zur Verwendung aus dem Cache abgerufen wurde.
UnlockUrlCacheEntryStream Schließt den Stream, der mit RetrieveUrlCacheEntryStream abgerufen wurde.

 

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.

Hinweis

WinINet unterstützt keine Serverimplementierungen. Darüber hinaus sollte es nicht von einem Dienst aus verwendet werden. Verwenden Sie für Serverimplementierungen oder Dienste Microsoft Windows HTTP Services (WinHTTP).