AcceptTypes | |||||||||||||
stringArray = Request.AcceptTypes | |||||||||||||
Gibt ein Stringarray zurück, das die vom Client akzeptierten MIME-Typen (MIME = Multipurpose Internet Mail Extension) enthält. Mit dieser Eigenschaft können Sie feststellen, ob ein Client bestimmte Antworttypen akzeptieren kann, darunter auch Anwendungen wie Word oder Excel, die nur vom Internet Explorer unterstützt werden. Die folgende Tabelle enthält die gängigsten MIME-Typen:
|
|||||||||||||
Parameter
|
|||||||||||||
Beispiel | |||||||||||||
Das folgende Codebeispiel deklariert ein Stringarray sowie eine ganzzahlige Zählervariable und weist der Array-Variablen den Wert der Eigenschaft AcceptTypes zu. Anschließend durchläuft der Code die Array-Mitglieder mit der Zählervariablen und schreibt mithilfe des Beschriftungssteuerelements Message jeden Wert in den Browser: Die Codeausgabe sieht in etwa folgendermaßen aus: |
|||||||||||||
Sub Page_Load( ) 'Display Accept Types Dim MyArray( ) As String Dim I As Integer MyArray = Request.AcceptTypes For I = 0 To MyArray.GetUpperBound(0) Message.Text &= "Type " & CStr(I) & ": " & CStr(MyArray(I)) & _ "<br/>" Next I End Sub |
|||||||||||||
Die Codeausgabe sieht in etwa folgendermaßen aus: Typ 0: image/gifTyp 1: image/x-xbitmap Typ 2: image/jpeg Typ 3: image/pjpeg Typ 4: application/vnd.ms-powerpoint Typ 5: application/vnd.ms-excel Typ 6: application/msword Typ 7: */* |
|||||||||||||
Hinweise | |||||||||||||
Diese Eigenschaft sorgt dafür, dass der Server nicht unnötig Zeit darauf verwendet, Antworten an den Client zu schicken, die dieser nicht verarbeiten kann. So ist es möglich, als Antwort auf eine Anforderung, auf die normalerweise eine Excel-Tabelle zurückgesendet wird, ein alternatives Antwortformat an Clients zu schicken, die den MIME-Typ Excel, application/vnd.ms-excel, nicht unterstützen. |
ApplicationPath | |
stringvar = Request.ApplicationPath | |
Gibt einen String zurück, der den Pfad zum virtuellen Stammordner der aktuellen Anwendung enthält. |
|
Parameter
|
|
Beispiel | |
Das folgende Codebeispiel ruft die Eigenschaft ApplicationPath ab und schreibt sie mithilfe des Beschriftungssteuerelements Message in den Client. |
|
Sub Page_Load( ) Message.Text = Request.ApplicationPath End Sub |
|
Der Code sollte den Namen des virtuellen Stammordners der Anwendung ausgeben, an die die Anforderung gesendet wurde. |
Browser | |
bc = Request.Browser | |
Gibt eine Instanz der Klasse HttpBrowserCapabilities zurück, die die Fähigkeiten des Clientbrowsers beschreibt. Anschließend können Sie mit der Klasseninstanz feststellen, welche Fähigkeiten der Clientbrowser unterstützt. Die Klasse HttpBrowserCapabilities legt die Fähigkeiten des Clientbrowsers als Boolesche und Stringeigenschaften offen. Eigenschaften der Klasse HttpBrowserCapabilities Klasse sind:
|
|
Parameter
|
|
Beispiel | |
Sub Page_Load( ) Dim bc As HttpBrowserCapabilities bc = Request.Browser If bc.Cookies Then Message.Text = "Cookies are available with this browser" Else Message.Text = "Cookies are not available with this browser" End If End Sub |
|
Hinweise | |
Sie werden vermutlich sehr häufig mit dieser Eigenschaft arbeiten, wenn Ihre Anwendung mehrere Browser unterstützen soll und Sie einen möglichst großen Funktionsumfang für Uplevel-Browser wie Internet Explorer 5 oder 6 bzw. Netscape 6 bereitstellen möchten. Bei einigen Eigenschaften wie Cookies oder JavaScript gibt der zurückgegebene Boolesche Wert lediglich an, ob die Browserversion, die die Anforderung sendet, diese Funktionen unterstützt, nicht aber, ob sie im Browser des aktuellen Benutzers aktiviert sind. Diese Eigenschaft ist besonders wichtig, wenn Sie benutzerdefinierte Serversteuerelemente entwickeln, denn mit dieser Eigenschaft können Sie dafür sorgen, dass die benutzerdefinierten Steuerelemente ihre Ausgabe automatisch für einen bestimmten Browser bzw. eine Browserklasse optimieren. In Kapitel 6 finden Sie weitere Informationen über die Entwicklung von benutzerdefinierten Steuerelementen. |
ClientCertificate | |
cs = Request.ClientCertificate | |
Gibt eine Instanz der Klasse HttpClientCertificate zurück, die Informationen über die Sicherheitszertifikateinstellungen des Clients offen legt. Solche Eigenschaften sind beispielsweise Angaben zum Aussteller, zur Schlüsselgröße und zur zeitlichen Gültigkeit des Zertifikats. |
|
Parameter
|
|
Beispiel | |
Sub Page_Load( ) Dim cs As HttpClientCertificate cs = Request.ClientCertificate Message.Text = "Certificate Issuer is: " & cs.Issuer & "." End Sub |
|
Hinweise | |
Diese Eigenschaft eignet sich besonders für Intranet-Einstellungen, bei denen Sie Zertifikate von Ihrem eigenen Zertifikatserver an eine begrenzte Gruppe von Clients ausgegeben haben, damit diese auf Ihre Anwendung zugreifen können. Auf diese Weise ist es nicht mehr erforderlich, sich über bestimmte Daten, die im Browser angegeben werden, auszuweisen. In diesem Fall werden die Clientzertifikate NT-Benutzerkonten zugeordnet, um einen sicheren Zugang zu gewährleisten. Clientzertifikate können auch von vertrauenswürdigen Dritten ausgestellt werden, aber dieses Verfahren wird nur selten verwendet. Falls auf dem Client, von dem die Anforderung stammt, kein Clientzertifikat installiert ist, gibt diese Eigenschaft eine HttpClientCertificate-Instanz zurück, die keine gültigen Eigenschaftenwerte enthält. |
ContentEncoding | |
ce = Request.ContentEncoding | |
Gibt eine Instanz der Klasse Encoding zurück (befindet sich im Namespace System.Text), die die Zeichenkodierung für den Body der aktuellen Anforderung darstellt. |
|
Parameter
|
|
Beispiel | |
Das folgende Beispiel veranschaulicht, wie der aktuelle Wert für ContentEncoding dem Benutzer angezeigt wird: |
|
Sub Page_Load( ) Dim ce As System.Text.Encoding ce = Request.ContentEncoding Message.Text = "Current encoding is: " & ce.EncodingName & "." End Sub |
|
Bei einer Anforderung mit der Zeichenkodierung UTF-8 würde die Ausgabe folgendermaßen lauten: Current encoding is: Unicode (UTF-8). |
ContentLength | |
intvar = Request.ContentLength | |
Gibt eine Ganzzahl zurück, die die Länge der vom Client gesendeten Anforderung in Byte enthält. Diese Eigenschaft berücksichtigt nur den Inhalt im Body der HTTP-Anforderung, nicht die Länge der HTTP-Headers oder sonstiger Daten, die als Teil einer HTTP-GET-Anforderung gesendet wurden und im Header erscheinen. Wenn zur HTTP-Anforderung kein Body gehört, ist der zurückgegebene Wert 0. |
|
Parameter
|
|
Beispiel | |
Das folgende Beispiel zeigt, wie die Länge der aktuellen Anforderung im Browser angezeigt wird: |
|
Sub Page_Load( ) Dim length As Integer length = Request.ContentLength Message.Text = "Length of request was: " & length & " bytes." End Sub |
|
Der folgende Code kann zum Posten der Beispielseite verwendet werden: <html> <head> <title>Submit a named parameter via POST</title> </head> <body> <form id="form1" action="ContentLength.aspx" method="POST"> <h3>Name:</h3> <input type="text" name="name"> <input type="submit"> </form> </body> </html> |
|
Hinweise | |
Mit dieser Eigenschaft können Sie die Länge des über eine POST-Anforderung geposteten Inhalts prüfen, bevor Sie den Inhalt verarbeiten. Angenommen, Ihre Seite empfängt Dateien über ein Eingabefeld für Dateien. Damit Benutzer keine Dateien hochladen, deren Größe einen bestimmten Wert überschreitet, können Sie den Wert über die Eigenschaft ContentLength überprüfen, bevor Sie die hochgeladene Datei speichern oder verarbeiten. Wenn Sie mehrere Formularfelder empfangen, erhalten Sie genauere Angaben zur Größe einer hochgeladenen Datei, indem Sie die Eigenschaft PostedFile.ContentLength des HtmlInputFile-Steuerelements auswerten, das zum Hochladen der Dateien verwendet wurde. |
ContentType | |
stringvar = Request.ContentType | |
Gibt einen String zurück, der den MIME-Typ der jeweiligen Clientanforderung enthält. Bei GET-Anforderungen kann es vorkommen, dass diese Eigenschaft einen leeren String zurückgibt. |
|
Parameter
|
|
Beispiel | |
Das folgende Beispiel zeigt, wie Sie für Ihre Seite basierend auf der ContentType-Eigenschaft der Anforderung unterschiedliche Aktionen festlegen können: |
|
Sub Page_Load( ) Dim ct As String ct = Request.ContentType If ct = "application/x-www-form-urlencoded" Then 'Process form input Message.Text = "Form data was submitted." Else Message.Text = "Content Type of request is: " & ct End If End Sub |
|
Der folgende Code kann zum Posten der Beispielseite verwendet werden: <html> <head> <title>Submit a named parameter via POST</title> </head> <body> <form id="form1" action="ContentType.aspx" method="POST"> <h3>Name:</h3> <input type="text" name="name"> <input type="submit"> </form> </body> </html> |
|
Hinweise | |
Mit dieser Eigenschaft können Sie sicherstellen, dass der Inhaltstyp der Anforderung dem erwarteten Typ entspricht. Dies verringert das Risiko, dass unnötig Prozessorzeit mit ungültigen Anforderungen in Anspruch genommen wird, und verhindert, dass böswillige Benutzer Anforderungen an Ihre Anwendung fälschen, die ungültigen Inhalt versenden. |
FilePath | |
stringvar = Request.FilePath | |
Gibt einen String zurück, der den virtuellen Pfad der jeweiligen Clientanforderung angibt. Zum virtuellen Pfad gehören der Name des Stammordners der Anwendung, Unterordner im angeforderten Pfad und der angeforderte Dateiname. |
|
Parameter
|
|
Beispiel | |
Das folgende Codebeispiel zeigt dem Benutzer die Eigenschaft FilePath an: |
|
Sub Page_Load( ) Dim fp As String fp = Request.FilePath Message.Text = "The virtual path of the current request is: _ & "<strong>" & fp & "</strong>" End Sub |
|
Hinweise | |
Diese Eigenschaft ist identisch mit der Eigenschaft Path, die später in diesem Kapitel aufgeführt ist. |
HttpMethod | |
stringvar = Request.HttpMethod | |
Gibt einen String zurück, der die Methode (GET, POST oder HEAD) der aktuellen Anforderung enthält. |
|
Parameter
|
|
Beispiel | |
Das folgende Beispiel verwendet die Eigenschaft HttpMethod, um die Vorgehensweise für die betreffende Anforderung zu bestimmen: Sub Page_Load( ) Select Case Request.HttpMethod Case "POST" Response.Write("POST requests not allowed!<br/>") Response.End Case "HEAD" Response.Write("HEAD requests not allowed!<br/>") Response.End Case "GET" 'Process request Message.Text = "GET requests are allowed!<br/>" Case Else Response.Write("Unknown request: not allowed!<br/>") Response.End End Select End Sub Response.Write wird zum Senden der Meldung verwendet, bevor Response.End aufgerufen wird. Beim Aufruf von Response.End wird die Verarbeitung der Seite sofort beendet, wodurch keine Ausgaben des Serversteuerelements mehr generiert werden. Der Code für eine Seite, die eine POST-Anforderung an die Beispielseite sendet, sieht folgendermaßen aus: |
|
<html> <head> <title>Submit a named parameter via POST</title> </head> <body> <form id="form1" action="HttpMethod.aspx" method="POST"> <h3>Name:</h3> <input type="text" name="name"> <input type="submit"> </form> </body> </html> |
|
Hinweise | |
Im klassischen ASP wurde die Anforderungsmethode in der Regel über den Schlüssel REQUEST_METHOD der Sammlung ServerVariables abgerufen. Dieser Schlüssel wurde häufig zur Erstellung von Formularseiten, die Daten an sich selbst senden, verwendet. Dabei wurde eine Gruppe von Formularfeldern angezeigt, wenn die Methode GET erkannt wurde. Bei Erkennung der Methode POST wurden die von den Formularfeldern empfangenen Eingaben verarbeitet. ASP.NET-Webformulare enthalten bereits Kanäle zur Weiterverarbeitung von Formularen, die Eingaben an sich selbst senden. Wenn Sie ein Formular mit dem Attribut runat="server" einbinden und dem Formular mindestens ein Serversteuerelement zur Eingabe hinzufügen, müssen Sie nur die Eigenschaft IsPostBack der Seite überprüfen, um festzustellen, ob eine POST- oder GET-Anforderung eingegangen ist, und abhängig davon den gewünschten Code ausführen. |
InputStream | |
inputstream = Request.InputStream | |
Gibt ein Stream-Objekt zurück, das den Body der eingehenden HTTP-Anforderung enthält. |
|
Parameter
|
|
Beispiel | |
Das folgende Beispiel verwendet ein Byte-Array, um nach einem bestimmten Zeichen zu suchen, und kopiert dann dieses Zeichen sowie den restlichen Inhalt des Streams in einen String. Die im Beispiel verwendete Direktive @ Import sollte sich oben auf der Seite befinden: <% @ Import Namespace="System.IO" %> Sub Page_Load( ) Dim InStream As Stream Dim iCounter, StreamLength, iRead As Integer Dim OutString As String Dim Found As Boolean InStream = Request.InputStream StreamLength = CInt(InStream.Length) Dim ByteArray(StreamLength) As Byte iRead = InStream.Read(ByteArray, 0, StreamLength) InStream.Close( ) For iCounter = 0 to StreamLength - 1 If Found = True Then OutString &= Chr(ByteArray(iCounter)) End If If Chr(ByteArray(iCounter)) = "A" Then Found = True OutString &= Chr(ByteArray(iCounter)) End If Next iCounter Message.Text = "Output: " & OutString End Sub Der folgende Code kann zum Posten der Beispielseite verwendet werden: <html> <head> </head> <body> <form id="form1" action="InputStream.aspx" method="POST"> <h3>Name:</h3> <input type="text" name="name"> <input type="submit"> </form> </body> </html> Der Code gibt eine Ausgabe zurück, die das erste große A aus dem Body der Anforderung enthält. Alle Zeichen danach werden ans Ende des Streams gestellt. |
|
Hinweise | |
Diese Eigenschaft ist nützlich, wenn Sie den Body der Anforderung auf Byte-Ebene filtern möchten. Sie kann nur bei POST-Anforderungen verwendet werden, da diese die einzigen gängigen HTTP-Anforderungen mit Body sind. |
IsAuthenticated | |
boolvar = Request.IsAuthenticated | |
Gibt einen Booleschen Wert zurück, der angibt, ob die aktuelle Anforderung von einem authentifizierten Benutzer stammt. Diese Eigenschaft bezieht sich auf eine Authentifizierung anhand der NTLM-Kontodatenbank. |
|
Parameter
|
|
Beispiel | |
Der folgende Beispielcode überprüft, ob der aktuelle Benutzer authentifiziert ist. Als Ausgabe sind zwei Meldungen möglich, je nach dem Status der Benutzerauthentifizierung. Die Meldung, die an authentifizierte Benutzer ausgegeben wird, verwendet die Eigenschaft User der Seite, um Name und Domäne des aktuellen Benutzers auszugeben. |
|
Sub Page_Load( ) Dim boolAuth As Boolean boolAuth = Request.IsAuthenticated If boolAuth Then Message.Text = "User " & Page.User.Identity.Name & " is authenticated." Else Message.Text = "Current user is not authenticated." End If End Sub |
|
Hinweise | |
Zusätzlich zu der von der Klasse HttpRequest offen gelegten Eigenschaft IsAuthenticated legen zu ungefähr dem gleichen Zweck auch die Klassen FormsIdentity, WindowsIdentity und PassportIdentity eine IsAuthenticated-Eigenschaft offen. Die Eigenschaft IsAuthenticated der Klasse HttpRequest gibt den Authentifizierungsstatus des Benutzers unabhängig vom verwendeten Authentifizierungsverfahren zurück. |
IsSecureConnection | |
boolvar = Request.IsSecureConnection | |
Gibt einen Booleschen Wert zurück, der angibt, ob die aktuelle Verbindung eine SSL-Verbindung (SSL = Secure Sockets Layer) verwendet. |
|
Parameter
|
|
Beispiel | |
Das folgende Beispiel demonstriert, wie abhängig davon, ob die aktuelle Anforderung über SSL gesendet wurde, unterschiedliche Aktionen ausgeführt werden können: |
|
Sub Page_Load( ) Dim boolvar As Boolean boolvar = Request.IsSecureConnection If boolvar = True Then Message.Text = "Connection is HTTPS." Else Message.Text = "Connection is HTTP." End If End Sub |
|
Hinweise | |
Diese Eigenschaft wird meistens verwendet, um festzustellen, ob eine Anforderung beantwortet werden soll, für die zur Verschlüsselung von vertraulichen Daten (z. B. Kreditkartennummern), die möglicherweise mit der angeforderten Seite übertragen werden, eine SSL-Verbindung erforderlich ist. Diese Eigenschaft eignet sich auch bei Seiten, die sowohl mit als auch ohne SSL verwendet werden können, um die Ausgabe der Seite dem SSL-Status anzupassen. Da bei der Kommunikation mit SSL die Ver- und Entschlüsselung von Inhalten zusätzliche Leistung erfordert, sollten bei SSL-fähigen Seiten generell die Anzahl und/oder Größe der verwendeten Grafiken reduziert werden. Wenn Sie die Eigenschaft IsSecureConnection verwenden, können Sie mehr Grafiken und Grafiken mit einer höheren Auflösung einsetzen, wenn die Anforderung nicht über SSL bearbeitet wird, und bei Anforderungen über SSL weniger Grafiken bzw. Grafiken mit einer geringeren Auflösung einbinden. |
Path | |
stringvar = Request.Path | |
Gibt einen String zurück, der den virtuellen Pfad der jeweiligen Clientanforderung angibt. Zum virtuellen Pfad gehören der Name des Stammordners der Anwendung, Unterordner im angeforderten Pfad und der angeforderte Dateiname. |
|
Parameter
|
|
Beispiel | |
Das folgende Codebeispiel zeigt dem Benutzer die Eigenschaft Path an: |
|
Sub Page_Load( ) Dim path As String path = Request.FilePath Message.Text = "The virtual path of the current request is: " & path End Sub |
|
Hinweise | |
Diese Eigenschaft ist identisch mit der Eigenschaft FilePath, die weiter oben in diesem Kapitel aufgeführt ist. |
PathInfo | |
stringvar = Request.PathInfo | |
Gibt einen String mit zusätzlichen Pfadangaben zurück, die mit der aktuellen Anforderung übertragen werden (auch Pfadangaben, die nach dem Dateinamen der angeforderten Ressource an die URL angehängt werden). |
|
Parameter
|
|
Beispiel | |
Das folgende Beispiel schreibt sowohl die Eigenschaft Path als auch PathInfo in den Clientbrowser: |
|
Sub Page_Load( ) Message.Text = "Path = " & Request.Path & "<br/>" Message.Text &= "Additional Path Info = " & Request.PathInfo & "<br/>" End Sub |
|
Hinweise | |
Die Werte von Abfragestrings werden von PathInfo nicht zurückgegeben. PathInfo gibt alle Zeichen zurück, die nach dem (Datei-)Namen der Ressource auf einen Schrägstrich (/) folgen, einschließlich des Schrägstrichs selbst. |
PhysicalApplicationPath | |
stringvar = Request.PhysicalApplicationPath | |
Gibt einen String zurück, der den physischen Pfad zum Stammordner der aktuellen Anwendung enthält. |
|
Parameter
|
|
Beispiel | |
Das folgende Beispiel schreibt die Eigenschaft PhysicalApplicationPath in den Browser: |
|
Sub Page_Load( ) Dim physAppPath As String physAppPath = Request.PhysicalApplicationPath Message.Text = "Physical Application Path = " & physAppPath End Sub |
|
Hinweise | |
Diese Eigenschaft ist hilfreich, wenn Sie innerhalb der Webanwendung eine Datei erstellen oder in eine Datei schreiben müssen. Die Seite muss so keinen fest kodierten Dateisystemffad enthalten, und Sie können diese Eigenschaft in Verbindung mit einem Dateinamen verwenden, um unabhängig vom Speicherort der Datei eine Datei im selben Ordner wie der Code zu erstellen oder zu bearbeiten. |
PhysicalPath | |
stringvar = Request.PhysicalPath | |
Gibt einen String zurück, der den physischen Pfad der angeforderten Datei enthält. |
|
Parameter
|
|
Beispiel | |
Das folgende Beispiel schreibt die Eigenschaft PhysicalPath in den Browser: |
|
Sub Page_Load( ) Dim physicalPath As String physicalPath = Request.PhysicalPath Message.Text = "Physical Path = " & physicalPath End Sub |
|
Hinweise | |
Im Gegensatz zur Eigenschaft PhysicalApplicationPath, die nur den Pfad des Stammordners der Anwendung zurückgibt, gibt die Eigenschaft PhysicalPath den vollständigen physischen Pfad der angeforderten Ressource zurück, einschließlich aller Ordner in diesem Pfad und des Dateinamens der Ressource. Diese Eigenschaft leistet in Verbindung mit der Ablaufverfolgung in ASP.NET gute Dienste bei der Fehlerbehebung, wenn Dateien, die geschrieben oder gelesen werden sollen, nicht gefunden werden oder wenn erstellte Dateien sich nicht dort befinden, wo Sie sie vermuten. Trace.Write-Anweisungen in der Seite, die die Eigenschaften Path, PhysicalApplicationPath und PhysicalPath in das Trace-Protokoll schreiben, können bei der Suche nach solchen Fehlern eine große Hilfe sein. (Sie können das Trace-Protokoll aktivieren, indem Sie der Direktive @ Page das Attribut Trace="true" hinzufügen.) |
RawUrl | |
stringvar = Request.RawUrl | |
Gibt einen String zurück, der die rohe URL der aktuellen Anforderung angibt. Die rohe URL besteht aus dem Teil der URL, der auf die Domänenangabe folgt. Bei der URL http://search.support.microsoft.com/kb/c.asp lautet die rohe URL also /kb/c.asp. Falls ein Abfragestring vorhanden ist, gilt dieser als Bestandteil der rohen URL. |
|
Parameter
|
|
Beispiel | |
Das folgende Beispiel schreibt die Eigenschaft RawUrl in den Browser: |
|
Sub Page_Load( ) Dim stringvar As String stringvar = Request.RawUrl Message.Text = "The raw URL is: " & stringvar End Sub |
RequestType | |
stringvar = Request.RequestType | |
Die Eigenschaft RequestType gibt einen String mit dem aktuellen Anforderungstyp zurück (z. B. GET oder POST). |
|
Parameter
|
|
Beispiel | |
Das folgende Beispiel schreibt die Eigenschaft RequestType in den Browser: |
|
Sub Page_Load( ) Dim stringvar As String stringvar = Request.RequestType Message.Text = "The request type is: " & stringvar End Sub |
|
Hinweise | |
Zwar kann diese Eigenschaft technisch gesehen gelesen und geschrieben werden, allerdings gibt es praktisch keine Situationen, in denen eine Veränderung ihres Wertes sinnvoll wäre. Beim Auslesen dieser Eigenschaft erhalten Sie dieselben Informationen wie von der schreibgeschützten Eigenschaft HttpMethod, die weiter oben in diesem Kapitel erläutert wird. Wenn Sie versuchen, den Wert dieser Eigenschaft zu ändern, ändert sich der Wert von HttpMethod nicht entsprechend. |
TotalBytes | |
intvar = Request.TotalBytes | |
Gibt eine Ganzzahl zurück, die die Body-Größe der HTTP-Anforderung angibt. Die Eigenschaft TotalBytes berücksichtigt nicht die Größe der HTTP-Anforderungsheader oder die mit einer GET-Anforderung übertragenen Abfragestringwerte. |
|
Parameter
|
|
Beispiel | |
Das folgende Beispiel schreibt die Eigenschaft TotalBytes in den Browser: | |
Sub Page_Load( ) Dim intvar As Integer intvar = Request.TotalBytes Message.Text = "The size of the current request body is: <br/>" Message.Text &= intvar & " bytes." End Sub |
|
Der folgende Code kann zum Posten der Beispielseite verwendet werden: <html> <head> <title>Submit a named parameter via POST</title> </head> <body> <form id="form1" action="TotalBytes.aspx" method="POST"> <h3>Name:</h3> <input type="text" name="name"> <input type="submit"> </form> </body> </html> |
|
Hinweise | |
Das Verhalten dieser Eigenschaft ist identisch mit dem der Eigenschaft ContentLength, die weiter oben in diesem Kapitel beschrieben wird. |
Url | |
uriObj = Request.Url | |
Gibt eine Instanz der Klasse Uri zurück. Die darin enthaltenen Eigenschaften beschreiben die vom Benutzer angeforderte aktuelle URL. Von der Klasse Uri werden die Eigenschaften Scheme (Protokoll), Port und Host offen gelegt. |
|
Parameter
|
|
Beispiel | |
Das folgende Beispiel verwendet das von der Eigenschaft Url zurückgegebene Uri-Objekt, um Informationen über die URL für die aktuelle Anforderung in den Browser zu schreiben: |
|
Sub Page_Load( ) Dim myUri As Uri myUri = Request.Url Message.Text = "Current request URL info - <br/><br/>" Message.Text &= "Protocol: " & myUri.Scheme & "<br/>" Message.Text &= "Port: " & myUri.Port & "<br/>" Message.Text &= "Host Name: " & myUri.Host & "<br/>" End Sub |
|
Hinweise | |
Die von dieser Eigenschaft zurückgegebene Klasse Uri verfügt zwar sowohl über Methoden als auch über Eigenschaften, aber Sie werden diese Methoden (inbesondere CheckHostName und CheckSchemeName) wahrscheinlich eher verwenden, wenn Sie eine eigene Uri-Ressource erstellen, als wenn Sie die Uri-Instanz von der Eigenschaft Url empfangen. Eine Anmerkung zu "URI": "URI" steht für "Uniform Resource Identifier" (analog zu "URL" = "Uniform Resource Locator"). "URI" ist eine allgemeinere Angabe als "URL" und "URN". In den meisten Fällen sind "URI" und "URL" identisch. Bei verstärktem Einsatz von "URN" kann sich dies aber ändern. Was die Eigenschaft Url angeht, sind beide Begriffe gleichbedeutend. |
UrlReferrer | |
uriObj = Request.UrlReferrer | |
Gibt eine Instanz der Klasse Uri zurück, deren Eigenschaften die URL der Ressource angeben, von der der Benutzer zur gerade angeforderten Ressource gelangte. Falls der Benutzer nicht über eine andere Seite zur aktuellen Ressource gelangte, diese also direkt aufgerufen wurde, gibt die Eigenschaft UrlReferrer Nothing zurück. |
|
Parameter
|
|
Beispiel | |
Das folgende Beispiel verwendet das von der Eigenschaft UrlReferrer zurückgegebene Uri-Objekt, um Informationen über die URL der verweisenden Ressource in den Browser zu schreiben: |
|
Sub Page_Load( ) Dim myUri As Uri myUri = Request.UrlReferrer If Not (myUri Is Nothing) Then Message.Text = "Referral URL info - <br/><br/>" Message.Text &= "Protocol: " & myUri.Scheme & "<br/>" Message.Text &= "Port: " & myUri.Port & "<br/>" Message.Text &= "Host Name: " & myUri.Host & "<br/>" Message.Text &= "App Path: " & myUri.AbsolutePath & "<br/>" Else Message.Text = "No referral URL info available." End If End Sub |
|
Der folgende Code kann einen Link zur Beispielseite generieren: <html> <head> <title>Link to UrlReferrer</title> </head> <body> <a href="UrlReferrer.aspx">Go to UrlReferrer.aspx</a> </body> </html> |
|
Hinweise | |
Der Beispielcode gewährleistet, dass die Eigenschaft UrlReferrer eine gültige Instanz der Klasse Uri zurückgibt. Die Eigenschaft UrlReferrer gibt Nothing zurück, wenn die Seite direkt und nicht über einen Link auf einer anderen Seite aufgerufen wird. |
UserAgent | |
stringvar = Request.UserAgent | |
Gibt einen String mit dem User-Agent-Header zurück. Der User-Agent-String gibt den Browser (oder andere HTTP-fähige Clientsoftware, beispielsweise für Mobiltelefone) an, über den der Client die Anforderung eingereicht hat. Je nach Browser und Plattform kann dieser String auch Informationen zu dem vom Client verwendeten Betriebssystem sowie zur installierten Version des .NET-Frameworks (nur IE) liefern. |
|
Parameter
|
|
Beispiel | |
Das folgende Beispiel schreibt die Eigenschaft UserAgent in den Browser: |
|
Sub Page_Load( ) Dim stringvar As String stringvar = Request.UserAgent Message.Text = "User Agent: " & stringvar End Sub |
|
Hinweise | |
Wenn Sie versuchen, die Fähigkeiten des Clientbrowsers festzustellen, lässt sich dies meist einfacher mit den Eigenschaften des von der Eigenschaft Request.Browser zurückgegebenen HttpBrowserCapabilities-Objekts erreichen. Es kann aber auch Situationen geben, in denen User-Agent für einen bestimmten Client Informationen zurückgibt, die die Klasse HttpBrowserCapabilities nicht ermittelt. In diesem Fall können Sie die gewünschten Informationen dem Handler für den <browserCaps>-Konfigurationsbereich in machine.config hinzufügen (in Kapitel 8 und Kapitel 20 finden Sie weitere Informationen zur Konfiguration von ASP.NET). Erstellen Sie anschließend Ihre eigene Version der Klasse HttpBrowserCapabilities durch Vererbung von der integrierten Klasse und Hinzufügen eigener Eigenschaften für das gesuchte User-Agent-Attribut. Falls Sie sich diese Mühe nicht machen möchten, können Sie auch einfach den User-Agent-String für das gewünschte Attribut unter Verwendung der Eigenschaft UserAgent analysieren. |
UserHostAddress | |
stringvar = Request.UserHostAddress | |
Gibt die IP-Adresse des Clients zurück, von dem die Anforderung stammt. |
|
Parameter
|
|
Beispiel | |
Das folgende Codebeispiel schreibt die Eigenschaften UserHostAddress, UserHostName und UserLanguages in den Browser: |
|
Sub Page_Load( ) Dim HostAddress, HostName, Languages( ) As String Dim iCounter As Integer HostAddress = Request.UserHostAddress HostName = Request.UserHostName Languages = Request.UserLanguages Message.Text = "Client IP Address: " & HostAddress & "<br/>" Message.Text &= "Client Machine Name: " & HostName & "<br/>" For iCounter = 0 To Languages.GetUpperBound(0) Message.Text &= "Client Language " & iCounter & ": " & _ CStr(Languages(iCounter)) & "<br/>" Next iCounter End Sub |
UserHostName | |
stringvar = Request.UserHostName | |
Gibt einen String mit dem DNS-Hostnamen des Clients zurück, von dem die Anforderung stammt. |
|
Parameter
|
|
Beispiel | |
Siehe das Beispiel für die Eigenschaft UserHostAddress. |
|
Hinweise | |
Falls kein DNS-Server verfügbar ist, um die IP-Adresse des Clients in einen DNS-Namen aufzulösen, gibt die Eigenschaft UserHostName ebenso wie die Eigenschaft UserHostAddress die IP-Adresse des Clients zurück. |
UserLanguages | |
stringArray = Request.UserLanguages | |
Gibt ein sortiertes Stringarray mit einer Liste der vom Client unterstützten Sprachen zurück. |
|
Parameter
|
|
Beispiel | |
Siehe das Beispiel für die Eigenschaft UserHostAddress. |
|
Hinweise | |
Um diese Eigenschaft zu testen, können Sie in Ihrem Browser die Unterstützung für zusätzliche Sprachen aktivieren.
Wenn Sie eine Seite aufrufen, die den im Beispiel für UserHostAddress vorgestellten Code enthält, werden alle ausgewählten Sprachen in der gewählten Reihenfolge angezeigt. |
Cookies | |
HttpCookieCollection = Request.Cookies | |
Die Sammlung Cookies gibt eine Instanz der Klasse HttpCookieCollection zurück, die alle Cookies enthält, die im Rahmen der aktuellen Anforderung gesendet wurden. Die Klasse HttpCookieCollection enthält für jedes Cookie, das als Teil einer Clientanforderung übergeben wurde, eine Instanz der Klasse HttpCookie. Die Eigenschaften dieser HttpCookie-Instanzen können zum Zugriff auf Informationen über die Cookies verwendet werden. Wie auch im klassischen ASP ist die Sammlung Cookies immer noch als Sammlung implementiert (so wird HttpCookieCollection von der .NET-Klasse NameObjectCollectionBase vererbt), allerdings handelt es sich bei der ASP.NET-Implementierung weniger um eine Sammlung von Stringschlüsseln und -werten als vielmehr um eine Sammlung von Stringschlüsseln und -objekten (Instanzen der Klasse HttpCookie). Einzelne Cookies werden in Variablen des Typs HttpCookie abgerufen und ermöglichen über die Klasseneigenschaften den Zugriff auf die Werte der Cookies. 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. Über den jeweiligen Schlüssel können Sie mit der folgenden Syntax auch einzelne Werte abrufen: HttpCookie.Values(" keyname ") |
|
Parameter
|
|
Beispiel | |
Der folgende Beispielcode ruft die Cookie-Sammlung aus der Eigenschaft Cookies ab und gibt den Schlüssel und den Wert jedes Cookies sowie die Unterschlüssel von Dictionary-Cookies aus: |
|
Sub Page_Load( ) Dim Counter1, Counter2 As Integer Dim Keys(), SubKeys( ) As String Dim CookieColl As HttpCookieCollection Dim Cookie As HttpCookie ' Get Cookie collection CookieColl = Request.Cookies ' Get Cookie keys Keys = CookieColl.AllKeys ' Get cookies by index For Counter1 = 0 To Keys.GetUpperBound(0) Cookie = CookieColl(Keys(Counter1)) Message.Text = "Cookie: " & Cookie.Name & "<br/>" Message.Text &= "Expires: " & Cookie.Expires & "<br/>" ' Get keys for dictionary cookie into an array SubKeys = Cookie.Values.AllKeys ' Write dictionary cookie values to the browser For Counter2 = 0 To SubKeys.GetUpperBound(0) Message.Text &= "Key " & CStr(Counter2) + ": " & _ SubKeys(Counter2) & "<br/>" Message.Text &= "Value " & CStr(Counter2) + ": " & _ Cookie.Values(Counter2) & "<br/>" Next Counter2 Message.Text &= "<br/>" Next Counter1 End Sub |
|
Hinweise | |
Die ASP-spezifische Implementierung der Sammlung Cookies und die von der Eigenschaft Cookies zurückgegebene Klasse HttpCookieCollection legen eine gemeinsame Gruppe von Eigenschaften offen. Erläuterungen zu diesen Eigenschaften finden Sie in Abschnitt 16.3. Zwar können Sie in ASP.NET nach wie vor ein einzelnes Cookie über seinen Textschlüssel und seinen numerischen Index abrufen, aber es gibt verfahrenstechnische Unterschiede, durch die eine schlichte Übernahme von ASP-Code zur Cookie-Verarbeitung in ASP.NET nicht ohne grundlegende Änderungen zu bewerkstelligen ist. So führt beispielsweise der folgende Code zu Ausnahmefehlern: For Each strKey In Request.Cookies Response.Write strKey & " = " & Request.Cookies(strKey) & _ "<br/>" If Request.Cookies(strKey).HasKeys Then For Each strSubKey In Request.Cookies(strKey) Response.Write "->" & strKey & "(" & strSubKey & _ ") = " & Request.Cookies(strKey)(strSubKey) & "<br/>" Next End If Next Abgesehen von der Tatsache, dass dieser Code die Variablen und ihre Typen nicht explizit deklariert (beides ist standardmäßig in ASP.NET erforderlich), schlägt die Ausführung dieses Codes fehl, weil die Eigenschaft Request.Cookies(key) statt eines Strings eine Instanz von HttpCookie zurückgibt, die nicht implizit in einen String für die Anweisung Response.Write, die einen String erwartet, konvertiert werden kann. Außerdem lassen sich durch Aufruf von Request.Cookies(key) nicht die Unterschlüssel für ein Dictionary-Cookie abrufen. Zum Glück lassen sich die folgenden Änderungen, die zur Verwendung des vorherigen Codes erforderlich sind, recht einfach vornehmen: For Each strKey In Request.Cookies Message.Text = strKey & " = " & _ Request.Cookies(strKey).ToString( ) & "<br/>" If Request.Cookies(strKey).HasKeys Then For Each strSubKey In Request.Cookies(strKey).Values Message.Text = "->" & strKey & "(" & strSubKey & _ ") = " & Request.Cookies(strKey)(strSubKey).ToString( ) _ & "<br/>" Next End If Next Das erste Problem lässt sich durch die Verwendung der Methode Value von HttpCookie lösen, die den Wert des Cookies als String abruft. Zur Lösung des zweiten Problems wird die Eigenschaft Values der HttpCookie-Instanz aufgerufen, über die die Unterschlüssel eines Dictionary-Cookies abgerufen werden können. Die Verschiebung von der vorwiegend textbasierten Manipulation von Cookie-Schlüsseln und -Werten in ASP zur klassenbasierten Manipulation in ASP.NET zeigt sich auch darin, dass die Eigenschaft Expires der Klasse HttpCookie unabhängig davon verfügbar ist, ob ein Cookie gelesen oder geschrieben wird. Der Versuch, in ASP die Eigenschaft Expires eines Cookies auszulesen, würde zu einem Fehler führen. Zum Zeitpunkt des Verfassens dieser Referenz gibt die Eigenschaft Expires von HttpCookie leider nicht das Ablaufdatum des Cookies zurück. Zurückgegeben wird stattdessen der Wert "12:00:00 AM", woraus sich schließen lässt, dass diese Eigenschaft trotz ihrer prinzipiellen Lesbarkeit nicht zum Auslesen konzipiert wurde. Darüber hinaus basieren Sammlungen in ASP.NET im Gegensatz zu ASP auf Null; das erste Element jeder Sammlung und jedes Arrays ist also 0, nicht 1. Achten Sie hierauf besonders, wenn Sie Werte nach ihrem Index abrufen. |
Files | |
HttpFileCollection = Request.Files | |
Die Sammlung Files, die neu in ASP.NET ist, gibt eine Sammlung des Typs HttpFileCollection zurück, die alle durch die aktuelle Benutzeranforderung hochgeladenen Dateien enthält. Diese Sammlung ist besonders nützlich in Kombination mit dem Serversteuerelement HtmlInputFile, das die grundlegenden Kanäle zum Hochladen von Dateien über eine HTTP-POST-Anforderung bereitstellt. Wenn ein Benutzer eine oder mehrere Dateien überträgt (eine pro HtmlInputFile-Steuerelement auf der Ausgangsseite), können Sie die Dateien über die Sammlung Files abrufen. |
|
Parameter
|
|
Beispiel | |
Das folgende Codebeispiel verwendet zwei HtmlInputFile-Serversteuerelemente und einen serverseitigen <script>-Block, um Dateien hochzuladen und zu verarbeiten. Das Beispiel enthält den <form>-Abschnitt der Seite und die dazugehörigen Steuerelemente sowie den <script>-Block mit der Methode UploadBtn_OnClick, die vom Ereignis onServerClick des HtmlInputButton-Steuerelements aufgerufen wird: |
|
<!--Place between the <head> and </head> tags --> <script runat="server"> Sub UploadBtn_Click(Sender as Object, e as EventArgs) UploadForm.Visible = False If InStr(Request.ContentType, "multipart/form-data") Then Dim Counter1 As Integer Dim Keys( ) As String Dim Files As HttpFileCollection ' Load File collection Files = Request.Files ' Get names of all files into an array Keys = Files.AllKeys For Counter1 = 0 To Keys.GetUpperBound(0) Message.Text &= "File ID: " & Keys(Counter1) & "<br/>" Message.Text &= "File Name/Path: " & _ Files(Counter1).FileName & "<br/>" Next Counter1 Else Message.Text = "Wrong content type!" End If End Sub </script> <!-- This section resides between the <body> and </body> tags --> <form id="UploadForm" enctype="multipart/form-data" runat="server"> Select File To Upload to Server: <br/> <%-- MyFile and MyFile2 are HtmlInputFile controls --%> <%-- note the runat attribute --%> <input id="MyFile" type="file" runat="server"> <br/> <input id="MyFile2" type="file" runat="server"> <br/> <input id="Submit1" type="submit" value="Upload!" onserverclick="UploadBtn_Click" runat="server" > </form> <asp:label id="Message" runat="server"/> |
|
Hinweise | |
Mit ASP war das Hochladen von Dateien ein mühsamer Prozess, in dessen Verlauf meist ein Upload-Steuerelement eines Drittanbieters gesucht und erworben werden musste, welches dann auf der ASP-Seite, auf der die Dateien eingingen, zum Analysieren und Speichern der hochgeladenen Dateien eingesetzt wurde. Dank der Sammlung Files sind zum Hochladen von Dateien keine Steuerelemente von Drittanbietern mehr erforderlich. Das ist zwar ungünstig für die Entwickler solcher Steuerelemente (obwohl diese den Verlust durch das Schreiben von Serversteuerelementen vermutlich mehr als ausgleichen werden), aber ausgesprochen günstig für ASP.NET-Entwickler! Damit das Hochladen von Dateien problemlos funktioniert, sollten Sie die folgenden beiden wichtigen Punkte über die Sammlung Files nicht vergessen:
|
|
Das Hochladen funktioniert nur, wenn Sie beide Schritte durchführen. Das Codebeispiel überprüft, ob die eingehende Anforderung multipart/form-data ist, bevor der Code versucht, die Dateien abzurufen. |
|
Es ist nicht notwendig, das Steuerelement HtmlInputFile zum Hochladen von Dateien zu verwenden, die über die Sammlung Files abgerufen werden können. Vorausgesetzt, die Seite, von der die Dateien gesendet werden, verwendet die Methode POST und das Attribut enctype ist auf multipart/form-data gesetzt, können Sie die normalen HTML-Dateieingabe-Tags verwenden: <input type="file" id="myFile" name="myFile"> |
|
In diesem Beispiel wird das Attribut name verwendet, ohne das die Dateisammlung nicht die hochgeladene Datei für das Steuerelement enthielte. |
Form | |
NameValueCollection = Request.Form | |
Die Sammlung Form gibt eine Instanz der Klasse NameValueCollection zurück, die alle mit der HTTP-Anforderung POST übertragenen Formularfelder enthält. Diese Sammlung enthält nur Daten, wenn Content-Type der HTTP-Anforderung entweder application/x-www-form-urlencoded oder multipart/form-data lautet. Die Sammlung Form ist eine von zwei Möglichkeiten, Daten abhängig von der HTTP-Methode, mit der sie gesendet wurden, abzurufen. Die Sammlung Form ruft Daten ab, die über ein HTML-Formular gesendet wurden, dessen Attribut method auf POST gesetzt ist, während die Sammlung QueryString (weiter unten in diesem Abschnitt erläutert) Werte abruft, die von HTML-Formularen gesendet wurden, deren Attribut method auf GET gesetzt ist. |
|
Parameter
|
|
Beispiel | |
Das folgende Beispiel veranschaulicht, wie in ASP.NET über eine einzige Seite Werte über die HTTP-Methode POST gesendet und die Werte dann abgerufen und dem Benutzer angezeigt werden können. Das Beispiel verwendet die Eigenschaft IsPostBack der Klasse Page, um festzustellen, ob die Anforderung aus dem Abschicken des Formulars resultiert. Falls die Anforderung kein Postback ist, werden die Formularfelder angezeigt, damit der Benutzer Werte eingeben kann. Falls es sich bei der Anforderung um ein Postback handelt, ruft die Seite die Sammlung Forms ab und zeigt Name und Wert jedes Felds im Browser an. |
|
Sub Page_Load( ) If IsPostBack Then Form1.Visible = False If Request.HttpMethod = "POST" Then Dim Counter1 As Integer Dim Keys( ) As String Dim FormElements As NameValueCollection ' Get Form keys/elements FormElements=Request.Form ' Get names of form fields into array Keys = FormElements.AllKeys For Counter1 = 0 To Keys.GetUpperBound(0) Message.Text &= "Form " & Counter1 & " name: " & _ Keys(Counter1) & "<br/>" Message.Text &= "Form " & Counter1 & " value: " & _ FormElements(Counter1) & "<br/>" Next Counter1 End If Else Form1.Visible = True End If End Sub <!-- This section resides between the <body> and </body> tags --> <form id="Form1" runat="server"> First Name: <br/> <asp:Textbox id="txtFName" runat="server"/> <br/> Last Name: <br/> <asp:Textbox id="txtLName" runat="server"/> <br/> <asp:Button id="Submit" Text="Submit" runat="server"/> </form> <asp:label id="Message" runat="server"/> |
|
Hinweise | |
Die Sammlung Form legt die gleichen Eigenschaften und Methoden offen wie in Abschnitt 16.3 beschrieben und fügt folgende Methoden hinzu:
|
Headers | |
NameValueCollection = Request.Headers | |
Die Sammlung Headers gibt eine Instanz der Klasse NameValueCollection zurück, die alle mit der aktuellen Anforderung gesendeten HTTP-Header enthält. Diese Sammlung liefert dieselben Informationen, wie sie auch durch den Aufruf der Sammlung Request.ServerVariables mit dem Schlüssel ALL_HTTP zurückgegeben werden. |
|
Parameter
|
|
Beispiel | |
Das folgende Beispiel schreibt die HTTP-Header, die mit der Anforderung an den Browser übergeben werden, zuerst unter Verwendung der Methode ServerVariables("ALL_HTTP") und dann unter Verwendung der Sammlung Headers: |
|
Sub Page_Load( ) Dim AllHttp As String ' Get a String with all the HTTP headers AllHttp = Request.ServerVariables("ALL_HTTP") ' Use Replace to format the String AllHttp = Replace(AllHttp, "HTTP", "<br/>HTTP" Message.Text &= AllHttp & "<br/><br/>" Dim Counter1, Counter2 As Integer Dim Keys(), subKeys( ) As String Dim HeaderColl As NameValueCollection ' Load Headers into NameValueCollection HeaderColl=Request.Headers ' Get keys into an array Keys = HeaderColl.AllKeys For Counter1 = 0 To Keys.GetUpperBound(0) Message.Text &= "Key: " & Keys(Counter1) & "<br/>" ' Get all values under this key subKeys = HeaderColl.GetValues(Counter1) For Counter2 = 0 To subKeys.GetUpperBound(0) Message.Text &= "Value " & CStr(Counter2) & ": " & _ subKeys(Counter2) & "<br/>" Next Counter2 Next Counter1 End Sub |
|
Hinweise | |
Die Sammlung Headers gibt nur die HTTP-Header zurück, die als Teil der aktuellen Anforderung geschickt wurden. Dies unterscheidet sie von der Sammlung ServerVariables (wird weiter unten in diesem Abschnitt erläutert), die Schlüssel für alle HTTP-Header enthält, unabhängig davon, ob ein Wert übergeben wurde. Wenn die HTTP-Header nur in eine Datei geschrieben oder im Browser angezeigt werden sollen, ist es eventuell einfacher, die Sammlung ServerVariables zu verwenden. In Fällen, wo Sie auf einen bestimmten HTTP-Header über den Namen zugreifen oder die Sammlung durchlaufen müssen, ist die Sammlung Headers besser geeignet. |
Params | |
NameValueCollection = Request.Params | |
Die Sammlung Params gibt eine Instanz der Klasse NameValueCollection zurück, die Schlüssel-/Wertpaare für die Sammlungen QueryString, Form, ServerVariables und Cookies enthält. Die Sammlung Params eignet sich, um alle diese Sammlungen an eine Datei oder an den Browser auszugeben. Sie eignet sich ebenfalls zur Fehlerbehebung für eine Anwendung oder zur Verfolgung der von der Anwendung empfangenen Formularwerte, unabhängig davon, ob sie über GET (Sammlung QueryString) oder POST (Sammlung Form) empfangen werden. |
|
Parameter
|
|
Beispiel | |
Das folgende Beispiel schreibt die Schlüssel und Werte der Sammlung Params in den Browser: |
|
Sub Page_Load( ) Dim Counter1, Counter2 As Integer Dim Keys(), subKeys( ) As String Dim ParamColl As NameValueCollection ' Load Params into NameValueCollection ParamColl=Request.Params ' Get keys into an array Keys = ParamColl.AllKeys For Counter1 = 0 To Keys.GetUpperBound(0) Message.Text &= "Key: " & Keys(Counter1) & "<br/>" ' Get all values under this key subKeys = ParamColl.GetValues(Counter1) For Counter2 = 0 To subKeys.GetUpperBound(0) Message.Text &= "Value " & CStr(Counter2) & ": " & _ subKeys(Counter2) & "<br/>" Next Counter2 Message.Text &= "<br/>" Next Counter1 End Sub |
|
Der folgende Code kann zum Posten der Beispielseite verwendet werden: <html> <head> <title>Submit a named parameter via POST</title> </head> <body> <form id="form1" action="Params.aspx" method="POST"> <h3>Name:</h3> <input type="text" name="name"> <input type="submit"> </form> </body> </html> |
|
Hinweise | |
Die Sammlungen werden in der folgenden Reihenfolge aufgeführt:
Es ist zwar möglich, dass sowohl die Sammlung Form als auch die Sammlung QueryString gefüllt sind (z. B. wenn über die Methode POST der URL für das Attribut action ein Namens-/Wertpaar für den Abfragestring hinzugefügt wird), aber in der Regel sehen Sie nur eine oder die andere, aber nicht beide. |
QueryString | ||||||||||||
NameValueCollection = Request.QueryString | ||||||||||||
Die Sammlung QueryString gibt eine Instanz der Klasse NameValueCollection zurück, die alle Schlüssel und Werte enthält, die als Teil des Abfragestrings übergeben wurden, normalerweise durch das Senden eines HTML-Formulars, das die Methode GET anstatt der Methode POST verwendet. |
||||||||||||
Parameter
|
||||||||||||
Beispiel | ||||||||||||
Das folgende Beispiel schreibt den Inhalt der Sammlung QueryString in den Browser: |
||||||||||||
Sub Page_Load( ) Dim Counter1, Counter2 As Integer Dim Keys(), subKeys( ) As String Dim QSColl As NameValueCollection ' Load QS into NameValueCollection QSColl=Request.QueryString ' Get keys into an array Keys = QSColl.AllKeys For Counter1 = 0 To Keys.GetUpperBound(0) Message.Text &= "Key: " & Keys(Counter1) & "<br/>" subKeys = QSCol1.GetValues(Counter1) 'Get all values under this key For Counter2 = 0 To subKeys.GetUpperBound(0) Message.Text &= "Value " & CStr(Counter2) & ": " & _ subKeys(Counter2) & "<br/>" Next Counter2 Message.Text &= "<br/>" Next Counter1 End Sub |
||||||||||||
Der folgende Code kann verwendet werden, um Daten an die Beispielseite zu senden. Das Formularmethodenattribut wurde hier auf GET gesetzt, damit der Wert für form als Teil des Abfragestrings gesendet wird: <html> <head> <title>Submit a named parameter via POST</title> </head> <body> <form id="form1" action="QueryString.aspx" method="GET"> <h3>Name:</h3> <input type="text" name="name"> <input type="submit"> </form> </body> </html> |
||||||||||||
Hinweise | ||||||||||||
Ein Vorteil der Sammlung QueryString gegenüber der Sammlung Form ist, dass der Benutzer nicht immer ein Formular absenden muss, damit diese Sammlung verwendet werden kann. Da die Werte des Abfragestrings an die URL angehängt werden, ist es relativ einfach, an Links innerhalb von Seiten statisch Abfragestrings anzufügen oder dynamisch Anker-Tags zu erzeugen, an die die Abfragestringwerte angehängt werden. Viele Online-Shops nutzen diese Methode für ihre Katalogseiten: Eine an den Link angehängte Produkt-ID wird an die Seite übergeben, die das Produkt anzeigen soll. Diese Seite kann dann über die Sammlung QueryString die ID abrufen. Da Abfragestringwerte als an die URL angehängter einfacher Text übergeben werden, können sie leichter beschädigt werden als Werte, die aufgrund eines POST-Vorgangs übergeben werden. Wenn Sie wichtige Daten übergeben müssen oder Daten, die der Anwendung Probleme bereiten könnten, wenn sie beschädigt werden, ist es überlegenswert, diese Werte vor dem Anfügen an den Abfragestring zu verschlüsseln oder eine andere Methode zum Übergeben der Werte zu verwenden. Manche Zeichen, die bei der Verarbeitung von Abfragestrings verwendet werden, darunter &, ?, % und +, müssen kodiert werden, um eine Verwechslung zwischen ihrer Verwendung im Schlüssel-/Wertpaar und ihrer Rolle als Sonderzeichen im Abfragestring auszuschließen. In der folgenden Tabelle finden Sie die Kodierung für jedes dieser Sonderzeichen:
Sie müssen nicht versuchen, diese Codes auswendig zu lernen – verwenden Sie einfach die Methode UrlEncode der Klasse HttpServerUtility (Beschreibung in Kapitel 18), die in einem String, der an diese Methode übergeben wird, Sonderzeichen automatisch durch die entsprechenden Codes ersetzt. |
ServerVariables | |
NameValueCollection = Request.ServerVariables | |
Parameter
|
|
Beispiel | |
Das folgende Beispiel schreibt, wie auch bereits die vorherigen Beispiele zu Sammlungen, den Inhalt der Sammlung ServerVariables in den Browser: |
|
Sub Page_Load( ) Dim Counter1, Counter2 As Integer Dim Keys(), subKeys( ) As String Dim SVarsColl As NameValueCollection ' Load ServerVariables into NameValueCollection SVarsColl=Request.ServerVariables ' Get keys into an array Keys = SVarsColl.AllKeys For Counter1 = 0 To Keys.GetUpperBound(0) Message.Text &= "Key: " & Keys(Counter1) & "<br/>" subKeys = SVarsColl.GetValues(Counter1) ' Get all values under this key For Counter2 = 0 To subKeys.GetUpperBound(0) Message.Text &= "Value " & CStr(Counter2) & ": " & _ subKeys(Counter2) & "<br/>" Next Counter2 Message.Text &= "<br/>" Next Counter1 End Sub |
|
Hinweise | |
Sie können nicht nur alle Werte abrufen, indem Sie die Schlüssel durchlaufen, sondern auch auf einzelne Werte zugreifen, wenn Sie deren Schlüssel kennen. Die folgende Liste zeigt die verfügbaren Schlüssel für die Sammlung ServerVariable:
|
BinaryRead | |
byteArray = Request.BinaryRead(byteCount) | |
Gibt ein Byte-Array zurück, das die im Argument byteCount festgelegte Anzahl von Byte enthält. |
|
Parameter
|
|
Hinweise | |
Diese Methode ist rückwärtskompatibel mit klassischen ASP-Anwendungen. Bei Neuentwicklungen empfiehlt es sich, andere Methoden, wie beispielsweise die Sammlung Files, einzusetzen, um die entsprechenden Ergebnisse zu erzielen. |
MapPath | |
stringvar = Request.MapPath(virtualPath) stringvar = Request.MapPath(virtualPath, _ baseVirtualDirectory, allowCrossMapping) | |
Die Methode MapPath, die in ASP vom Server-Objekt offen gelegt wurde, ermöglicht es, für den angegebenen virtuellen Pfad den physischen Pfad auf dem Server abzurufen. In ASP.NET wird diese Methode überladen, was bedeutet, dass sie wie im vorigen Codebeispiel mit zwei verschiedenen Argumentsätzen aufgerufen werden kann. Die erste Version ist dieselbe wie bei ASP und übergibt einfach einen String, der den zuzuordnenden virtuellen Pfad enthält. Die zweite Version fügt das Argument baseVirtualDirectory hinzu, das definiert, auf welcher Basis relative Pfade aufgelöst werden, sowie das Argument allowCrossMapping , über das Sie virtuelle Pfade zuordnen können, die zu anderen Anwendungen gehören. |
|
Parameter
|
|
Beispiel | |
Das folgende Beispiel löst den Pfad des Verzeichnisses /QuickStart mit den Beispielen aus dem .NET Framework SDK auf und schreibt das Ergebnis in den Browser: |
|
Sub Page_Load( ) Dim VirPath, PhysPath, BasePath As String Dim BoolCross As Boolean = True VirPath = "/QuickStart" BasePath = "" Message.Text = Request.MapPath(VirPath, BasePath, BoolCross) End Sub |
|
Hinweise | |
Hätten wir im vorigen Beispiel die Variable BoolCross auf False gesetzt und den Beispielcode von außerhalb der QuickStart-Anwendung aus aufgerufen, würde eine HttpException ausgelöst, da dieses Argument auf True gesetzt sein muss, um Pfade anderer Anwendungen aufzulösen. |
SaveAs | |
Request.SaveAs(filename, includeHeaders) | |
Speichert die aktuelle HTTP-Anforderung auf dem Datenträger und verwendet dazu das Argument filename als Pfad und Dateinamen, unter dem die Anforderung gespeichert wird. |
|
Parameter
|
|
Beispiel | |
Das folgende Beispiel schreibt die Header der HTTP-Anforderung zu Vergleichszwecken in den Browser und speichert anschließend die aktuelle Anforderung mit und ohne Headerdaten: |
|
Sub Page_Load( ) Message.Text = Request.Headers ' Save HTTP Request and Headers to a file Request.SaveAs((Request.PhysicalApplicationPath & _ "HTTPRequest.txt"), True) ' Save HTTP Request to a file Request.SaveAs((Request.PhysicalApplicationPath & _ "HTTPRequest_NoHeaders.txt"), False) End Sub |
|
Hinweise | |
Diese Methode kann ausgesprochen nützlich beim Debuggen sein, denn damit erhalten Sie Einblick in alle Daten, die in einer bestimmten Anforderung gesendet wurden (besonders nützlich bei POST-Anforderungen). |