Glengamoi (Forum) · AspHeute · .NET Heute (RSS-Suche) · AspxFiles (Wiki) · .NET Blogs

Zwischenspeichern von ASP Seiten

Geschrieben von: Christian Koller
Kategorie: ASP Tricks

This printed page brought to you by AlphaSierraPapa

Wenn eine ASP Seite aufgerufen wird, so wird das Ergebnis (als HTML) an den aufrufenden Browser geschickt. Normalerweise schickt der Webserver die Ergebnis-Seite nach Belieben, Stück für Stück, zum Browser.

"Zwischenspeichern" (oder "Puffern") von ASP-Seiten bedeutet nun, daß das Ergebnis einer ASP Seite (oder Teile davon) solange im Webserver-Cache zwischengespeichert wird, bis die ASP-Seite komplett ausgeführt wurde, oder die ASP Seite explizit den Befehl zum Senden des Inhaltes (aus dem Zwischenspeicher) zum Browser gibt.

Ein ASP Skript kann nicht nur steuern, ob und wann das Puffern der Ergebnis-Seite erfolgen soll. Aus einer ASP Seite heraus kann man genau steuern, wann das Senden des Zwischenspeicher-Inhaltes zu erfolgen hat. Darüber hinaus kann man den Zwischenspeicher aus ASP heraus löschen.

Wann in der ASP-Programmierung hat man nun mit dem Puffern von Seiten zu tun, und wo kann man es sinnvoll einsetzen?

Webseiten schneller darstellen

Eine interessante Tatsache ist, daß der komplette Inhalt einer Webseite schneller im Browser angezeigt wird, wenn man die Ausgabe puffert. Dies ist eine Konsequenz der Art und Weise, wie Webserver und Browser während eines Seitenaufrufes kommunizieren; bei nicht-gepuffertem Output werden viele kleine Pakete geschickt, bei eingeschaltetem hingegen am Ende Transfer-optimierte Pakete. Weiters kommt hinzu, daß der Server während der Abarbeitung des Skripts nicht mit dem Schicken von Daten belastet ist.

Um die Ausgabe einer ASP-Seite zu puffern kann man den Befehl Response.Buffer = True benutzen. Dieses Kommando sollte ganz am Anfang der ASP-Seite, gleich nach den (optionalen) @-Direktiven, angeführt sein:

<% @ LANGUAGE="VBScript" ENABLESESSIONSTATE=FALSE %>
<% 
Option Explicit

Response.Buffer = True

%>

...

Sämtliche Ausgaben der ASP-Seite werden nach dem Befehl Response.Buffer = True erst einmal im Server Cache zwischengespeichert und deshalb (vorläufig) nicht zum Browser geschickt. Durch den Befehl Response.Buffer = False kann man das Zwischenspeichern wieder abstellen.

Will man den angesammelten Inhalt des Zwischenspeichers zum Browser schicken, so benutzt man den Befehl Response.Flush. Um hingegen den Inhalt des Zwischenspeichers zu löschen, führt man Response.Clear aus. Ein implizites Response.Flush wird auch dann ausgeführt (und somit der Inhalt des Speichers zum Browser geschickt), wenn die ASP-Seite zur Gänze abgearbeitet wurde. Das gleiche gilt auch dann, wenn die Ausführung der ASP-Seite mit dem Befehl Response.End abgebrochen wird.

Das folgende Beispiel-Skript soll die Interaktionen der einzelnen Befehle mit dem Zwischenspeicher verdeutlichen:

<% @ LANGUAGE="VBScript" ENABLESESSIONSTATE=FALSE %>
<% 
Option Explicit

' Zwischenspeicher einschalten
Response.Buffer = True

' Text A ausgeben
Response.Write "Text A wird (in den Zwischenspeicher) geschrieben.<br>"

' Zwischenspeicher loeschen
Response.Clear

' Text B ausgeben
Response.Write "Text B wird (abermals in den Zwischenspeicher) " & _
               "geschrieben.<br>"

' Inhalt des Zwischenspeichers (nur Text B) zum Browser schicken
Response.Flush

' Text C ausgeben
Response.Write "Kurzer Text C.<br>"

' Ende der ASP-Seite: Verbliebener Inhalt aus dem Zwischenspeicher 
'    wird automatisch zum Browser geschickt
%>

Die Ausgabe dieser ASP-Seite sieht dann wie folgt aus:

Text B wird (abermals in den Zwischenspeicher) geschrieben.
Kurzer Text C.

Der Text A wird gar nicht zum Browser geschickt, da er mit dem Response.Clear Befehl aus dem Zwischenspeicher gelöscht wurde. Wann immer Response.Clear aufgerufen wird, löscht es den Zwischenspeicher. Bereits davor (mit Response.Flush) zum Browser gesendeter Inhalt kann dadurch natürlich nicht gelöscht werden.

Nachträgliche Fehlermeldungen

Wie bereits kurz gezeigt ist es möglich, einen Teil der Seite bereits (in den Puffer) auszugeben, um dann in bestimmten Situationen den Puffer-Inhalt zu löschen. Ein Paradebeispiel dafür ist, wenn man eine beim Auftreten eines Fehlers eine Fehlermeldung statt der normalen Seite anzeigen will.

Das folgende Skript enthält eine Fehlerbehandlung, die statt dem bereits von der ASP-Seite ausgegebenen HTML Code nur eine Fehlermeldung zum Browser schickt. Dies erreicht das Skript, indem der Fehlerbehandlungs Code den Zwischenspeicher löscht und anschließend die Fehlermeldung ausgibt. Voraussetzung ist natürlich, daß der gesamte bisher ausgegebene HTML Code sich noch im Zwischenspeicher befindet und nicht zum Browser gesendet wurde:

<% 
' HTML Ausgabe in Zwischenspeicher umleiten
Response.Buffer = True 
%>

<HTML>
<BODY>
Normale HTML Ausgabe ...<br>

<%
' Fehlerbehandlungsroutine beginnt
On Error Resume Next

' Das Script produziert einen Fehler,
'   daher gibt Err.Number einen Wert ungleich 0 zurueck 
If Err.Number <> 0 Then
    ' Zwischenspeicher loeschen
    Response.Clear
 
    ' Fehlermeldung ausgeben 
    Response.Write "Im Skript ist ein Fehler aufgetreten..."
    Response.End   ' beendet das Script
End If
%>

Weiterer Text
</BODY>
</HTML>

Wenn kein Fehler auftritt, so wird folgendes Ergebnis zum Browser geschickt:

Normale HTML Ausgabe ...
Weiterer Text

Wenn jedoch ein Fehler auftritt, so wird die bisherige HTML Ausgabe gelöscht und stattdessen nur die folgende Fehlermeldung ausgegeben:

Im Skript ist ein Fehler aufgetreten...

Nachträgliche Umleitung mit Response.Redirect

Wenn man einmal in die Situation kommt, in einer ASP-Seite eine Umleitung (engl. redirect) zu einer anderen Internetseite einzubauen, so ist diese Umleitung (mit Hilfe der Methode Response.Redirect) nur dann möglich, wenn noch kein Seiteninhalt zum Browser geschrieben wurde.

Dies bedeutet für gewöhnlich, daß der Response.Redirect Befehl in der ASP Seite vor dem ersten Response.Write und vor dem ersten HTML-Teil stehen muß! Mit einem gewollten Zwischenspeichern des Seiteninhaltes ist es jedoch möglich, eine Umleitung an beliebiger Stelle der ASP Seite zu plazieren.

Dies erreicht man dadruch, daß man alle HTML-Ausgaben mit Response.Buffer = True in den Zwischenspeicher umleitet. Um nun an einer beliebigen Stelle der ASP-Seite den Befehl Response.Redirect ausführen zu können, löscht man den Zwischenspeicher des Webservers und schickt die Anweisung zur Seiten-Umleitung (mit einem Response.Redirect Befehl) zum Browser:

<% 
' HTML Ausgabe in Zwischenspeicher umleiten
Response.Buffer = True 
%>

<HTML>
<BODY>
Normale HTML Ausgabe ...<br>

<%

' Aus irgendeinem Grund will man nun zu einer anderen Seite umleiten:
blnUmleitung = True

If blnUmleitung = True Then
	' Umleiten zu anderer Seite
	Response.Redirect "AndereSeite.asp"
	' Ausführen des Scripts beenden, sodass der HTTP-Header,
	'  den der Befehl Response.Redirect erzeugt,
	'  aus dem Zwischenspeicher zum Browser geschickt wird.
	Response.End
End If

%>

Weiterer Text
</BODY>
</HTML>

Weiters kann man mit diesem Trick auch alle anderen ASP Befehle, die so wie Response.Redirect einen HTTP-Header zum Browser schicken, überall in einer ASP Seite verwenden.

Beipspiele für ASP Kommandos, die HTTP-Headers zum Browser schicken, enthalten zum Beispiel die Cookies Collection, oder eine der nachfolgenden Eigenschaften des Response Objektes:
CacheControl, ContentType, Expires, ExpiresAbsolute.

HTTP-Header werden ausserdem von den Methoden AddHeader und Redirect des Response Objektes zum Browser geschickt.

Standardeinstellungen unter IIS

Standardmässig ist der Default-Wert für das Zwischenspeichern wie folgt eingestellt:

IIS 4.0 benutzt den Zwischenspeicher nur, wenn Response.Buffer = True aufgerufen wird.

IIS 5.0 hingegen benutzt den Zwischenspeicher immer, solange die ASP Seite nicht den Befehl Response.Buffer = False benutzt.
Daher kann man unter IIS 5.0 normalerweise auch die Befehle Response.Clear und Response.Flush benutzen, ohne vorher explizit Response.Buffer = True aufzurufen.

HTTP-Keep Alive Headers

Noch ein Tip für Programmierprofis:
Immer wenn der Zwischenspeicher für die ASP-Ausgabe aktiv ist, egal ob nun für alle ASP-Seiten der Website im Internet Service Manager so eingestellt, oder per Response.Buffer = True aktiviert, werden sogenannte HTTP Keep-Alive Headers zwischen Webserver und Browser geschickt.

Um dies zu unterbinden ruft man ganz am Anfang der ASP Seite die Response.Flush Methode auf:

<% @ LANGUAGE="VBScript" ENABLESESSIONSTATE=FALSE %>
<% 
Option Explicit

' Zwischenspeicher einschalten
Response.Buffer = True
' HTTP-Keep Alive Headers unterdrücken
Response.Flush

...
%>