Response-Objekt | |
Während Sie mit dem Objekt Request vom Client-Browser in einer HTTP-Anforderung gesendete Informationen abrufen und ändern können, gibt Ihnen das Objekt Response eine Vielzahl von Steuerungsmöglichkeiten für die HTTP-Antwort an den Client. Diese Steuerung lässt sich in drei Hauptkategorien einteilen:
Die Steuerung der HTTP-Antwort- Header umfasst die Einstellung von Cookies auf dem Client-Computer, die Festlegung von verschiedenen bereits vorhandenen HTTP-Headerwerten (z. B. dem Inhaltstyp und der Ablaufinformationen für eine bestimmte Seite) und das Hinzufügen Ihrer eigenen, benutzerdefinierten Header zur HTTP-Antwort. Sie steuern den Body der HTTP-Antwort direkt über die Methoden Write und BinaryWrite. Die Namen weisen bereits darauf hin, dass Sie über diese Methoden des Objekts Response Informationen direkt in den Antwortbody schreiben können, die dann vom Client genau wie andere Informationen einer Antwort auf eine HTML-Anforderung empfangen werden. Schließlich ermöglicht das Objekt Response Ihnen die Steuerung darüber, wie und wann die Antwort an den Client gesendet wird. Zum Beispiel können Sie mittels der Eigenschaften und Methoden, die zur Pufferung der Antwort benötigt werden, feststellen, ob eine HTTP-Antwort als Einheit oder die Ergebnisse stückweise an den Client gesendet werden sollen. Sie bestimmen dynamisch, ob der Client weiterhin mit Ihrer Website verbunden sein soll. Sie können die Anforderung der Website weiterleiten, als ob diese etwas anderes angefragt hätte. Letztendlich können Sie das Objekt Response zum Schreiben von Einträgen in das Webserverprotokoll verwenden. |
Buffer | |
Response.Buffer[=blnSetting] | |
Die Eigenschaft Buffer bestimmt, ob der von Ihrem Skript erstellte Inhalt als Ganzes an den Client-Browser geliefert wird oder ob jede Zeile direkt nach der Erzeugung an den Client-Browser gesendet und in den HTML-Datenstrom eingefügt wird. Wenn die Eigenschaft auf True gesetzt ist, werden alle Skripte auf der Seite ausgeführt, bevor die Ergebnisse des Skripts an den Client-Browser gesendet werden. Der Standardwert für die Eigenschaft Buffer ist False, es sei denn, Sie legen ASPBufferingOn in der Metabase fest (über ein Windows Scripting Host-Skript oder über die Microsoft Management Console für Ihre Website). Wenn der Wert in der Metabase festgelegt ist, kann er durch die Eigenschaft Buffer auf einer Seite überschrieben werden. Wenn Sie beispielsweise ASPBufferingOn auf True setzen, können Sie dieses Verhalten anschließend mittels der Eigenschaft Buffer überschreiben und IIS dazu zwingen, die Seite nicht zu puffern. |
|
Parameter | |
|
|
Beispiel | |
Sehen Sie sich das folgende Beispiel an. Beachten Sie, dass die Eigenschaft Buffer des Objekts Response nicht explizit gesetzt wurde. Aus diesem Grund ist der Wert False: <%@ LANGUAGE="VBScript" %> <HTML> <% CODE THAT RETRIEVES A FIELD VALUE FROM A DATABASE %> Die Antwort wird nicht gepuffert, bevor sie an den anfordernden Browser gesendet wird. Der Benutzer sieht deshalb eine abgebrochene Seite, die mit einer Fehlermeldung endet, wenn die vorherige Datenbankaktion einen Fehler verursacht. Sehen Sie sich jetzt das zweite Codebeispiel an: <%@ LANGUAGE="VBScript" %> <%Response.Buffer = True %> <HTML> <% On Error Resume Next ' CODE THAT RETRIEVES A FIELD VALUE FROM A DATABASE If Err.Number <> 0 Then Response.Clear Response.Write "There has been an error. Here is the SQL" Response.Write "statement that caused the problem: " Response.Write strSQL Response.End End If %> In diesem Beispiel wird die Antwort zuerst gepuffert und abgeschlossen, bevor sie an den anfordernden Browser gesendet wird. In diesem Fall haben Sie die Möglichkeit, den Puffer zu leeren und eine einfach Fehlermeldung anzuzeigen, die mehr Informationen liefert als das nicht gepufferte Beispiel weiter oben. Der gezeigte Code ist nicht besonders interaktiv, jedoch ausreichend zum Verständnis. Wenn die Antwort nicht gepuffert wird, empfängt der Client die HTTP-Antwort auf seine Anforderung, während diese erzeugt wird - auch, wenn diese Erzeugung zu Fehlern führt. |
|
Hinweise | |
An erster Stelle müssen Sie sich merken, dass die Eigenschaft Buffer festgelegt werden muss, bevor das <HTML>-Tag für die HTTP-Antwort erzeugt wird. Wenn Sie die Eigenschaft Buffer nach dem <HTML>-Tag festlegen, wird ein Laufzeitfehler erzeugt. Umfasst Ihr Skript beispielsweise eine Vorverarbeitungsdirektive, die die Sprache für die Seite festlegt, muss diese Direktive festgelegt werden, bevor Sie den Wert der Eigenschaft Buffer setzen. Wenn Sie die Sprache für die Seite nach der Festlegung des Wertes für die Eigenschaft Buffer einstellen, tritt ein Laufzeitfehler auf. Wenn die Eigenschaft Buffer auf True gesetzt ist und Ihr Skript an keiner Stelle die Methode Flush aufruft, erkennt der Webserver die vom Client gesendeten Keep-Alive-Anforderungen an. Keep-Alive-Anforderungen vom Browser informieren den Server darüber, dass er eine Verbindung zum Client aufrecht erhalten soll. Wenn die Keep-Alive-Anforderung des Clients vom Server anerkannt wird, wird dieser nicht dazu gezwungen, die Verbindung jedes Mal neu aufzubauen, wenn er eine HTTP-Anforderung stellt. Er ist in diesem Fall bereits verbunden. Auf diese Weise braucht der Client die URL nicht erneut aufzulösen. Ist die Eigenschaft Buffer auf False gesetzt, oder Sie verwenden die Methode Flush an einer Stelle in Ihrem Skript, wird der Server gezwungen, als Antwort auf jede Anforderung eine neue Verbindung zum Client aufzubauen. Wann sollten Sie Ihre Skripte puffern? Die Antwort auf diese Frage ist abhängig von zwei Dingen: welche Wartezeit Sie Ihren Clients zumuten können und wie komplex Ihre Skripts sind. Wenn Ihre Clients Internetbenutzer mit relativ wenig Erfahrung sind, ist ihre Geduld gewöhnlich ziemlich schnell zu Ende - für diese Clients ist sofortige Aktion nach dem Klicken auf die Schaltfläche zum Absenden in Ihren Formularen erforderlich. Erfahrenere Benutzer verstehen mehr von den Hintergründen von Anwendungen im Internet und haben - vielleicht - mehr Verständnis für Zeitverzögerungen bei Skriptergebnissen. Vorrangig ist jedoch, wie wichtig es Ihnen selbst ist, Ihre Antwort als eine Einheit darzustellen. Bei Skripts, in denen viele sich wiederholende Verarbeitungsschritte ausgeführt werden und jede Schleife direkt von der vorherigen Schleife betroffen ist, kann es wichtig sein, das Endergebnis als eine Einheit darzustellen. Bestehen Ihre Skripts hingegen aus mehreren definierbaren Abschnitten, von denen jeder eigenständig angezeigt werden kann, ist eine Pufferung möglicherweise weniger wichtig. Eine Strategie zur Handhabung von Zeitverzögerungen bei komplexen Skripts, deren Ergebnisse als eine Einheit benötigt werden, ist die Bereitstellung einer Seite "Bitte warten" oder Ähnliches. Diese Zwischenseite teilt dem Benutzer mit, dass seine Anforderung empfangen wurde und das Skript verarbeitet wird. Angenommen, der Client-Browser fordert ein ASP-Skript an, dass Daten aus einer äußerst komplexen Anforderung mit einer langen Ladezeit (z. B. 30 Sekunden) abruft und formatiert. Anstatt nun den Client zu zwingen, auf einen Hyperlink zu klicken, worauf 30 Sekunden lang nichts geschieht (und der unerfahrene Internetbenutzer wahrscheinlich wiederholt auf den gleichen Hyperlink bzw. die gleiche Schaltfläche klickt), könnten Sie zwischenzeitlich eine Seite wie die folgende anzeigen: <HTML> <HEAD><TITLE>Please Wait</TITLE></HEAD> <BODY LANGUAGE = "VBScript" OnLoad = "WinLoad( )"> Your request is being processed, please wait... <SCRIPT LANGUAGE = "VBScript"> Sub WinLoad( ) Parent.Location.HREF = "/Reports/Longreport.asp" End Sub </SCRIPT> </BODY> </HTML> Diese kurze Seite wird schnell geladen, und der Benutzer sieht die "Bitte warten"-Meldung so lange, bis das nächste Skript verarbeitet wurde und der Bericht angezeigt werden kann. An dieser Stelle wird die Meldung ausgeblendet, und der Bericht geladen. Wenn Sie die meisten Ihrer Skripts puffern wollen, können Sie die Metabase ASPBufferingOn festlegen (über die Konfigurationsseite für die Optionen Ihrer Anwendung für Ihr virtuelles Verzeichnis, siehe auch Anhang D), damit standardmäßig alle Skripts gepuffert werden. |
|
CacheControl | |
Response.CacheControl[=ProxyCacheControlSetting] | |
Über CacheControl können Sie bestimmen, ob die Proxyserver, die Ihre Seiten bereitstellen, diese zwischenspeichern können. Handelt es sich um Seiten mit umfangreichem Inhalt, der selten geändert wird, sollten Sie zulassen, dass Proxyserver die Seiten zwischenspeichern und sie auf diese Weise den anfordernden Client-Browsern schneller bereitstellen. |
|
Parameter | |
|
|
Beispiel | |
Die Einstellung dieser Eigenschaft ist einfach, wie der folgende Code zeigt. Nun stellt sich die Frage, ob es möglich ist, festzustellen, ob der Client über einen Proxyserver auf die Webseite zugreift. Diese Möglichkeit besteht zwar, aber es ist problematisch und beschwerlich, wenn Sie im Voraus von der Existenz möglicher Proxyserver wissen. Dies ist zudem für die Festlegung dieser Eigenschaft nicht wichtig: Entweder wird die Client-Anforderung von einem Proxyserver abgewickelt und diese Eigenschaft hat somit Auswirkungen auf die Zwischenspeicherung der Seite, oder diese Eigenschaft wird ignoriert. <% ' The following code sets the HTTP cache control header so ' that this page can be cached by the proxy servers being ' used to access the page. Response.CacheControl = "Public" %> <HTML> <% ' Note that the CacheControl property was set BEFORE the ' <HTML> tag was constructed. %> |
|
Hinweise | |
Wenn der Proxyserver Ihre Seite zwischenspeichern kann, verringert sich die Zugriffszeit des Clients über einen Proxyserver auf Ihre Seite. Dies ist jedoch nicht besonders nützlich, wenn sich die Seite häufig ändert. Es ist auch zu beachten, dass der Proxyserver nicht unbedingt Ihre Seite(n) zwischenspeichert, selbst wenn die Eigenschaft CacheControl auf Public gesetzt ist - dies muss auf dem Proxyserver selbst konfiguriert werden. Wenn Sie einen Wert für CacheControl setzen, ändert sich der Wert in der Cache-Steuerung des HTTP-Headers, der auf Anforderung an den Client gesendet wird. Wenn Sie diese Eigenschaft verwenden, müssen Sie sie setzen, bevor Sie eine Antwort an den Client senden (d. h., bevor das <HTML>-Tag für Ihre Seite erzeugt wird). Wenn Sie versuchen, diesen Wert (oder einen anderen HTTP-Header) zu setzen, nachdem das <HTML>-Tag an den Client gesendet wurde, tritt ein Fehler auf, wenn die Antwort nicht gepuffert wird. Das Setzen dieser Eigenschaft garantiert jedoch nicht die Zwischenspeicherung auf dem Proxyserver: Der Proxyserver selbst muss so konfiguriert sein, dass diese Seiten zwischengespeichert werden. Andernfalls hat diese Einstellung keine Auswirkungen. |
|
Charset | |
Response.Charset(strCharsetName) | |
Über Charset können Sie einen Zeichensatz für den Inhalt der HTTP-Antwort festlegen. Der Name dieses Zeichensatzes wird dem Ende des inhaltsbezogenen Paares Header/Wert in den HTTP-Antwort-Headern hinzugefügt. |
|
Parameter | |
|
|
Beispiel | |
Wenn Sie die Eigenschaft Charset nicht festlegen, sehen die inhaltsbezogenen HTTP-Antwort-Header wie folgt aus: content-type:text/html Setzen Sie hingegen die Eigenschaft Charset wie in der folgenden Codezeile - <% Response.Charset("ISO-LATIN-7") %> - wird der Wert, den Sie zur Festlegung des Werts der Eigenschaft Charset verwenden (im Code oben der String "ISO-LATIN-7"), an das Ende des inhaltsbezogenen HTTP-Antwort-Header-Werts angehängt: content-type:text/html;charset=ISO-LATIN-7 |
|
Hinweise | |
Charset wird zwar sowohl in dieser Dokumentation als auch in Microsoft-Dokumentation als eine Eigenschaft dargestellt, tatsächlich handelt es sich jedoch um eine Methode, die ein String-Argument mit dem Namen des am Ende des inhaltsbezogenen HTTP-Antwort-Headers anzuhängenden Zeichensatzes aufgreift. Daher tritt ein Fehler auf, wenn Sie versuchen, den Wert der "Eigenschaft" Charset auf die gleiche Weise einzustellen wie andere Eigenschaften des Objekts Response: <% ' Next line will NOT work: Response.Charset = "ISO-LATIN-7" %> Stellt der für die Eigenschaft Charset festgelegte Wert keinen gültigen Zeichensatz dar, wird der Wert vom Client-Browser ignoriert und stattdessen der Standardzeichensatz verwendet. Sie können jeweils nur den Namen eines Zeichensatzes an das Ende des inhaltsbezogenen Paares Header/Wert anhängen. Nachträgliche Änderungen der Eigenschaft Charset überschreiben jeweils die vorherige Einstellung. Der folgende Code: <% Response.Charset("ISO-LATIN-7") Response.Charset("ISO-LATIN-3") %> führt zum folgenden inhaltsbezogenen HTTP-Antwortpaar Header/Wert: content-type:text/html;charset=ISO-LATIN-3 Zusätzlich ist zu beachten, dass der Wert für den Zeichensatz vom Browser ignoriert wird, wenn Ihr Inhaltstyp ausschließlich nicht-Text (z. B. Bilddaten) enthält. Der Standardzeichensatz für Apple Macintosh- und damit kompatible Computer ist nicht ISO-LATIN-1 wie für IBM-PCs und damit kompatible Computer. Wenn Sie die Eigenschaft Charset nicht setzen, interpretieren alle Macintosh-Browser angeforderte Seiten entsprechend dem Macintosh-Zeichensatz. Personal Web Server für Macintosh von Microsoft konvertiert den Zeichensatz des angeforderten Inhalts automatisch in ISO-LATIN-1 und ignoriert jegliche anderen Einstellungen der Eigenschaft Charset in Ihrem Skript. Wie andere Eigenschaften, die eine Änderung der HTTP-Antwort-Header-Werte zur Folge haben, muss die Eigenschaft Charset festgelegt werden, bevor der Server das <HTML>-Tag an den Client sendet, wenn die Antwort nicht gepuffert ist. |
|
ContentType | |||||||||||||||||||||||||
Response.ContentType[=strContentType] | |||||||||||||||||||||||||
Über den Parameter ContentType können Sie den Wert für die inhaltsbezogene Einstellung in dem HTTP-Antwort-Header festlegen. Dieser Wert definiert den Datentyp, der im Body der Antwort gesendet wird. Der Client-Browser verwendet diese Information, um zu bestimmen, wie der Inhalt der heruntergeladenen HTTP-Antwort interpretiert werden soll. |
|||||||||||||||||||||||||
Parameter | |||||||||||||||||||||||||
|
|||||||||||||||||||||||||
Beispiel | |||||||||||||||||||||||||
<% ' The following code sets the value of the Content-Type ' HTTP response header according to the value of a ' local variable. If strData = "jpg" Then Response.ContentType = "image/JPEG" Else Response.ContentType = "text/plain" End If %> |
|||||||||||||||||||||||||
Hinweise | |||||||||||||||||||||||||
Einige der möglichen Werte für Typ/Subtyp-Paare für ContentType sind in Tabelle 8.1 aufgeführt.
Es ist zu erwarten, dass die Anzahl Subtypen mit der Zeit erheblich zunimmt. Die beste Referenz bezüglich Subtypen finden Sie im neuesten MIME RFC (zum Zeitpunkt dieser Veröffentlichung: RFC 2231). Viele der neuen Subtypen werden aus der Industrie erwartet. Beispielsweise hat Microsoft bereits den Subtyp x-cdf für den Typ Application für sein Format "Channel Definition Format" hinzugefügt. Wie andere Eigenschaften, die eine Änderung der HTTP-Antwort-Header-Werte zur Folge haben, muss die Eigenschaft ContentType festgelegt werden, bevor der Server das <HTML>-Tag an den Client sendet, wenn die Antwort nicht gepuffert ist. Ein weiteres Beispiel für die Eigenschaft ContentType ist das Codebeispiel für die Methode BinaryWrite des Objekts Response weiter unten in diesem Kapitel. |
|||||||||||||||||||||||||
Expires | |
Response.Expires[=intNumMinutes] | |
Die Eigenschaft Expires gibt die Zeitdauer (in Minuten) an, für die der Client-Computer die aktuelle Seite zwischenspeichert. Wenn der Benutzer innerhalb der für die Eigenschaft Expires festgelegten Zeitspanne zur Webseite zurückkehrt, wird die zwischengespeicherte Version der Seite angezeigt. Ist die Eigenschaft Expires nicht gesetzt, wird die für das virtuelle Verzeichnis in der Microsoft Management Console auf der Seite Properties festgelegte Ablaufzeit für den Inhalt verwendet. Der Standardwert ist 24 Stunden. |
|
Parameter | |
|
|
Hinweise | |
Wenn der Client-Browser die Seite nicht zwischenspeichern soll, stellen Sie intNumMinutes auf "Null" ein. Dies erzwingt, dass der Client die Seite jedes Mal, wenn der Benutzer sie aufruft, erneut vom Webserver anfordert. Wenn Sie die Eigenschaft Expires mehr als einmal pro Skript festlegen, wird die kürzeste Zeit verwendet. Die Seite, die das folgende Skript enthält, führt beispielsweise dazu, dass der Client die Seite fünf Minuten zwischenspeichert, auch wenn die letzte Einstellung der Eigenschaft Expires 20 Minuten ist. <% Response.Expires = 10 Response.Expires = 5 Response.Expires = 20 %> Wie andere Eigenschaften, die eine Änderung der HTTP-Antwort-Header-Werte zur Folge haben, muss die Eigenschaft Expires festgelegt werden, bevor der Server das <HTML>-Tag an den Client sendet, wenn die Antwort nicht gepuffert ist. |
|
ExpiresAbsolute | |
Response.ExpiresAbsolute[=[ Datum ] [ Uhrzeit ] ] | |
Gibt den Zeitpunkt (Datum und Uhrzeit) an, zu dem die Zwischenspeicherung des Inhalt der aktuellen Seite auf dem Client-Computer beendet wird. Wird für die Eigenschaft ExpiresAbsolute keine Uhrzeit angegeben, wird als Zeitpunkt Mitternacht des angegebenen Datums verwendet. Vor dem in der Eigenschaft ExpiresAbsolute festgelegten Datum zeigt der Client die zwischengespeicherte Version der aktuellen Seite an, wenn der Benutzer diese aufruft. |
|
Parameter | |
|
|
Beispiel | |
<% ' The following code sets the current page's caching on the ' client machine to end at 9 P.M. on 7 May 1998 GMT. NOTE ' the use of the "#" to designate the date and time. Response.ExpiresAbsolute=#May 7, 1998 21:00:00# %> |
|
Hinweise | |
Wie das Beispiel zeigt, müssen Sie die in der Eigenschaft ExpiresAbsolute verwendeten Werte für Datum und Uhrzeit mit dem Doppelkreuzzeichen (#) versehen. Wie bei der Eigenschaft Expires führt die mehrmalige Einstellung dieser Eigenschaft dazu, dass die Zwischenspeicherung der aktuellen Seite zum frühesten im Skript eingestellten Zeitpunkt (Datum und Uhrzeit) endet. Wie andere Eigenschaften, die eine Änderung der HTTP-Antwort-Header-Werte zur Folge haben, muss die Eigenschaft ExpiresAbsolute festgelegt werden, bevor der Server das <HTML>-Tag an den Client sendet, wenn die Antwort nicht gepuffert ist. |
|
IsClientConnected | |
Response.IsClientConnected | |
Eine schreibgeschützte Eigenschaft, die zur Bewertung True führt, wenn der Client seit der letzten Verwendung der Methode Write des Objekts Response noch mit dem Webserver verbunden ist. Andernfalls gibt sie den Wert False zurück. |
|
Parameter | |
Keine |
|
Beispiel | |
<% ' The following code determines whether the client ' is still connected to the server. If it is still ' connected, then the SessionID (see Chapter 10) will be ' used to retrieve the user information from a database. If Response.IsClientConnected Then strUserName = fn_strGetUserName(Session.SessionId) End If %> |
|
Hinweise | |
Über die Eigenschaft IsClientConnected können Sie feststellen, ob die Verbindung zum Client getrennt wurde. Dies ist äußerst wichtig, wenn das aktuelle Skript lang ist. Besteht keine Verbindung mehr zum Client, kann es wichtig sein, die Verarbeitung eines Skripts abzubrechen. Im folgenden Beispiel wird gezeigt, wie die Verbindung zum Client vor dem Fortsetzen eines langen Skripts überprüft wird. Besteht keine Verbindung mehr zum Client, können Sie die Verarbeitung am einfachsten über die Methode End des Objekts Response anhalten. <%Response.Buffer = True%> <HTML> <HEAD><TITLE>One Long Script</TITLE></HEAD> <BODY> <% ' The following code is the first of two segments ' in this script that will take a long time to process: [SOME LONG CODE] ' Now before performing the second half of this long script, ' check to see if the client is still connected. If Response.IsClientConnected Then [SECOND LONG CODE SEGMENT] Else ' The client is no longer connected, end the script's ' processing. Response.End End If %> </BODY></HTML> Diese Eigenschaft ist nur für Clients von Nutzen, die HTTP 1.1 verwenden. Verwendet der Browser HTTP 1.0, verfolgt IIS die Sitzung über individuelle HTTP- und Keep-Alive-Anforderungen durch den Client und nicht über eine ständige Verbindung. Letztere ist nur konform mit späteren Versionen von HTTP (1.1+). Wenn die ASP-Datei, in der Sie IsClientConnected einsetzen, unter IIS 4.0 ausgeführt wird, ist der Wert der Eigenschaft nur dann richtig, wenn die Datei Inhalte an den Client sendet (d. h., wenn die Datei ausschließlich serverseitigen Code enthält, ist der Ergebniswert von IsClientConnected nicht korrekt). In IIS 5.0 funktioniert IsClientConnected jedoch unabhängig davon, ob die aktuelle Datei Inhalte an den Client sendet. |
|
PICS | |
Response.PICS(strPICSLabel) | |
Fügt ein PICS- (Platform for Internet Content Selection) Label zu dem HTTP-Antwort-Header hinzu. Das PICS-System bezeichnet Ihren Webinhalt, um Zertifizierungsdienste zuzulassen (z. B. "Recreational Software Advisory Council" (RSAC) und "SafeSurf", eine Elternorganisation), damit der Inhalt anhand verschiedener Kriterien von Software zur Inhaltskontrolle (z. B. NetNanny und CyberWatch) beurteilt werden kann. |
|
Parameter | |
|
|
Beispiel | |
<% ' The following piece of code sets a PICS label for the ' content of this page corresponding to the rating discussed ' earlier. Dim strPicsLabel strPicsLabel = _ "(PICS-1.1 <HTTP://www.rsac.org/ratingsv01.html> " strPicsLabel = strPicsLabel & "labels on " & Chr(34) strPicsLabel = strPicsLabel & "2000.07.20T06:00-0000" & _ Chr(34) strPicsLabel = strPicsLabel & " until " & Chr(34) strPicsLabel = strPicsLabel & "2000.12.31T23:59-0000" & _ Chr(34) strPicsLabel = strPicsLabel & "ratings (V 0 S 1 L 3 N 0))" Response.PICS(strPicsLabel) %> |
|
Hinweise | |
Das PICS-Label im Beispiel gibt an, dass:
Das eigentliche PICS-Label, das dem HTTP-Antwort-Header hinzugefügt wird, ist folgendes: PICS-label:(PICS-1.1 http://www.rsac.org/ratingsv01.html labels on "1998.03.20T06:00-0000" until "1999.12.31T023:59-0000" ratings (v 0 s 1 l 3 n 0)) Wenn versucht wird, dem HTTP-Header ein ungültiges PICS-Label hinzuzufügen, wird dieses von dem Client-Computer ignoriert. Es ist zu beachten, dass jede neue Einstellung des Eigenschaftswerts PICS den vorherigen Wert überschreibt. Nur die letzte Einstellung wird tatsächlich an den Client-Computer gesendet. Weiterhin ist zu beachten, dass die Datumsangaben in dem PICS-Label in Anführungszeichen gestellt sind. Verwenden Sie hierfür das Zeichen Chr(34) (34 ist die ASCII-Bezeichnung für das Anführungszeichen oben). Dies können Sie am einfachsten ausführen, indem Sie zuerst den Label-Text so eingeben, wie er im endgültigen PICS-Label erscheinen soll. Anschließend ersetzen Sie jedes Anführungszeichen in der Codezeile durch folgende Zeichenfolge: " & Chr(34) & " Wie andere Eigenschaften, die eine Änderung der HTTP-Antwort-Header-Werte zur Folge haben, muss ein PICS-Label hinzugefügt werden, bevor der Server das <HTML>-Tag an den Client sendet, wenn die Antwort nicht gepuffert ist. |
|
Status | |
Response.Status(strStatusDescSetting) | |
Gibt die HTTP-Statuszeile an, die vom Webserver an den Client-Computer zurückgegeben wird. |
|
Parameter | |
|
|
Beispiel | |
<% ' The following code sets the Status property of the ' Response object to 404 Not Found. Unless other content is ' generated for the page, the status code will be ' interpreted by itself by the client. strStatusText = _ "404 Not Found The Web server cannot find the " strStatusText = strStatusText & "file or script you asked " strStatusText = strStatusText & "for. Please check the URL " strStatusText = strStatusText & "to ensure that the path " strStatusText = strStatusText & "is correct." Response.Status = strStatusText %> |
|
Hinweise | |
Wie bei der Einstellung anderer Antwort-Header, überschreibt die Einstellung der Eigenschaft Status die jeweils vorherige Einstellung. Wie andere Eigenschaften, die eine Änderung der HTTP-Antwort-Header-Werte zur Folge haben, muss die Eigenschaft Status festgelegt werden, bevor der Server das <HTML>-Tag an den Client sendet, wenn die Antwort nicht gepuffert ist. |
|
Cookies | |
strKeyName = Response.Cookies.Key(3) strKeyValue = Response.Cookies.Item(strKeyName) | |
Über die Kollektion Cookies des Objekts Response kann Ihre ASP-Anwendung den Set-Cookie-HTTP-Antwort-Header dafür einsetzen, Cookies auf den Client-Computer zu schreiben. Beim Setzen des Werts für einen Cookie, der noch nicht vorhanden ist, wird dieser erstellt. Existiert er bereits, überschreibt der neue Wert den alten, der sich auf dem Client-Computer befindet. Wie bei der Kollektion Cookies des Request-Objekts kann jeder Cookie in der Kollektion des Objekts Response eine Cookie-Liste repräsentieren. In Kapitel 7 wurde erläutert, dass eine Cookie-Liste ein Konstrukt ähnlich einem inhaltsorientierten Array ist, in dem jedes Element nach seinem Namen identifiziert werden kann. Weitere Informationen zu Cookie-Listen finden Sie im Abschnitt zur Kollektion Cookies des Objekts Request in Kapitel 7. Die Kollektion Cookies des Objekts Response weist wie andere ASP-Kollektionen die folgenden Eigenschaften auf:
Wie bei anderen ASP-Kollektionen können Sie den Wert eines beliebigen Felds der Kollektion Cookies über die Eigenschaft Item abrufen. In den folgenden Beispielen wurde die Syntax jedoch verkürzt (wie auch an anderen Stellen in dieser Dokumentation), so dass die Verwendung der Eigenschaft Item nicht explizit zu sehen ist. Beispiel: Response.Cookies("UserPref") = "Red" ist eine verkürzte Form von: Response.Cookies.Item("UserPref") = "Red" Um den Wert eines Cookies zu setzen, können Sie einen Code wie den folgenden verwenden: Response.Cookies("LastSearch") = _ "SELECT * FROM Details WHERE Color = 'Red'" Weitere Informationen zu den Kollektionseigenschaften Item, Key und Count finden Sie in Abschnitt 4.2 in Kapitel 4. Der Code oben erstellt den Cookie UserPref, wenn dieser nicht bereits vorhanden ist (bzw. überschreibt den ursprünglichen Wert, wenn er bereits existiert). Dieser Cookie würde in einen SET-COOKIE-Antwort-Header umgesetzt, der der an den Client-Browser zu sendenden Antwort hinzugefügt wird. Der Client-Browser empfängt diesen Antwort-Header und erstellt (bzw. überschreibt) einen UserPref-Cookie auf dem Benutzercomputer. Jedes Element in der Kollektion Cookies (bzw. jeder Unterschlüssel, wenn es sich bei dem Cookie um eine Cookie-Liste handelt) verfügt zudem über folgende cookie-spezifischen Attribute:
|
|
Beispiel | |
Das folgende Beispiel zeigt den vollständigen Umfang der Verwendung der Kollektion Cookies des Objekts Response. Hierin werden viele der vorstehend erläuterten Elemente eingesetzt. <HTML> <HEAD><TITLE>Search Cookie Example</TITLE></HEAD> <BODY> <H3>Welcome to the Search Results Options Page.</H3> You can use the following form to select your search results display options. These options will be saved on your machine as a set of cookies. <FORM ACTION="/SaveSearchCookie.asp" METHOD = POST> First Name:<INPUT TYPE = TEXT NAME = "txtFirstName"><BR> Last Name:<INPUT TYPE = TEXT NAME = "txtLastName"><BR> User ID:<INPUT TYPE = TEXT NAME = "txtUserId"><BR> Check All that Apply: Show Descriptions: <INPUT TYPE = CHECKBOX NAME = "chkUserPrefs"VALUE = "Desc"> Show Hit Count (display how many matches found per result): <INPUT TYPE = CHECKBOX NAME = "chkUserPrefs"VALUE = "Count"> Show Relevance with Graph: <INPUT TYPE = CHECKBOX NAME = "chkUserPrefs" VALUE = "Graph"> Use Small Fonts(will show more results per page): <INPUT TYPE = CHECKBOX NAME = "chkUserPrefs" VALUE = "Small"> <INPUT TYPE = SUBMIT VALUE = "Save Selections"> </FORM> </BODY> </HTML> Der folgende Code ( <% ' The following code retrieves user information from the ' Form collection of the Request object (see Chapter 7) and ' then writes the information to a set of cookies on the ' client machine. Dim strFirstName Dim strLastName Dim strUserId Dim intCounter Dim intPrefCounter Dim strKeyName Dim arstrUserPrefs( ) ' Retrieve user information... strFirstName = Request.Form("txtFirstName") strLastName = Request.Form("txtLastName") strUserId = Request.Form("txtUserId") intPrefCounter = 1 For intCounter = 1 to Request.Form("chkUserPrefs").Count ReDim Preserve arstrUserPrefs(intPrefCounter) arstrUserPrefs(intPrefCounter - 1) = _ Request.Form("chkUserPrefs")(intCounter) intPrefCounter = intPrefCounter + 1 Next ' Write the user information to the client machine. ' Save all the information in cookies, but set the ' Expires property only for the UserId. We'll want ' that to remain on the client machine after the session ' is complete. Response.Cookies("UserFirstName") = strFirstName Response.Cookies("UserLastName") = strLastName For intCounter = 1 to intPrefCounter - 1 strKeyName = "Pref" & CStr(intCounter) Response.Cookies("UserPrefs")(strKeyName) = _ arstrUserPrefs(intCounter - 1) Next ' Note in the first line below, that when no property ' is specified, the value of the cookie is set. Response.Cookies("UserId") = strUserId Response.Cookies("UserId").Expires = #December 31, 1999# Response.Cookies("UserId").Domain = "www.customsearch.com" Response.Cookies("UserId").Path = "/usersearch/" Response.Cookies("UserId").Secure = True %> |
|
Hinweise | |
In dem Beispiel oben wird der Cookie UserFirstName an den Client-Computer gesendet. Für dieses Beispiel nehmen wir an, dass der Wert für die Variable strFirstName der String "David" ist. Der tatsächlich zu dem Client-Computer gesendete HTTP-Antwort-Header ist dann: Set-Cookie:USERFIRSTNAME=david Für das gleiche Beispiel wird angenommen, dass die drei folgenden Werte gesendet werden: "800" (für die Breite des Client-Browsers), "8" (für die Farbtiefe in Bit) und "English" (für Englisch als Sprachvorgabe). Der tatsächlich zu dem Client gesendete HTTP-Antwort-Header ist dann: Set-Cookie:USERPREFS=PREF1=800&PREF2=8&PREF3=english Wenn der String-Wert, der für den Wert eines Cookies gesendet wird, Leerzeichen enthält, werden diese Leerstellen im Antwort-Header durch Pluszeichen (+) ersetzt. Wenn Sie einen weiteren Cookie-Wert an den Cookie UserPrefs auf dem Client-Computer senden, ohne einen SubKey (Unterschlüssel) anzugeben - Response.Cookies("UserPrefs") = "german" - werden die beiden Werte für PREF1 und PREF2 überschrieben und die Eigenschaft Count des Cookies UserPrefs gibt "1" zurück. Senden Sie jedoch einen weiteren Cookie-Wert unter Angabe eines SubKey an einen Client-Computer, und der Cookie hat zwar einen Wert, jedoch keine Schlüssel, wird der Wert des Cookies auf dem Client-Computer überschrieben. Wenn Sie während der Erzeugung von Werten für die Kollektion Cookies des Objekts Response feststellen möchten, ob für einen bestimmten Cookie bereits Unterschlüssel definiert wurden, können Sie die Eigenschaft HasKeys des Cookies auswerten. Wenn für den Cookie Unterschlüssel definiert sind, ist die Eigenschaft HasKeys auf True gesetzt. Wie andere Eigenschaften, die eine Änderung der HTTP-Antwort-Header-Werte zur Folge haben, müssen die Cookies-Kollektionswerte festgelegt werden, bevor der Server das <HTML>-Tag an den Client sendet, wenn die Antwort nicht gepuffert ist. |
|
AddHeader | |
ClientCustomHeader:CustomHeaderValue | |
Lässt das Hinzufügen eines eigenen HTTP-Antwort-Headers mit einem entsprechenden Wert zu. Wenn Sie einen HTTP-Header mit dem gleichen Namen wie ein zuvor angefügter Header hinzufügen, wird der zweite Header zusätzlich zum ersten gesendet: durch Hinzufügen des zweiten Headers wird der Wert des ersten, gleichnamigen Headers nicht überschrieben. Ein der HTTP-Antwort einmal hinzugefügter Header kann nicht entfernt werden. Wenn der Client dem Webserver einen HTTP-Header sendet, der nicht im Abschnitt zu der Kollektion ServerVariables in Kapitel 7 aufgeführt ist, können Sie diesen über HTTP_HeaderName abrufen. Sendet der Client beispielsweise den HTTP-Header: ClientCustomHeader:CustomHeaderValue so können Sie den Wert für dieses Element über die folgende Syntax abrufen: <% Request.ServerVariables("HTTP_ClientCustomHeader") %> Hierbei handelt es sich um eine fortgeschrittene Methode, die nicht ohne sorgfältige Planung eingesetzt werden sollte. Wenn eine andere Methode des Objekts Response angewendet werden kann, sollten Sie diese an Stelle der Methode AddHeader verwenden. |
|
Parameter | |
|
|
Beispiel | |
<% ' The following code adds the CUSTOM-ERROR HTML header to ' the HTTP response headers. Response.AddHeader "CUSTOM-ERROR", "Your browser is not IE." %> |
|
Hinweise | |
Wie die anderen Methoden und Eigenschaften des Objekts Response, die eine Änderung der HTTP-Antwort-Header zur Folge haben, müssen Sie die Methode AddHeader aufrufen, bevor das <HTML>-Tag an den Client gesendet wird. Wenn Sie den Wert der Eigenschaft Buffer zuvor auf True gesetzt haben, können Sie AddHeader einsetzen - es sei denn, Sie haben vorher die Methode Flush aufgerufen. Wenn Sie AddHeader nach dem Senden des <HTML>-Tags an den Client aufrufen bzw. die Methode Flush aufrufen, hat der Aufruf von AddHeader einen Laufzeitfehler zur Folge. Verwenden Sie keine Unterstriche in benutzerdefinierten Headern. Dies erhöht die mögliche Doppeldeutigkeit mit bereits vorhandenen Headern. Verwenden Sie stattdessen Bindestriche, um Wörter zu trennen. Beachten Sie dabei, dass zum Abrufen der Werte eines benutzerdefinierten Headers mit Bindestrichen diese durch Unterstriche ersetzt werden. |
|
AppendToLog | |
Response.AppendToLog strLogEntry | |
Fügt dem Webserver-Protokolleintrag für die aktuelle Client-Anforderung einen String hinzu. Sie können maximal 80 Zeichen gleichzeitig hinzufügen; Sie können jedoch die Methode AppendToLog mehrmals aufrufen. |
|
Website-Aktivitäten protokollieren | |
IIS ermöglicht die Protokollierung von Benutzeraktivitäten in einer Textdatei oder einer ODBC-kompatiblen Datenbank. Diese Art Protokollierung geschieht unabhängig von der Protokollerstellung in Windows NT, und die Datensätze in IIS-Protokollen können über Windows NT Event Viewer angezeigt werden. Zur Anzeige der IIS-Protokolldateien öffnen Sie diese wie andere ASCII-Textdateien und importieren sie in ein Tabellkalkulations- oder Datenbankprogramm. Wenn Sie die Protokolle in eine ODBC-Datenbank geschrieben haben, zeigen Sie die Dateien durch Abfragen der Datenbank an. Die IIS-Protokolldateien werden unter Sie können u. a. speziell die folgenden Aspekte von Benutzerbesuchen auf Ihrer Website protokollieren:
Anhand dieser Informationen und zusätzlicher Informationen, die Ihre Anwendung diesem Protokoll über Response.AppendToLog anfügt, können Sie die zukünftige Entwicklung Ihrer Website planen, Sicherheitsaspekte planen und neue Server vorsehen, wenn die Belastung dies rechtfertigt. |
|
Parameter | |
|
|
Beispiel | |
<% ' Assume you have constructed one string containing all that ' you'd like logged to the web's server. This string is ' declared as strOrigLogContent. The following Do...While ' loop code will loop through your content and log it to the ' web server 79 characters at a time. Do While Len(strOrigLogContent) > 0 If Len(strOrigLogContent) >= 79 Then strLogString = Left(strOrigLogContent, 79) Else strLogString = strOrigLogContent End If ' Log the content. Response.AppendToLog strLogString If Len(strOrigLogContent) > Len(strLogString) Then strOrigLogContent = _ Right(strOrigLogContent, _ Len(strOrigLogContent) - Len(strLogString)) Else strOrigLogContent = " End If Loop %> |
|
Hinweise | |
Bevor Sie dem Webserverprotokoll in IIS Informationen hinzufügen können, müssen Sie die Option URL Query der Seite Extended Logging Properties der Website aktivieren, deren Aktivität die Protokolldateien aufzeichnen soll. Diese Methode kann eine außerordentliche Zeitersparnis zum Festhalten detaillierter Informationen zu Aktionen auf Ihrer Website darstellen. Wenn Sie über einen eindeutigen Bezeichner für jeden Benutzer verfügen, der zusammen mit dem Eintrag in der Protokolldatei gespeichert wird, können Sie schnell feststellen, wer die Website beispielsweise zurzeit eines unerwarteten Fehlers gerade besucht hat. (Ein Eintrag enthält eine IP-Adresse, möglicherweise auch einen Windows NT Kontonamen und Datum und Uhrzeit des Besuchs.) Auf diese Methode können Sie sich nicht für Sicherheitszwecke verlassen, da Sie der Identität des Benutzers nicht 100 %-ig vertrauen können, aber sie ist dennoch nützlich. |
|
BinaryWrite | |
Request.BinaryWrite arbyteData | |
Schreibt Informationen ohne Zeichenkonvertierung direkt in den Antwortinhalt. Wenn Ihre Anwendung voraussetzt, dass Binärdaten auf dem Client-Computer geschrieben werden, müssen Sie diese Methode einsetzen, um sicherzustellen, dass die von Ihnen gesendeten Daten nicht von den ursprünglichen Binärdaten in Zeichen konvertiert werden. |
|
Parameter | |
|
|
Beispiel | |
Der folgende Beispielcode ist relativ lang für den einfachen Aufruf von BinaryWrite, er veranschaulicht jedoch ein äußerst nützliches Konzept - vor allem für die Handhabung von Binärdaten aus einer Datenbank. <% ' The following code retrieves a binary object ' (in this case a JPG image) and writes it to the ' client using BinaryWrite. (For more information ' on ActiveX Data Objects usage, see Chapter 12.) ' Create an ADO connection object. Set adoCon = Server.CreateObject("ADODB.Connection") ' Use the Open method of the Connection object ' to open an ODBC connection with the database ' represented by the DSN ImageDatabase. adoCon.Open "ImageDatabase" ' Use the Execute method of the ADO Connection object ' to retrieve the binary data field from the database. Set adoRecImgData = adoCon.Execute _ ("SELECT ImageData FROM Images WHERE ImageId = 1234") ' Create a Field object by setting one equal to a ' specific field in the recordset created previously. Set adoFldImage = adoRecImgData("ImageData") ' Use the ActualSize property of Field object to retrieve ' the size of the data contained in the Field object. After ' this line you will know how many bytes of data reside in ' the Field object. lngFieldDataLength = adoFldImage.ActualSize ' Use the BinaryWrite method to write 4K bytes of binary ' data at a time. So, first we need to determine how many ' 4K blocks the data in the Field object represents. lngBlockCount = lngFieldDataLength / 4096 ' Now let's get how many bytes are left over after removing ' lngBlockCount number of bytes. lngRemainingData = lngFieldDataLength Mod 4096 ' We now must set the HTTP content type Response header ' so that the browser will recognize the data being sent ' as being JPEG image data. Response.ContentType = "image/JPEG" ' Loop through and write the first lngBlockCount number ' of binary blocks of data. For intCounter = 1 to lngBlockCount Response.BinaryWrite adoFldImage.GetChunk(4096) Next ' Now write the last remainder of the binary data. Response.BinaryWrite adoFldImage.GetChunk(lngRemainingData) ' Close the recordset. adoRecImgData.Close %> |
|
Hinweise | |
Auf den ersten Blick scheint die Methode BinaryWrite von begrenztem Nutzen zu sein. Wenn jedoch Binärdaten aus einer Datenbank an den Client-Computer gesendet werden müssen, erweist sich BinaryWrite als unschätzbar. Im Code oben wird gezeigt, dass ein Beispiel hierfür die Anzeige von Bilddaten ist, die in einem Datenbanksystem gespeichert sind, das Binärdaten speichern kann, und die daraus abgerufen werden. Diese Methode kann beispielsweise erfolgreich eingesetzt werden, um JPEG-Bilder anzuzeigen, die in einer Microsoft SQL Server-Datenbank abgelegt sind. (Verwenden Sie dabei ähnlichen Code wie im Beispiel oben.) Da Sie die HTTP-Antwort nur mit den Bilddaten senden (ohne Hyperlinkanforderung für das Bild), ist dies möglicherweise noch schneller als das Senden von Bildern an den Client nach einer direkten Client-Anforderung - vorausgesetzt, Ihr Datenbankzugriff ist entsprechend schnell. |
|
Clear | |
Response.Clear | |
Leert den aktuellen Inhalt des Response-Puffers. Dabei wird keine der gepufferten Antworten an den Client gesendet. |
|
Parameter | |
Keine |
|
Beispiel | |
<% Response.Buffer = True%> <HTML> <HEAD><TITLE>Response Clear Method Example</TITLE></HEAD> <BODY> <% On Error Resume Next [CODE TO DO SOME CALCULATIONS] lngFormulaElement1 = 47 lngFormulaElement2 = lngFormulaElement1 - 47 lngFormulaElement3 = 23 ' This next line results in a division-by-zero error ' (Error Number 11). lngNewCalcTotal = lngFormulaElement3 / lngFormulaElement2 ' This next line will still be processed because we used ' ON ERROR RESUME NEXT. If Err <> 0 Then ' The following code clears the Response buffer, writes ' an error message, and ends the response, forcing IIS to ' send the response to the client. Note that the Buffer ' property has to be set to True for the following code ' to work properly. Response.Clear Response.Write "Your request resulted in the error: " & _ Err.Description Response.Write " Error Number: " & Err.Number Response.Write "<BR>Call your web admin at 555-HELP for " Response.Write "more information." Response.End End If %> |
|
Hinweise | |
Die Methode Clear des Objekts Response löscht nicht die HTTP-Header, sondern nur deren Inhalt. Wie im Beispiel gezeigt, muss die Eigenschaft Buffer des Objekts Response auf True gesetzt sein. Andernfalls resultiert diese Methode in einem Laufzeitfehler. Einer der wichtigsten Verwendungszwecke der Methode Clear ist das Leeren des Puffers und Senden eines anderen Inhalts an den Client-Browser - häufig einer Fehlermeldung (wie im Beispiel oben). Damit Fehler entdeckt und Fehlermeldungen auf diese Art an den Client gesendet werden, muss die Eigenschaft Buffer auf True gesetzt sein, und Sie müssen die folgende Codezeile verwenden, um sicherzustellen, dass die Fehleridentifizierung verarbeitet wird: On Error Resume Next |
|
End | |
Response.End | |
Beendet die Speicherung von Informationen im Response-Puffer und sendet den aktuellen Pufferinhalt umgehend an den Client. Eventuell vorhandener Code nach dem Aufruf der Methode End wird nicht verarbeitet. Speicherkapazität, die vom Skript möglicherweise bis zum Aufruf von End vorbehalten wurde (z. B. vorher im Skript verwendete Datenbankobjekte), wird freigegeben. |
|
Parameter | |
Keine |
|
Beispiel | |
Siehe Beispiel oben für die Methode Clear. |
|
Hinweise | |
Wenn die Eigenschaft Buffer auf True gesetzt ist, wird beim Aufruf der Methode End der Response-Puffer geleert, als wenn Sie die Methode Flush (siehe nächsten Abschnitt) aufgerufen hätten. Allerdings wird, im Gegensatz zum Aufruf der Methode Flush, nach dem Aufruf von End kein weiterer Code vom Webserver verarbeitet. |
|
Flush | |
Response.Flush | |
Sendet umgehend alle zurzeit im Respones-Puffer befindlichen Daten an den Client. Wenn die Eigenschaft Buffer des Objekts Response nicht auf True gesetzt ist, resultiert diese Methode in einem Laufzeitfehler. Über diese Methode können Sie nach Belieben verschiedene Teile der Antwort an den Client senden. |
|
Parameter | |
Keine |
|
Beispiel | |
<% Response.Buffer = True%> <HTML> <HEAD><TITLE>Response Flush Method Example</TITLE></HEAD> <BODY> <% ' Suppose for this example that this first part of the ' script retrieves some information from a database and ' that retrieval takes a long time, say 30 seconds. ' (Don't worry about the details of the ActiveX Data Object ' calls. They are covered later in the book and serve only ' as an example here of something that might take a long time.) Set adoCon = Server.CreateObject("ADODB.Connection") adoCon.Open MyDatabase Set adoRec = adoCon.Execute([BIG SQL STATEMENT]) ' Rather than continue to the second part of the script, in ' which a second slow SQL statement (say another 15 seconds) ' executes, first we'll use the Flush method to force the ' first part of the script results to the client. This way, ' the user can be looking at the results of the first query ' while waiting for the second. Response.Flush ' [Second LONG SQL statement.] Set adoRec2 = adoCon.Execute([BIG SQL STATEMENT]) %> </BODY></HTML> |
|
Hinweise | |
Unter Verwendung der Pufferkapazität des Objekts Response können Sie dem Client die Antwort stückweise senden. Sie präsentieren beispielsweise eine Beschreibung Ihrer globalen Organisation, gefolgt von einer Liste der Standorte, die aus Informationen in einer Datenbank abgeleitet wird. Bei der Organisationsbeschreibung handelt es sich um einfachen Text, der nicht lange vorbereitet werden muss und sofort an den Client gesendet werden kann. Der zweite Teil der Antwort ist zeitaufwändiger. Setzen Sie hier beispielsweise die Methode Flush des Objekts Response ein, um zuerst die Organisationsbeschreibung an den Client zu senden, und die Liste dann zu übermittlen, wenn diese vollständig ist. Ohne diesen Ansatz erhält der Benutzer möglicherweise den Eindruck, dass die Seite langsam heruntergeladen wird. Beachten Sie jedoch beim Einsatz der Methode Flush auf einer Active Server Page, dass der Server die vom Client gesendeten Keep-Alive-Anforderungen für diese Seite ignoriert. Für jede an den Client zu sendende Information wird also der Aufbau einer neuen Verbindung erzwungen. |
|
Redirect | |
Response.Redirect strURL | |
Leitet die Anforderung des Clients an eine andere URL weiter. |
|
Parameter | |
|
|
Beispiel | |
<% ' The following code determines whether the client has ' security clearance for a certain page. If not, it ' is redirected to another URL. [...Code to determine user's clearance for the current page...] If Not(strUserSecurity = "ADMIN" or strUserSecurity = "SUPERADMIN") Then Response.Redirect "/security/noclearance.asp?usrid=09563" End If %> |
|
Hinweise | |
Der Wert strURL, den Sie für den Aufruf der Methode Redirect verwenden, kann eine exakte URL mit DNS oder ein virtuelles Verzeichnis mit Dateiname sein. Alternativ kann er der Name einer Datei sein, der im gleichen Ordner wie die angeforderte Seite gespeichert ist. Hat Ihr Skript einen Inhalt in den HTTP-Antwortbody geschrieben, wird dieser Inhalt vom Skript ignoriert, sobald der Aufruf der Methode Redirect ausgeführt wird. Der Aufruf der Methode Redirect ist gleichzusetzen mit der Einstellung der Eigenschaft Status auf "302 Object Moved" (302, Objekt verschoben) und dem Weiterleiten des Benutzers an einen neuen Speicherort über den HTTP-Header Location. Beachten Sie, dass bei einer Weiterleitung einige ältere Client-Browser (HTTP 1.0) POST-Anforderungen fälschlich in GET-Anforderungen ändern, wenn die neue URL aufgerufen wird. Dies ist eine wichtige Erwägung, wenn die POST-Informationen des Clients mehr Daten enthalten als die GET-Methode verarbeiten kann. Für neue Browser, die das HTTP 1.1-Protokoll unterstützen, entfällt dieses Problem. Wenn Ihre ASP-Datei unter IIS 5.0 ausgeführt wird, sollten Sie den Einsatz der Servermethode Execute bzw. Transfer in Betracht ziehen. Keine dieser Methoden zieht den kostenintensiven Weg zum Client und zurück zum Server mit sich, den die Methode Redirect erfordert. |
|
Write | |
Response.Write vntData | |
Schreibt Informationen direkt in den HTTP-Antwortbody. |
|
Parameter | |
|
|
Beispiel | |
<% strDirCommand = "Dir /w" ' The following code writes an entire HTML table to the HTTP ' response body. Response.Write "<TABLE>" Response.Write "<TR>" Response.Write "<TD WIDTH = 50%\>" Response.Write "Command" Response.Write "</TD>" Response.Write "<TD WIDTH = 50%\>" Response.Write "Description" Response.Write "</TD>" Response.Write "</TR>" Response.Write "<TR>" Response.Write "<TD WIDTH = 50%\>" Response.Write Chr(34) & strDirCommand & Chr(34) Response.Write "</TD>" Response.Write "<TD WIDTH = 50%\>" Response.Write "This allows you to see a list of the " Response.Write "files in <BR> your current folder." Response.Write "</TD>" Response.Write "</TR>" Response.Write "</TABLE>" %> |
|
Hinweise | |
Wie im Beispielprogramm veranschaulicht, können Sie die Methode Write einsetzen, um HTML- und clientseitiges Skript in den Antwortbody zu schreiben, den der Client-Browser als einfaches HTML interpretiert. Um einen Zeilenumbruch/Zeilenvorschub oder ein Anführungszeichen zu senden, verwenden Sie die Funktion ' Note: Chr(34) is a quotation mark. Chr(13) & Chr(10) is ' the equivalent of a carriage return, followed by a ' linefeed. Response.Write "Hamlet said, " & Chr(34) & _ "To be, or not to be." & Chr(34) & Chr(13) & Chr(10) Schließlich können Sie die Methode Write dazu verwenden, den Wert eines serverseitigen Skripts an den Client-Browser zu senden. Diese Methode ist in einigen Fällen "sauberer" in Ihrem Code als das Hin- und Herspringen zwischen server- und clientseitigem Code über die Schreibweise <%=...%>. Der folgende Code zeigt beispielsweise den Wert von strHighestPrice an, wobei sowohl die Methode <%=...%> als auch Response.Write eingesetzt wird: %> <% Response.Write "The highest price is " & strHighestPrice Response.Write ".<BR>" ' The same line as the preceding using the other format: %> The highest price is <%=strhighestPrice%>.<BR> |
|