Buffer | |
Boolean = Response.Buffer Response.Buffer = Boolean | |
Gibt einen Booleschen Wert zurück oder legt ihn fest. Dieser Wert steuert, ob Ausgabedaten auf dem Server gepuffert und erst nach vollständiger Verarbeitung der Anforderung oder nach dem Aufruf der Methode Response.Flush oder Reponse.End gesendet werden. Der Standardwert ist True. |
|
Parameter
|
|
Hinweise | |
Diese Eigenschaft dient der Rückwärtskompatibilität mit ASP. In ASP.NET hat die Eigenschaft BufferOutput Vorrang. Neuer ASP.NET-Code sollte anstelle von Buffer BufferOutput verwenden. Ein wichtiger Unterschied zwischen der Eigenschaft Response.Buffer in ASP und den Eigenschaften Buffer und BufferOutput in ASP.NET besteht darin, dass in ASP die Eigenschaft Buffer nur bis zum Senden von Ausgaben an den Browser verändert werden konnte. Sonst trat ein Fehler auf. In ASP.NET können Sie Buffer oder BufferOutput zu jedem Zeitpunkt verändern, da diese Eigenschaften in ASP.NET kompiliert und nicht interpretiert werden. Änderungen wirken sich nur auf die Art der Pufferung aus. So können Entwickler viel flexibler festlegen, wie und wann Ausgaben gepuffert werden. Dies wird im Beispiel zu BufferOutput veranschaulicht. |
BufferOutput | |
Boolean = Response.BufferOutput Response.BufferOutput = Boolean | |
Gibt einen Booleschen Wert zurück oder legt ihn fest. Dieser Wert steuert, ob Ausgabedaten auf dem Server gepuffert und erst nach vollständiger Verarbeitung der Anforderung oder nach dem Aufruf der Methode Response.Flush oder Reponse.End gesendet werden. Der Standardwert ist True. |
|
Parameter
|
|
Beispiel | |
In diesem Beispiel wird die Eigenschaft BufferOutput auf False gesetzt und 50 mal eine Schleife durchlaufen. Bei jedem Durchlauf wird ein Punkt in die HTTP-Ausgabe gesetzt. Dieselbe Ausgabe wird auch in die Text-Eigenschaft des Beschriftungssteuerelements Message geschrieben. Für die ersten 10 und die letzten 21 Durchläufe ist BufferOutput False, für die Durchläufe 11 bis 29 True. |
|
Sub Page_Load( ) Response.BufferOutput = False Dim i As Integer For i = 1 To 50 If (i > 10 And i < 30) Then Response.BufferOutput = True Else Response.BufferOutput = False End If System.Threading.Thread.Sleep(500) Response.Write(".") Message.Text &= "." 'Response.Flush Next Response.Write("<br/>Done!<br/>") Message.Text &= "<br/>Done!<br/>" End Sub |
|
Die Codeausgabe sieht in etwa folgendermaßen aus: .................................................. Done! .................................................. Done! In der ersten Zeile werden die Punkte nacheinander ausgegeben, bis zehn Punkte angezeigt werden. Danach werden nach einer Pause 20 weitere Punkte angezeigt. Anschließend werden nacheinander die restlichen Punkte und zum Schluss die Meldung "Done!" angezeigt. Die identische Ausgabe des Beschriftungssteuerelements von ASP.NET (als HTML-<span>) wird komplett auf einmal ausgegeben, da die Ausgabe von Steuerelementen auf dem Server erst an den Client gesendet wird, wenn das Steuerelement dargestellt ist. Bei jeder Schleife im vorigen Beispiel fügt der Code also einfach einer Eigenschaft des Steuerelements, das zu einem späteren Zeitpunkt dargestellt wird, Daten hinzu. Der Text, der durch den Aufruf von Response.Write gesendet wird, wird sofort an den Browser übertragen, wenn die Pufferung ausgeschaltet wird. Ein ähnlicher Verlauf ergibt sich, wenn Sie die Response.BufferOutput-Zeilen im Beispiel auf Kommentar setzen (indem Sie der Zeile ein Hochkomma (') voranstellen) und den Kommentarstatus der Response.Flush-Zeile aufheben. Durch diese Kommentareinstellungen verläuft die Ausgabe ohne die oben beschriebene Pause. Durch den Aufruf der gemeinsamen (statischen) Methode Thread.Sleep können Sie die Verarbeitung einer ASP.NET-Anforderung für eine bestimmte Anzahl Millisekunden unterbrechen. So können Sie bei Bedarf Verarbeitungspausen einfügen. Das kann sich jedoch auf die für einzelne Anforderungen erforderliche Gesamtzeit auswirken. In Anwendungen, die hohe Skalierbarkeit erfordern, kann dies die Gesamtleistung der Anwendung in nicht akzeptablem Maße beeinträchtigen, da nur eine begrenzte Anzahl Threads für die Verarbeitung von Anforderungen zur Verfügung steht. Wenn Sie auf der Seite direkt hinter der Deklaration @ Page folgende Zeile hinzufügen, braucht der Namespace-Name beim Aufruf von Thread.Sleep nicht explizit angegeben zu werden: |
|
<%@ Import Namespace="System.Threading" %> |
|
Hinweise | |
Diese ASP.NET-Eigenschaft entspricht der ASP-Eigenschaft Buffer und sollte bei neuen Projekten bevorzugt verwendet werden. |
Cache | |||||||||||||||
HttpCachePolicy = Response.Cache | |||||||||||||||
Gibt eine Instanz der Klasse HttpCachePolicy zurück, die das Cache-Verhalten der Seite enthält. Sie können mit den von der Klasse HttpCachePolicy offen gelegten Methoden untersuchen, welche Header oder Parameter festgelegt wurden, um den Ausgabe-Cache zu variieren, oder die aktuellen Cache-Einstellungen ändern. Zur Klasse HttpCachePolicy gehören folgende Mitglieder:
|
|||||||||||||||
Parameter
|
|||||||||||||||
Beispiel | |||||||||||||||
Das folgende Beispiel ruft eine Instanz der Klasse HttpCachePolicy in eine lokale Variable ab, stellt als Gültigkeitsdauer 2 Minuten ab Verarbeitung der Seite ein und setzt das Cache-Verhalten der Seite dann auf Public. Zum Schluss wird die Eigenschaft Text des Beschriftungssteuerelements Message auf die aktuelle Zeit gesetzt. |
|||||||||||||||
Sub Page_Load( ) Dim myCachePol As HttpCachePolicy myCachePol = Response.Cache myCachePol.SetExpires(DateTime.Now.AddSeconds(120)) myCachePol.SetCacheability(HttpCacheability.Public) Message.Text = Now.ToString( ) End Sub |
|||||||||||||||
Die Seite sollte dann das aktuelle Datum und die aktuelle Uhrzeit ausgeben. Beim Aktualisieren sollte sich die Ausgabe erst nach Ablauf von 2 Minuten ändern. |
|||||||||||||||
Hinweise | |||||||||||||||
Das durch diese Eigenschaft zurückgegebene HttpCachePolicy-Objekt ist die in ASP.NET bevorzugte Methode, um das Cache-Verhalten einer Seite zu ändern. HttpCachePolicy enthält die Funktionalität, die in ASP durch die Eigenschaften CacheControl, Expires und ExpiresAbsolute erfüllt wurden. Mit der Klasse HttpCachePolicy können Sie z. B. explizit verhindern, dass der Server die jeweilige Antwort zwischenspeichert. Downstream-Caching der Antwort ist jedoch weiterhin möglich. Durch die Direktive @ OutputCache und die dazu gehörenden Attribute können Sie auch das Ausgabe-Cache-Verhalten einer Seite festlegen. Dabei haben Sie jedoch weniger Kontrolle als bei den Methoden der Klasse HttpCachePolicy. Caching mit der Direktive @ OutputCache wird in Kapitel 3 beschrieben. |
CacheControl | |
Response.CacheControl = String | |
Legt das Cache-Verhalten der aktuellen Seite fest. |
|
Parameter
|
|
Beispiel | |
|
|
Sub Page_Load( ) Response.CacheControl = "Public" Response.Expires = 2 Message.Text = Now.ToString( ) End Sub |
|
Die Ausgabe dieses Codes sollte mit der des vorherigen Beispiels identisch sein.
|
|
Hinweise | |
Anstelle dieser Eigenschaft werden jetzt die HttpCacheability-Klassenmethoden bevorzugt. |
Charset | |
String = Response.Charset Response.Charset = String | |
Gibt einen String zurück, der den Zeichensatz für die aktuelle Antwort angibt, oder legt diesen fest. Wird der String explizit festgelegt, wird der der Eigenschaft Charset zugewiesene Wert dem HTTP-Antwort-Header Content-Type hinzugefügt. |
|
Parameter
|
|
Beispiel | |
Das folgende Beispiel legt als Zeichensatz für die HTTP-Antwort Windows-1255 fest. Wie der Name schon sagt, ist dieser Zeichensatz nur unter Internet Explorer auf Windows-Clients verfügbar. In anderen Browsern oder Browsern auf anderen Betriebssystemen wird die Seite möglicherweise nicht richtig angezeigt. Der Wert für den Zeichensatz wird dann in die Text-Eigenschaft des Beschriftungssteuerelements Message geschrieben. Den Unterschied zwischen diesem Zeichensatz und dem Standardzeichensatz "utf-8" sehen Sie, wenn Sie die Seite im Internet Explorer laden, die Zeile zur Festlegung der Eigenschaft Charset auf Kommentar setzen, die Seite speichern und dann erneut im Browser laden. |
|
Sub Page_Load( ) Response.Charset = "Windows-1255" Message.Text = "Current character set is " & Response.Charset End Sub |
|
Hinweise | |
Wenn Sie versuchen, diese Eigenschaft zu ändern, nachdem die HTTP-Header an den Browser gesendet wurden, wird eine HttpException ausgelöst. Dies tritt sehr wahrscheinlich auf, wenn Sie das Puffern der Ausgabe über die Eigenschaft BufferOutput deaktivieren und anschließend den Inhalt mit Response.Write in den Browser schreiben. Ist der durch die Eigenschaft Charset festgelegte Zeichensatz für den vom Client verwendeten Browser nicht gültig, wird die Festlegung ignoriert und stattdessen der Standardzeichensatz des jeweiligen Browsers verwendet. Wie bereits erwähnt, wird mit dem Standardzeichensatz die Seite möglicherweise nicht in der gewünschten Weise angezeigt. |
ContentEncoding | |
Encoding = Response.ContentEncoding Response.ContentEncoding = Encoding | |
Gibt eine Instanz der Klasse Encoding zurück, die die Kodierung der aktuellen Antwort angibt. Die Klasse Encoding legt Eigenschaften und Methoden offen, mit denen Sie die Zeichenkodierung des Systems, also die Art der internen Speicherung von Zeichen im System, überprüfen und ändern können. Sie können z. B. eine Unicode-Zeichenfolge in ASCII, UTF-7 oder UTF-8 konvertieren. |
|
Parameter
|
|
Beispiel | |
Das folgende Beispiel verwendet die Eigenschaften der Klasseninstanz Encoding, die durch die Eigenschaft ContentEncoding zurückgegeben werden, um den Namen der aktuellen Kodierung in Klartext und als registrierten Namen (IANA) anzuzeigen. |
|
Sub Page_Load( ) Message.Text = "Current encoding is " & _ Response.ContentEncoding.EncodingName & "<br/>" Message.Text &= "Current encoding IANA name is " & _ Response.ContentEncoding.WebName & "<br/>" End Sub |
|
Hinweise | |
Die Eigenschaft ContentEncoding ist neu in ASP.NET und bietet eine umfangreichere Oberfläche zum Überprüfen und Ändern des Zeichensatzes und der Codepage-Informationen für die aktuelle Antwort. Sie bietet auch die einzige Möglichkeit, die Kodierung eines Strings zu ändern, z. B. von Unicode in ANSI. |
ContentType | |
String = Response.ContentType Response.ContentType = String | |
Gibt einen String zurück, der den MIME-Typ der aktuellen Antwort angibt, oder legt diesen fest. Damit können Sie den Wert des HTTP-Antwort-Headers Content-Type abrufen oder festlegen. |
|
Parameter
|
|
Beispiel | |
Das folgende Beispiel zeigt den aktuellen MIME-Inhaltstyp im Clientbrowser an. |
|
Sub Page_Load( ) Message.Text = "Current content type is " & _ Response.ContentType & "<br/>" End Sub |
|
Hinweise | |
Die Eigenschaft ContentType ist sehr wichtig, da Sie dadurch Inhalte an den Clientbrowser senden können, die nicht als Standard-HTML vorliegen. Wenn Sie z. B. mit der Methode Response.BinaryWrite binäre Bilddaten an den Clientbrowser senden möchten, müssen Sie auch für die Eigenschaft ContentType den entsprechenden MIME-Typ wählen (z. B. "image/jpg" oder "image/gif"). Im Beispiel für BinaryWrite sehen Sie, wie Sie dazu vorgehen. |
Expires | |
Integer = Response.Expires Response.Expires = Integer | |
Gibt einen Integerwert zurück, der angibt, wie vielen Minuten eine zwischengespeicherte Seite gültig ist, oder legt diese ganze Zahl fest. Diese Eigenschaft wird gemeinsam mit der Eigenschaft CacheControl verwendet, um das Zwischenspeichern von Antworten zu steuern. |
|
Parameter
|
|
Hinweise | |
Diese Eigenschaft gewährleistet die Rückwärtskompatibilität mit ASP. In ASP.NET werden stattdessen die Methoden der HttpCachePolicy-Instanz bevorzugt, die von der Eigenschaft Cache zurückgegeben wird. |
ExpiresAbsolute | |
DateTime = Response.Expires Response.Expires = DateTime | |
Gibt einen DateTime-Wert für den Zeitpunkt (Datum und Uhrzeit) zurück, bis zu dem eine zwischengespeicherte Antwort gültig sein soll, oder legt diesen Wert fest. |
|
Parameter
|
|
Beispiel | |
Das folgende Beispiel ermöglicht durch die Eigenschaft CacheControl das Zwischenspeichern der aktuellen Antwort und legt als absolute Gültigkeit 30 Sekunden ab der aktuellen Uhrzeit fest. |
|
Sub Page_Load( ) Response.CacheControl = "Public" Response.ExpiresAbsolute = DateTime.Now.AddSeconds(30) Message.Text = Now.ToString( ) End Sub |
|
Hinweise | |
Diese Eigenschaft gewährleistet die Rückwärtskompatibilität mit ASP. In ASP.NET werden stattdessen die Methoden der HttpCachePolicy-Instanz bevorzugt, die von der Eigenschaft Cache zurückgegeben wird. |
IsClientConnected | |
Boolean = Response.IsClientConnected | |
Gibt einen Booleschen Wert zurück, der angibt, ob der Client noch verbunden ist. False bedeutet, dass der Client nicht mehr verbunden ist. |
|
Parameter
|
|
Beispiel | |
Dieses Beispiel überprüft die Eigenschaft IsClientConnected, bevor eine längere Task gestartet wird, um zu vermeiden, dass die Task ausgeführt wird, ohne dass eine Verbindung zum Client besteht. Wenn die Eigenschaft False zurückgibt, ruft der Code die Methode Response.End auf. Obwohl der Client nicht mehr verbunden ist und keine gepufferten Ausgabedaten mehr empfangen kann (die beim Aufrufen der Methode End gesendet werden), empfiehlt es sich trotzdem, die Methode End aufzurufen, da so die weitere Verarbeitung der Seite angehalten und das Ereignis Application_EndRequest ausgelöst wird. Wenn Sie Cleanup-Code für die Seite geschrieben haben, der von der Ereignisbehandlungsroutine für Application_EndRequest ausgeführt wird, lässt sich durch Aufruf von Response.End sicherstellen, dass der Cleanup-Code ausgeführt wird, selbst wenn keine Verbindung zum Client mehr besteht. |
|
Sub Page_Load( ) 'Check client connection status If Response.IsClientConnected = False Then Response.End Else 'Start long-running processing task End If End Sub |
|
Hinweise | |
Die Eigenschaft IsClientConnected eignet sich besonders für lang andauernde Prozesse, die in großem Umfang Verarbeitungsressourcen auf dem Server belegen. Wenn Sie die Eigenschaft IsClientConnected vor oder regelmäßig während der Ausführung umfangreicher Verarbeitungsaufgaben abfragen, können Sie eine unnötige Fortführung der Verarbeitung vermeiden, wenn der Client aus irgendeinem Grund die Verbindung getrennt hat. |
Output | |||||||||||||||
TextWriter = Response.Output | |||||||||||||||
Gibt ein TextWriter-Objekt zurück, das nur geschrieben, aber nicht gelesen werden kann. Dieses Objekt schreibt Text direkt in den Ausgabestream der aktuellen Antwort. |
|||||||||||||||
Parameter
Zur Klasse TextWriter gehören folgende Mitglieder:
|
|||||||||||||||
Beispiel | |||||||||||||||
Das folgende Beispiel deklariert eine lokale Variable des Typs TextWriter, ruft eine TextWriter-Instanz aus der Eigenschaft Output ab und verwendet danach die Methode WriteLine, um den Text "Hello, World!" in den Ausgabestream schreiben. Die Methode WriteLine schreibt den angegebenen Text (bzw. bei Datentypen, die kein Stringformat haben, die Textdarstellung) zusammen mit dem durch die TextWriter-Eigenschaft NewLine festgelegten Zeilenendezeichen. Wird die Eigenschaft NewLine nicht gesetzt, beeinflusst das Zeilenendezeichen die Formatierung des an den Browser gesendeten Texts. Die Formatierung des im Browser angezeigten Texts würde jedoch nicht beeinflusst, da Browser normalerweise Leerräume, wie z. B. HTML-fremde Zeilenendezeichen, bei der Darstellung von HTML ignorieren. |
|||||||||||||||
Sub Page_Load( ) Dim myWriter As System.IO.TextWriter myWriter = Response.Output myWriter.NewLine = "<br/>" myWriter.WriteLine("Hello, World!") myWriter.WriteLine("Hello, World, once again!") End Sub |
|||||||||||||||
Hinweise | |||||||||||||||
Die Eigenschaft Output ist eine Alternative zur Methode Response.Write beim Ausgeben von Text an den Ausgabestream. Sie können auch die aus der Eigenschaft Output abgerufene TextWriter-Instanz an eine Methode einer benutzerdefinierten Komponente weitergeben, damit diese Komponente Text direkt in den Ausgabestream der aktuellen Antwort schreiben kann. Wie bei der Methode Response.Write wird beim Schreiben von Text in den Ausgabestream mit dem von der Eigenschaft Output zurückgegebenen TextWriter-Objekt die Textausgabe durch die Position des Codes beeinflusst, der den Text schreibt. Im Codebeispiel weiter oben wird der Text "Hello, World!" vor allen statischen HTML-Daten in der Seitenausgabe angezeigt. Der Grund dafür ist, dass in diesem Fall die Ausgabe von TextWriter und der Methode Response.Write verarbeitet wird, bevor die Steuerelemente auf der Seite dargestellt werden. Wenn die Ausgabe der TextWriter-Instanz und von Response.Write inline erscheinen soll, können Sie den oben angegebenen Code dort, wo die Ausgabe angezeigt werden soll, in einen <% %>-Ausgabeblock setzen. Eine bessere Alternative zur genauen Positionierung von Ausgabedaten in ASP.NET wäre es, ein ASP.NET-Literal-Serversteuerelement an der Stelle in die Datei einzufügen, an der die Ausgabe erscheinen soll, und den gewünschten Ausgabetext an die Text-Eigenschaft des Literal-Steuerelements weiterzugeben. Wenn Sie die Klasse TextWriter verwenden möchten, ohne explizit den Namespace System.IO der Variablendeklaration hinzuzufügen, können Sie die Direktive @ Import direkt unter der Direktive @ Page hinzufügen und dabei wie im folgenden Beispiel das Attribut Namespace auf System.IO setzen: <% @ Import Namespace="System.IO" %> |
OutputStream | ||||||||||||||||||||
Stream = Response.OutputStream | ||||||||||||||||||||
Gibt ein Stream-Objekt zurück, das nur geschrieben, aber nicht gelesen werden kann. Dieses Objekt schreibt binäre Inhalte direkt in den Ausgabestream der aktuellen Anforderung. |
||||||||||||||||||||
Parameter
|
Status | |
String = Response.Status Response.Status = String | |
Gibt einen String zurück (oder legt diesen fest), der die HTTP-Statuszeile enthält, die an den Clientbrowser gesendet wird. |
|
Parameter
|
|
Hinweise | |
Diese Eigenschaft dient der Rückwärtskompatibilität mit ASP. In ASP.NET hat die Eigenschaft StatusDescription Vorrang. Mit den Eigenschaften StatusCode und StatusDescription können Sie, anders als bei der Eigenschaft Status, den numerischen Statuscode der Statuszeile und die Textbeschreibung separat festlegen. |
StatusCode | |
Integer = Response.StatusCode Response.StatusCode = Integer | |
Gibt eine Ganzzahl zurück (oder legt diese fest), die den HTTP-Statuscode angibt, der an den Browser zurückgegeben wird. |
|
Parameter
Codes zwischen 100 und 199 sind für Informationsmeldungen vorgesehen. 2xx Codes zwischen 200 und 299 sind für Meldungen über erfolgreiche Vorgänge vorgesehen. 3xx Codes zwischen 300 und 399 sind für Meldungen über Umleitungsvorgänge vorgesehen. Der jeweilige Statuscode gibt an, ob eine Seite vorübergehend oder dauerhaft verschoben wurde. 4xx Codes zwischen 400 und 499 sind für Clientfehlermeldungen vorgesehen. Die bekannteste Meldung ist "404 Nicht gefunden", die angibt, dass der Client eine Ressource angefordert hat, die auf dem Server nicht vorhanden ist. In diesem Bereich finden sich auch Statusfehlermeldungen in Verbindung mit der Clientauthentifizierung. 5xx Codes von 500 bis 599 sind für Serverfehlermeldungen vorgesehen. Wenn z. B. mehr Anforderungen von IIS empfangen werden, als verarbeitet oder zur späteren Verarbeitung in eine Warteschlange gestellt werden können, erhalten Clients einen Statuscode aus dem 500er-Bereich mit einer Meldung, dass der Server überlastet ist. |
|
Beispiel | |
In diesem Beispiel wird mit den Eigenschaften StatusCode und StatusDescription eine HTTP-Statusmeldung an den Client gesendet. Die Methode Response.End stoppt die Verarbeitung und sendet die momentan gepufferte Ausgabe an den Client. |
|
Sub Page_Load( ) Response.StatusCode = 542 Response.StatusDescription = "Server Error - The code is the answer." Response.End( ) End Sub |
|
Hinweise | |
Diese Eigenschaft kann wie andere Eigenschaften, die HTTP-Antwort-Header festlegen, nicht mehr gesetzt werden, wenn bei ausgeschalteter Pufferfunktion bereits über Response.Write oder eine ähnliche Methode HTTP-Body-Ausgabedaten an den Client gesendet wurden. |
StatusDescription | |
String = Response.StatusDescription Response.StatusDescription = String | |
Gibt einen String mit dem Text der HTTP-Statusmeldung zurück (oder legt ihn fest), die zusammen mit dem in der Eigenschaft StatusCode enthaltenen Statuscode an den Browser gesendet wird. |
|
Parameter
|
|
Beispiel | |
Siehe das Beispiel für die Eigenschaft StatusCode. |
|
Hinweise | |
Diese Eigenschaft kann wie andere Eigenschaften, die HTTP-Antwort-Header festlegen, nicht mehr eingestellt werden, wenn bei ausgeschalteter Pufferfunktion bereits über Response.Write oder eine ähnliche Methode HTTP-Body-Ausgabedaten an den Client gesendet wurden. |
SuppressContent | |
Boolean = Response.SuppressContent Response.SuppressContent = Boolean | |
Gibt einen Booleschen Wert zurück (oder legt ihn fest), der angibt, ob HTTP-Ausgabedaten an den Client gesendet werden sollen. |
|
Parameter
|
|
Beispiel | |
Das folgende Beispiel schreibt "Hello, World!" in die Ausgabe (die standardmäßig gepuffert wird) und setzt SuppressContent auf True, sodass keine Ausgabedaten an den Client gesendet werden. |
|
Sub Page_Load( ) Response.Write("Hello, World!") Response.SuppressContent = True If Response.SuppressContent Then Response.Close( ) End Sub |
|
Hinweise | |
Da durch SuppressContent keine Ausgabedaten (also auch keine Fehlermeldungen) an den Client zurückgegeben werden, muss die Methode Response.Close (die die Netzwerkverbindung zum Client schließt) aufgerufen werden, damit der Clientbrowser nicht unbegrenzt lange hängen bleibt. |
Cookies | |
HttpCookieCollection = Response.Cookies | |
Die Sammlung Cookies gibt eine Instanz der Klasse HttpCookieCollection mit allen Cookies zurück, die als Teil der aktuellen Anforderung gesendet wurden. Die Klasse HttpCookieCollection enthält eine Instanz der Klasse HttpCookie für jedes Cookie, das als Teil der Clientanforderung gesendet wurde. Mit den Eigenschaften dieser HttpCookie-Instanzen können Informationen zu dem oder den Cookie(s) abgerufen werden. Die Sammlung Cookies der Klasse Response unterstützt folgende Eigenschaften:
Wie bei ASP ist die Sammlung Cookies weiterhin als Sammlung implementiert (die Klasse HttpCookieCollection erbt von der .NET-Klasse NameObjectCollectionBase). Die ASP.NET-Implementierung ist aber eine Sammlung von Stringschlüsseln und -objekten (Instanzen der Klasse HttpCookie) und keine Sammlung von Stringschlüsseln und -werten. Einzelne Cookies werden in Variablen des Typs HttpCookie abgerufen. So besteht über Klasseneigenschaften Zugriff auf Cookie-Werte. Auf Dictionary-Cookies, d. h. Cookies mit mehr als einem Wert, kann über die Eigenschaft Values der Klasse HttpCookie zugegriffen werden. Diese Eigenschaft gibt eine NameValueCollection mit den Unterschlüsseln und Werten der Cookies zurück. Mit folgender Syntax können Sie auch einzelne Werte anhand ihres Schlüssels festlegen: |
|
HttpCookie.Values(" |
|
Parameter
|
|
Beispiel | |
Das folgende Beispiel erstellt ein Login-Cookie, legt als Gültigkeitsdauer 30 Minuten ab der aktuellen Uhrzeit fest und fügt dann das Cookie der Sammlung Cookies hinzu. |
|
Sub Page_Load( ) Dim myCookie As New HttpCookie("LoggedIn") myCookie.Value = "True" myCookie.Expires = DateTime.Now.AddMinutes(30) Response.Cookies.Add(myCookie) End Sub |
|
Hinweise | |
Anders als bei ASP basieren die Sammlungen in ASP.NET auf null. Das erste Element in einer Sammlung oder einem Array ist als 0 und nicht 1. Das ist vor allem wichtig, wenn Werte anhand ihres Index abgerufen werden. |
AddCacheItemDependencies | |
Response.AddCacheItemDependencies(ByVal cacheKeys As ArrayList) | |
Fügt der Liste von Cache-Elementschlüsseln eine Liste von in einer ArrayList enthaltenen Schlüsseln hinzu, von der der Ausgabe-Cache der aktuellen Antwort abhängt. Wenn eines der von den Schlüsseln identifizierten Cache-Elementen geändert wird, wird der Ausgabe-Cache der aktuellen Antwort ungültig und eine neue Antwort erstellt. |
|
Parameter
|
|
Beispiel | |
Dieses Beispiel zeigt, wie Sie mit der Methode AddCacheItemDependencies eine Reihe von Cache-Schlüsseln als Abhängigkeiten für den Ausgabe-Cache der aktuellen Antwort festlegen können. Wird eines der durch diese Schlüssel vertretenen Cache-Elemente geändert, wird der Ausgabe-Cache ungültig und die Seite mit Response.Redirect aktualisiert. |
|
<%@ Page Language="vb" %> <%@ OutputCache Duration="300" VaryByParam="None" %> <html> <head> <title>Adding cache dependencies in ASP.NET</title> <script runat="server"> Sub Page_Load( ) Dim myArrayList As New ArrayList myArrayList.Add("Key1") myArrayList.Add("Key2") Response.AddCacheItemDependencies(myArrayList) Message.Text = DateTime.Now.ToString( ) End Sub Sub Button1_Click(sender As Object, e As EventArgs) Cache("Key1") = "foo" & DateTime.Now.ToString( ) Response.Redirect("AddCacheItemDependencies.aspx") End Sub Sub Button2_Click(sender As Object, e As EventArgs) Cache("Key2") = "bar" & DateTime.Now.ToString( ) Response.Redirect("AddCacheItemDependencies.aspx") End Sub </script> </head> <body> <form runat="server"> <asp:label id="Message" runat="server"/> <asp:button id="Button1" text="Change Key 1" onClick="Button1_Click" runat="server"/> <asp:button id="Button2" text="Change Key 2" onClick="Button2_Click" runat="server"/> </form> </body> </html> |
|
Hinweise | |
Die Methode AddCacheItemDependencies ist hilfreich, wenn Sie eine Seite im Ausgabe-Cache ablegen möchten, diese Seite aber vom Wert mehrerer im ASP.NET-Cache gespeicherter Elemente abhängt. Anstatt eine Seite auf sehr kurze Zeit zwischenzuspeichern, um das Veraltern von Daten zu vermeiden, können Sie mit AddCacheItemDependencies automatisch den Ausgabe-Cache ungültig machen, wenn sich die Abhängigkeiten ändern. |
AddCacheItemDependency | |
Response.AddCacheItemDependency(ByVal cacheKey As String) | |
Fügt einen Cache-Elementschlüssel der Liste der Cache-Schlüssel hinzu, von der der Ausgabe-Cache der aktuellen Antwort abhängt. Wenn das vom Schlüssel identifizierte Cache-Element geändert wird, wird der Ausgabe-Cache der aktuellen Antwort ungültig und eine neue Antwort erstellt. |
|
Parameter
|
|
Beispiel | |
Dieses Beispiel zeigt, wie Sie mit der Methode AddCacheItemDependency einen Cache-Schlüssel als Abhängigkeit für den Ausgabe-Cache der aktuellen Antwort festlegen können. Wird das durch diesen Schlüssel vertretene Cache-Element geändert, wird der Ausgabe-Cache ungültig und die Seite mit Response.Redirect aktualisiert. |
|
<%@ Page Language="vb" %> <%@ OutputCache Duration="300" VaryByParam="None" %> <html> <head> <title>Adding a cache dependency in ASP.NET</title> <script runat="server"> Sub Page_Load( ) Response.AddCacheItemDependency("Key1") Message.Text = DateTime.Now.ToString( ) End Sub Sub Button1_Click(sender As Object, e As EventArgs) Cache("Key1") = "foo" & DateTime.Now.ToString( ) Response.Redirect("AddCacheItemDependency.aspx") End Sub </script> </head> <body> <form runat="server"> <asp:label id="Message" runat="server"/> <asp:button id="Button1" text="Change Key 1" onClick="Button1_ Click" runat="server"/> </form> </body> </html> |
|
Hinweise | |
Die Methode AddCacheItemDependency bietet für ein einzelnes Cache-Element dieselbe Funktionalität wie die Methode AddCacheItemDependencies für mehrere Elemente. |
AddFileDependencies | |
Response.AddFileDependencies(ByVal filenames As ArrayList) | |
Fügt eine Liste von in einer ArrayList enthaltenen Dateien der Liste von Dateien hinzu, von der der Ausgabe-Cache der aktuellen Anforderung abhängt. Ändert sich eine dieser Dateien, wird der Ausgabe-Cache ungültig. |
|
Parameter
|
|
Beispiel | |
Dieses Beispiel zeigt, wie Sie mit der Methode AddFileDependencies eine Reihe von Dateien als Abhängigkeiten für den Ausgabe-Cache der aktuellen Antwort festlegen können. Ändert sich eine dieser Dateien, wird der Ausgabe-Cache ungültig. |
|
<%@ Page Language="vb" %> <%@ OutputCache Duration="300" VaryByParam="None" %> <html> <head> <title>Adding file dependencies in ASP.NET</title> <script runat="server"> Sub Page_Load( ) Dim myArrayList As New ArrayList myArrayList.Add(Server.MapPath("dep.txt")) myArrayList.Add(Server.MapPath("dep1.txt")) Response.AddFileDependencies(myArrayList) Message.Text = DateTime.Now.ToString( ) End Sub </script> </head> <body> <asp:label id="Message" runat="server"/> </body> </html> |
|
Hinweise | |
Die Methode AddFileDependencies ist nützlich, wenn Sie eine Seite im Ausgabe-Cache ablegen möchten, die Seite aber vom Wert mehrerer Dateien auf dem Webserver abhängt (auf den über einen Dateipfad des Servers zugegriffen werden kann). Anstatt eine Seite auf sehr kurze Zeit zwischenzuspeichern, um das Veraltern von Daten zu vermeiden, können Sie mit AddFileDependencies automatisch den Ausgabe-Cache ungültig machen, wenn sich die Abhängigkeiten ändern. |
AddFileDependency | |
Response.AddFileDependency(ByVal filename As String) | |
Fügt eine Datei der Dateiliste hinzu, von der der Ausgabe-Cache der aktuellen Anforderung abhängt. Wenn die im Argument Dateiname angegebenene Datei geändert wird, wird der Ausgabe-Cache ungültig. |
|
Parameter
|
|
Beispiel | |
Dieses Beispiel zeigt, wie Sie mit der Methode AddFileDependency eine Datei als Abhängigkeit für den Ausgabe-Cache der aktuellen Antwort festlegen können. Wird die Datei geändert, wird der Ausgabe-Cache ungültig. |
|
<%@ Page Language="vb" %> <%@ OutputCache Duration="300" VaryByParam="None" %> <html> <head> <title>Adding a file dependency in ASP.NET</title> <script runat="server"> Sub Page_Load( ) Response.AddFileDependency(Server.MapPath("dep.txt")) Message.Text = DateTime.Now.ToString( ) End Sub </script> </head> <body> <asp:label id="Message" runat="server"/> </body> </html> |
|
Die im obigen Code angegebene Datei dep.txt sollte sich im selben Verzeichnis befinden wie die Seite. Die Seite kann einen beliebigen Inhalt aufweisen. Ändert sich der Inhalt der Datei, wird der Cache ungültig.
|
|
Hinweise | |
Die Methode AddFileDependency bietet für eine einzelne Datei dieselbe Funktionalität wie die Methode AddFileDependencies für mehrere Dateien. |
AddHeader | |
Response.AddHeader(ByVal name As String, ByVal value As String) | |
Fügt einen HTTP-Header mit dem angegebenen Namen und Wert dem Ausgabestream hinzu. |
|
Parameter
|
|
Hinweise | |
Die Eigenschaft AddHeader sorgt für Rückwärtskompatibilität mit ASP. Anstelle dieser Eigenschaft wird jetzt die Methode AppendHeader bevorzugt. |
AppendHeader | |
Response.AppendHeader(ByVal name As String, ByVal value As String) | |
Fügt einen HTTP-Header mit dem angegebenen Namen und Wert dem Ausgabestream hinzu. Mit dieser Methode können benutzerdefinierte HTTP-Header hinzugefügt und der Wert von Standard-HTTP-Headern geändert werden. |
|
Parameter
|
|
Beispiel | |
In diesem Beispiel wird der HTTP-Header Content-Type auf "text/xml" gesetzt und der neue Wert dann angezeigt, indem die Eigenschaft Text des Beschriftungssteuerelements Message auf den Wert der Eigenschaft ContentType gesetzt wird. Dadurch wird die Seitenausgabe als XML behandelt. |
|
Sub Page_Load( ) Response.AppendHeader("Content-Type", "text/xml") Message.Text = Response.ContentType End Sub |
|
Hinweise | |
Wenn diese Methode bei HTTP-Headern verwendet wird, die sich auf das Cache-Verhalten beziehen, und restriktivere Einstellungen durch die Verwendung der Cache-APIs von ASP.NET definiert werden, erhalten die restriktiveren Einstellungen Vorrang vor den durch AppendHeader definierten Einstellungen. |
AppendToLog | |
Response.AppendToLog(ByVal param As String) | |
Fügt den Text, der durch das Argument param definiert ist, der IIS-Protokolldatei für die aktuelle IIS-Anwendung hinzu. |
|
Parameter
|
|
Beispiel | |
Das folgende Beispiel schreibt eine Meldung in das IIS-Protokoll für die Anwendung, zu der die Seite gehört. Anschließend wird eine Meldung in das ASP.NET-Beschriftungssteuerelement Message geschrieben, aus dem hervorgeht, dass eine Meldung geschrieben wurde: |
|
Sub Page_Load( ) Response.AppendToLog("Hello from Page_Load!") Message.Text = "Message written to IIS Log!" End Sub |
|
Der durch dieses Beispiel erzeugte IIS-Protokolleintrag sieht in etwa folgendermaßen aus:
|
|
2001-10-14 00:13:14 127.0.0.1 - 127.0.0.1 80 GET |
|
Hinweise | |
Im Gegensatz zur ASP-Methode AppendToLog, bei der eine Beschränkung von 80 Zeichen pro Aufruf bestand, können Sie mit der Methode AppendToLog in ASP.NET beliebig viel Text zum Protokoll hinzufügen. Die IIS-Protokolldateien befinden sich standardmäßig in %winverz%\System32\LogFiles\W3SVCx\exdatum.log. Dabei ist %winverz% der Name des Windows-Verzeichnisses, x die Nummer der Website für das Protokoll (der IIS-Metabase-Name für die gewünschte Anwendung) und datum das Erstellungsdatum der Protokolldatei. |
ApplyAppPathModifier | |
String = Response.ApplyAppPathModifier(ByVal virtualPath_ As String) | |
Ist ein virtueller Pfad zu einer Ressource festgelegt, wird ein String mit einem neuen virtuellen Pfad zurückgegeben, der die SessionID enthält. Mit diesem neuen virtuellen Pfad können Sie absolute URLs für Anwendungen erstellen, die Sitzungen ohne Cookies verwenden. |
|
Parameter
|
|
Beispiel | |
Das folgende Beispiel ruft einen virtuellen Pfad mit der SessionID ab und zeigt den Pfad über die Eigenschaft Text des Beschriftungssteuerelements Message an: |
|
Sub Page_Load( ) Dim NewPath As String NewPath = Response.ApplyAppPathModifier(Request.Path) Message.Text = "Modified virtual path = " & NewPath End Sub |
|
Die Datei web.config die festlegt, dass der Sitzungsstatus-Handler Sitzungen ohne Cookies verwendet, sieht wie folgt aus: | |
<configuration> |
|
Hinweise | |
Diese Methode ist gut geeignet, um die in ASP.NET eingeführte Funktion für Sitzungen ohne Cookies zu nutzen. Ist das Attribut cookieless im Abschnitt configuration der Datei web.config nicht auf true gesetzt, gibt diese Methode den übergebenen virtuellen Pfad einfach unverändert zurück. |
BinaryWrite | |
Response.BinaryWrite(ByVal buffer( ) As Byte) | |
Ermöglicht das Schreiben von Binärinhalten in den Ausgabestream. An der Ausgabe werden vor dem Senden des Binärinhalts an den Client keine Änderungen vorgenommen. |
|
Parameter
|
|
Beispiel | |
Nachfolgend ein Beispiel für BinaryWrite: |
|
Sub Page_Load( ) Dim ImageStream As New FileStream(MapPath("aspnetian.jpg"), _ FileMode.Open, FileAccess.Read) Dim ImageBytes(ImageStream.Length) As Byte ImageStream.Read(ImageBytes, 0, ImageStream.Length) ImageStream.Close( ) Response.ContentType = "image/bmp" Response.BinaryWrite(ImageBytes) Response.End( ) End Sub |
|
Hinweise | |
Diese Methode eignet sich vor allem dazu, aus einer Datenbank abgerufene Binärinhalte in den Browser zu schreiben. Legen Sie zum Schreiben von Bildern und anderen Nicht-Textdaten mit der Eigenschaft Response.ContentType den passenden MIME-Typ für das gesendete Bildformat fest (z. B. image/jpg). |
Clear | |
Response.Clear( ) | |
Löscht den Inhalt des aktuellen Ausgabestreams. |
|
Parameter | |
Keine | |
Hinweise | |
Die Methode Clear löscht die gesamte momentan gepufferten Ausgabe, ohne die HTTP-Antwort-Header zu löschen. Ist das Puffern von Ausgabedaten deaktiviert, da die Eigenschaft BufferOutput auf False gesetzt ist, bleibt diese Methode wirkungslos, da nur gepufferte Inhalte gelöscht werden. Dieses Verhalten unterscheidet sich von dem in ASP, wo der Aufruf von Clear bei deaktivierter Pufferfunktion einen Fehler auslöst. |
ClearContent | |
Response.ClearContent( ) | |
Löscht den Inhalt des aktuellen Ausgabestreams. |
|
Parameter | |
Keine | |
Beispiel | |
Dieses Beispiel schreibt mit Response.Write eine Meldung und ruft anschließend Response.Clear auf, um die gepufferte Ausgabe zu löschen. Bei aktivierter Pufferfunktion wird diese Meldung nie an den Browser gesendet. |
|
Sub Page_Load( ) Response.Write("This content will not be seen.") Response.Clear( ) Message.Text = _ "Content written with <i>Response.Write</i> was cleared." End Sub |
|
Hinweise | |
Die Methode ClearContent löscht die gesamte momentan gepufferte Ausgabe, ohne den HTTP-Antwort-Header zu löschen. HTTP-Header können über die Methode ClearHeaders gelöscht werden. Ist das Puffern von Ausgabedaten deaktiviert, da die Eigenschaft BufferOutput auf False gesetzt ist, bleibt die Methode ClearContent wirkungslos, da nur gepufferte Inhalte gelöscht werden. |
ClearHeaders | |
Response.ClearHeaders( ) | |
Löscht die HTTP-Header aus dem aktuellen Ausgabestream. |
|
Parameter | |
Keine | |
Beispiel | |
Dieses Beispiel setzt den HTTP-Header Content-Type auf "text/xml", löscht anschließend die HTTP-Header durch Aufruf der Methode ClearHeaders und schreibt dann den Wert der Eigenschaft Response.ContentType in die Eigenschaft Text des ASP.NET-Beschriftungssteuerelements Message. Der angezeigte Content-Type ist der Standardwert, d. h. "text/html". |
|
Sub Page_Load( ) Response.AppendHeader("Content-Type", "text/xml") Response.ClearHeaders( ) Message.Text = Response.ContentType End Sub |
|
Hinweise | |
Die Methode ClearHeaders löscht nur die HTTP-Antwort-Header, nicht den gepufferten Inhalt. |
Close | |
Response.Close( ) | |
Schließt den Netzwerk-Socket für die aktuelle Antwort. |
|
Parameter | |
Keine | |
Beispiel | |
Siehe das Beispiel für die Eigenschaft SuppressContent. |
|
Hinweise | |
Mit der Methode Close können Sie den Netzwerk-Socket für die aktuelle Antwort sofort schließen. Das Schließen führt in der Regel dazu, dass der Client eine Browserfehlermeldung erhält (wie z. B. "Server nicht gefunden"). |
End | |
Response.End( ) | |
Stoppt die Verarbeitung der aktuellen Anforderung und sendet den gesamten Pufferinhalt sofort an den Client. |
|
Parameter | |
Keine | |
Beispiel | |
Das folgende Beispiel schreibt den Text "Hello, World!" in den Browser, ruft dann Response.End auf und versucht anschließend, die Eigenschaft Text des ASP.NET-Beschriftungssteuerelements Message auf "Hello, World!" zu setzen. Der Code wird jedoch nicht ausgeführt, da die Methode End die Verarbeitung der Seite sofort stoppt. |
|
Sub Page_Load( ) Response.Write("Hello, World!") Response.End( ) Message.Text = "Hello, World!" End Sub |
|
Der Code führt dazu, dass nur der Text "Hello, World!" an den Browser ausgegeben wird, da statisches HTML und Steuerelemente nicht in der Seite angezeigt werden.
|
|
Hinweise | |
Wird die Methode End aufgerufen, werden die gepufferten Ausgabedaten an den Client gesendet, die Verarbeitung wird beendet und das Ereignis Apllication_EndRequest wird ausgelöst. |
Flush | |
Response.Flush( ) | |
Sendet alle gepufferten Ausgabedaten sofort an den Client. |
|
Parameter | |
Keine | |
Beispiel | |
Siehe das Beispiel für die Eigenschaft BufferOutput. Wenn Sie die Zeilen, in denen BufferOutput auf False gesetzt wird, auf Kommentar setzen und den Kommentarstatus für die Zeile, die Response.Flush aufruft, aufheben, sehen Sie, dass Sie mit der Methode Flush gepufferte Inhalte explizit an den Browser senden können. |
|
Hinweise | |
Die Methode Flush ist sehr nützlich, da die Pufferfunktion in ASP.NET standardmäßig aktiviert ist. Anstatt die Pufferfunktion zu deaktivieren, was dazu führt, dass jeglicher durch Aufruf von Response.Write gesendeter Inhalt sofort an den Browser gesendet wird, können Sie mit Response.Flush Inhalte abschnittsweise senden oder sicherstellen, dass ein Vorgang vor dem Senden des bis zu diesem Zeitpunkt gepufferten Inhalts vollständig abgeschlossen ist. Sie können auch alle Response.Flush-Aufrufe mit Response.Clear-Aufrufen kombinieren, um Inhalte vor der Übertragung an den Browser zu überprüfen. Tritt bei einer Reihe von Berechnungen oder Ausgaben ein Fehler auf, können Sie mit Response.Clear die problematische Ausgabe löschen und durch eine Fehlermeldung oder anderen Inhalt ersetzen. Liegen keine Probleme mit der Ausgabe vor, können Sie mit Response.Flush den gepufferten Inhalt an den Browser senden und dann die Verarbeitung fortsetzen. |
Pics | |
Response.Pics(ByVal value As String) | |
Fügt dem Ausgabestream für die aktuelle Antwort einen PICS-Label-Header hinzu. PICS (Platform for Internet Content Selection) dient zum Bewerten von Gewalt darstellenden und pornographischen Inhalten, Nacktaufnahmen sowie Inhalten mit nicht jugendfreier Sprache im Internet. |
|
Parameter
|
|
Beispiel | |
Das folgende Beispiel definiert einen PICS-Header, der "RSAC" als bewertende Organisation angibt, als Bewertungszeitraum den 01.08.2001 bis 28.02.2002 bestimmt und folgende Bewertungsstufen definiert:
|
|
|
|
Sub Page_Load( ) Dim PICSLabel As String PICSLabel &= "(PICS-1.1 <http://www.rsac.org/ratingsv01.html> " PICSLabel &= "labels on " & Chr(34) PICSLabel &= "2001.08.01T06:00-0000" & Chr(34) PICSLabel &= " until " & Chr(34) PICSLabel &= "2002.02.28T23:59-0000" & Chr(34) PICSLabel &= " ratings (V 1 S 2 L 3 N 4))" Response.PICS(PICSLabel) Message.Text = PICSLabel End Sub |
|
Hinweise | |
Der PICS-Label-Header dient der Bewertung des Inhalts einer Website. Benutzer können ihren Browser so konfigurieren, dass Sites nicht angezeigt werden, wenn sie PICS-Label-Headers senden und ihr Inhalt in einer der bewerteten Kategorien die für den Browser konfigurierte Stufe übersteigt. Weitere Informationen zum PICS-Standard zur Bewertung von Inhalten finden Sie auf der Website des World Wide Web Consortium unter http://www.w3c.org. |
Redirect | |
Response.Redirect(ByVal url As String) Response.Redirect(ByVal url As String, ByVal endResponse As Boolean) | |
Leitet die momentan ausgeführte Seite an eine andere im Argument url angegebene Seite um und beendet optional die Verarbeitung der aktuellen Seite. |
|
Parameter
|
|
Beispiel | |
Dieses Beispiel leitet die aktuelle Anforderung an BufferOutput.aspx um und weist ASP.NET an, die Verarbeitung der aktuellen Seite abzubrechen: |
|
Sub Page_Load( ) Response.Redirect("BufferOutput.aspx", True) End Sub |
|
Hinweise | |
Sofern auf der Seite, von der aus Response.Redirect aufgerufen wird, keine weitere Verarbeitung erforderlich ist, sollten Sie an Response.Redirect als zweites Argument immer True übergeben. So wird verhindert, dass unnötig Serverressourcen durch weiteres Verarbeiten der aktuellen Seite beansprucht werden. Diese Funktion ist neu in ASP.NET. Wird Response.Redirect nur mit dem Argument url aufgerufen, wird die Verarbeitung der aktuellen Seite automatisch unterbrochen. Erfolgt die Weiterleitung an eine Seite wie BufferOutput.aspx, in der das Puffern deaktiviert ist, oder an eine Seite, die Response.Flush aufruft, wird die Weiterleitung erst abgeschlossen, wenn die Verarbeitung der Zielseite abgeschlossen ist. So wird der gesamte Inhalt der Zielseite auf einmal angezeigt und nicht nach und nach aufgebaut oder aus dem Puffer ausgegeben. |
Write | |
Response.Write(ByVal ch As Char) Response.Write(ByVal obj As Object) Response.Write(ByVal s As String) Response.Write(ByVal buffer( ) As Char, ByVal index As Integer, ByVal count As Integer) | |
Ermöglicht das Schreiben von beliebigen Inhalten in den Ausgabestream. Bei den Inhalten kann es sich um Zeichendaten, Objekte (mit der Methode ToString( ) des Objekts) oder Stringdaten handeln. |
|
Parameter
|
|
Beispiel | |
Das Beispiel erstellt ein Array von Zeichen, legt Werte für die Zeichen fest, durchläuft das Array und zeigt durch Aufruf von Response.Write den Inhalt an: |
|
Sub Page_Load( ) Dim MyChars(2) As Char Dim MyChar As Char MyChars(0) = CChar("A") MyChars(1) = CChar("B") MyChars(2) = CChar("C") For Each MyChar in MyChars Response.Write(MyChar) Next End Sub |
|
Hinweise | |
Wie oben beschrieben, verfügt die Methode Write in ASP.NET über eine Reihe überladener Implementierungen. Der oben angegebene Code könnte auch mit einer anderen überladenen Implementierung geschrieben werden, die wie folgt ein Zeichenarray, einen Startindex und die Anzahl der zu schreibenden Zeichen akzeptiert: Response.Write(MyChars, 0, 3) Die Implementierung der Methode Write, die ein Objekt als Argument akzeptiert, nutzt die eingebaute Methode ToString der Objektklasse, um die Stringdarstellung des Objekts anzuzeigen. ToString wird von jeder .NET-Klasse geerbt und gibt standardmäßig den Namespace- und Klassennamen der Klasse des Objekts zurück. Klassen, die andere Informationen über sich selbst senden möchten, können die geerbte Implementierung von ToString übergehen, um diese Informationen zu senden. |
WriteFile | |
Response.WriteFile(ByVal fileName As String) Response.WriteFile(ByVal fileName As String, ByVal includeHeaders As Boolean) Response.WriteFile(ByVal fileHandle As IntPtr, ByVal offset As Long, ByVal size As Long) Response.WriteFile(ByVal fileName As String, ByVal offset As Long, ByVal size As Long) | |
Schreibteine in den überladenen Argumenten angegebene Datei in den Ausgabestream. |
|
Parameter
|
|
Beispiel | |
Das folgende Beispiel schreibt den Inhalt der Datei dep.txt in den Ausgabestream der aktuellen Antwort. |
|
Sub Page_Load( ) Response.WriteFile("dep.txt") End Sub |
|
Hinweise | |
Die Methode WriteFile bietet mehrere (zum Beispiel Bilddaten), schlagen fehl. |