AcceptTypes |
stringArray = Request.AcceptTypes |
Retourne un tableau de chaînes contenant les types MIME (Multipurpose Internet Mail Extension) acceptés par le client. Vous pouvez utiliser cette propriété pour déterminer si un client est en mesure d'accepter certains types de réponse, y compris des types d'application comme Word ou Excel, qui ne sont pris en charge que par Internet Explorer. Le tableau suivant dresse une liste des types MIME les plus fréquents:
MIME type | Description
--- | ---
text/html | Contenu du texte HTML
text/xml | Contenu du texte XML
image/gif | Données graphiques au format GIF
image/jpg | Données graphiques au format JPEG
application/msword | Données binaires pour Microsoft Word
Paramètres stringArray Un tableau de chaînes qui reçoit le tableau des types d'acceptation de la propriété.
Exemple
Avec cet échantillon de code, on déclare un tableau de chaînes et une variable de compteur de nombres entiers et on attribue la valeur de propriété AcceptTypes à la variable de tableau. Puis on réitère les éléments de tableau à l'aide de la variable de compteur, tout en écrivant chaque valeur dans le navigateur à l'aide du contrôle d'étiquette de Message:
    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
Le résultat du code aura à peu près l'aspect suivant: Type 0: image/gif Type 1: image/x-xbitmap Type 2: image/jpeg Type 3: image/pjpeg Type 4: application/vnd.ms-powerpoint Type 5: application/vnd.ms-excel Type 6: application/msword Type 7: */*
Remarques
Cette propriété peut permettre au serveur d'éviter de perdre son temps à envoyer des réponses au client que celui-ci ne peut pas traiter. Par exemple, une requête qu'il serait normal de satisfaire en renvoyant une feuille de calcul Excel pourra être satisfaite à l'aide d'un type de réponse alternatif pour les clients qui ne prennent pas en charge le type MIME Excel, application/vnd.ms-excel .

ApplicationPath |
stringvar = Request.ApplicationPath |
Renvoie une chaîne contenant le chemin vers la racine virtuelle de l'application considérée.
Paramètres stringvar Une variable de chaîne servant à recevoir la valeur de la propriété ApplicationPath.
Exemple
Avec cet échantillon de code, on récupère l'ApplicationPath et on l'inscrit dans le client à l'aide du contrôle d'étiquette de Message:
    Sub Page_Load(  )
       Message.Text = Request.ApplicationPath
    End Sub
Le résultat du code sera en principe le nom de la racine virtuelle de l'application à laquelle la requête a été envoyée.

Browser |
bc = Request.Browser |
Renvoie une instance de la classe HttpBrowserCapabilities qui décrit les capacités du navigateur du client. Vous pouvez dès lors utiliser l'instance de classe pour déterminer les capacités prises en charge par le navigateur du client. La classe HttpBrowserCapabilities présente les capacités du navigateur du client sous la forme d'un ensemble de propriétés booléennes et de chaînes. Parmi les propriétés de la classe HttpBrowserCapabilities figurent les propriétés suivantes: ActiveXControls Une valeur booléenne qui indique si le navigateur prend en charge ou non les contrôles ActiveX. AOL Une valeur booléenne qui indique si le navigateur est un navigateur AOL ou non. BackgroundSounds Une valeur booléenne qui indique si le navigateur prend en charge ou non les sons d'ambiance. Beta Une valeur booléenne qui indique si le navigateur est un logiciel bêta ou non. Browser Une chaîne contenant la valeur de l'en-tête User-Agent. CDF Une valeur booléenne qui indique si le navigateur prend en charge ou non le format de définition de canal pour repousser le contenu. ClrVersion Renvoie un objet System.Version contenant des informations concernant la version de CLR installée (si elle existe) sur la machine client (à partir de l'en-tête User-Agent). Si ClrVersion n'a pas pour valeur Nothing , vous pouvez récupérer les informations de version à partir de quatre de ses propriétés de nombre entier: Major, Minor, Revision et Build. Cookies Une valeur booléenne qui indique si le navigateur prend en charge ou non les cookies. Crawler Une valeur booléenne qui indique si le navigateur est un compilateur web de moteurs de recherche ou non. EcmaScriptVersion Renvoie une instance de la classe Version contenant des informations sur la version d'ECMAScript prise en charge par le navigateur du client. Si EcmaScriptVersion n'a pas pour valeur Nothing , vous pouvez récupérer les informations de version à partir de quatre de ses propriétés de nombre entier: Major, Minor, Revision et Build. Frames Une valeur booléenne qui indique si le navigateur prend en charge ou non les cadres. Item Une interface entre le Dictionnaire et les valeurs (soit, Request.Browser.Item( keyname ) ). JavaApplets Une valeur booléenne qui indique si le navigateur prend en charge ou non les applets Java. JavaScript Une valeur booléenne qui indique si le navigateur prend en charge JavaScript ou non. MajorVersion Un nombre entier qui représente le numéro de version principale du navigateur (par exemple, pour IE 3.01, la propriété MajorVersion renverra 3). MinorVersion Un nombre à deux chiffres qui représente le numéro de sous-version du navigateur (par exemple, pour IE 3.01, la propriété MinorVersion renverra .01). MSDomVersion Renvoie une instance de la classe Version contenant des informations concernant la version du modèle de document (DOM) XML de Microsoft prise en charge par le navigateur du client. Si MSDomVersion n'a pas pour valeur Nothing , vous pouvez récupérer les informations de version à partir de quatre de ses propriétés de nombre entier: Major, Minor, Revision et Build. Platform Une chaîne contenant le nom de plate-forme (s'il existe) figurant dans l'en-tête User-Agent. Tables Une valeur booléenne qui indique si le navigateur prend en charge ou non les tableaux HTML. Type Une chaîne contenant le nom et la version principale du navigateur du client. VBScript Une valeur booléenne qui indique si le navigateur prend en charge VBScript ou non. Version Une chaîne contenant à la fois le numéro principal de version et celui de sous-version du navigateur du client. W3CDomVersion Renvoie une instance de la classe Version contenant des informations sur la version de DOM XML du World Wide Web Consortium (W3C) prise en charge par le navigateur du client. Si W3CDomVersion n'a pas pour valeur Nothing , vous pouvez récupérer les informations de version à partir de quatre de ses propriétés de nombre entier: Major, Minor, Revision et Build. Win16 Une valeur booléenne qui indique si le client est une machine Win16 ou non. Win32 Une valeur booléenne qui indique si le client est une machine Win32 ou non.
Paramètres bc Une variable d'objet de type HttpBrowserCapabilities.
Exemple
    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
Remarques
Vous risquez d'utiliser fréquemment cette propriété si vous envisagez de prendre en charge plusieurs navigateurs et s'il vous faut fournir un niveau de fonctionnalité très élevé dans le cas de navigateurs de haut niveau tels que Internet Explorer 5 ou 6, ou bien Netscape 6. Pour certaines propriétés, comme les Cookies et JavaScript, la valeur booléenne renvoyée indique seulement si la version du navigateur à l'origine de la requête prend en charge ces fonctions, et non pas si elles sont par exemple activées dans le navigateur de l'utilisateur en question. Cette propriété est particulièrement importante lors de la mise en oeuvre de contrôles de serveur personnalisés, étant donné qu'elle vous permet d'obliger vos contrôles personnalisés à adapter automatiquement leur action à un navigateur (ou à une classe de navigateurs) donné(e). Reportez-vous au chapitre 6 pour plus de détails concernant la mise en oeuvre de contrôles personnalisés.

ClientCertificate |
cs = Request.ClientCertificate |
Renvoie une instance de la classe HttpClientCertificate qui comporte des informations en matière de paramètres de certificat de sécurité du client. Ces propriétés incluent les informations concernant l'émetteur, la taille de clé et les dates de validité du certificat.
Paramètres cs Une variable d'objet de type HttpClientCertificate.
Exemple
    Sub Page_Load(  )
       Dim cs As HttpClientCertificate
       cs = Request.ClientCertificate
       Message.Text = "Certificate Issuer is: " & cs.Issuer & "."
    End Sub
Remarques
Vous risquez d'utiliser cette propriété dans les paramètres Intranet, où vous avez fourni un ensemble limité de clients avec certificats (provenant de votre propre serveur de certificat) pour accéder à votre application, plutôt que de leur demander de s'authentifier à l'aide d'un ensemble de recommandations saisies par le biais du navigateur. Dans ce cas, les certificats de client sont associés aux comptes d'utilisateurs NT afin d'offrir un accès sécurisé. Les certificats de client peuvent également être émis par des tiers reconnus, mais cette méthode est rarement employée. Si aucun certificat de client n'est installé sur le client demandeur, cette propriété renvoie une instance HttpClientCertificate sans valeurs de propriété valables.

ContentEncoding |
ce = Request.ContentEncoding |
Renvoie une instance de la classe Encoding (située dans l'espace de nom System.Text), qui représente le codage de caractères du corps de la requête considérée.
Paramètres ce Une variable d'objet de type Encoding.
Exemple
L'exemple montre comment afficher le ContentEncoding considéré à l'utilisateur:
    Sub Page_Load(  )
       Dim ce As System.Text.Encoding
       ce = Request.ContentEncoding
       Message.Text = "Current encoding is: " & ce.EncodingName & "."
    End Sub
Pour une requête utilisant un codage de contenu UTF-8, le résultat de cet exemple sera:
    Current encoding is: Unicode (UTF-8).

ContentLength |
intvar = Request.ContentLength |
Renvoie un nombre entier contenant la longueur, en octets, de la requête envoyée par le client. Cette propriété ne comporte que le contenu envoyé dans le corps de la requête HTTP et n'indique pas la longueur des en-têtes HTTP ou de toute donnée envoyée dans le cadre d'une requête HTTP GET (qui apparaîtra dans les en-têtes). Si la requête HTTP ne contient pas de corps, sa valeur est 0.
Paramètres intvar Une variable entière censée recevoir la longueur du contenu, exprimée en octets.
Exemple
Cet exemple montre comment afficher dans le navigateur la longueur de la requête considérée:
    Sub Page_Load(  )
       Dim length As Integer
       length = Request.ContentLength
       Message.Text = "Length of request was: " & length & " bytes."
    End Sub
Le code suivant peut être utilisé pour envoyer du contenu à la page d'exemple:
    <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>
Remarques
Vous pouvez utiliser cette propriété pour tester la longueur de contenu transmise à l'aide d'une requête POST avant d'agir sur le contenu en question. Par exemple, si votre page reçoit des fichiers d'un champ d'entrée de fichier, vous pourrez vérifier la propriété ContentLength avant de sauvegarder ou de traiter le fichier téléchargé afin d'éviter que les utilisateurs ne téléchargent des fichiers supérieurs à une taille donnée. Veuillez noter que si vous recevez de multiples champs de formulaires, vous pouvez obtenir plus de données spécifiques concernant la taille d'un fichier téléchargé en vous reportant à la propriété PostedFile.ContentLength du contrôle HtmlInputFile utilisé pour soumettre les fichiers.

ContentType |
stringvar = Request.ContentType |
Renvoie une chaîne contenant le type MIME de la requête client considérée. Dans le cas des requêtes GET, il peut arriver que cette propriété renvoie une chaîne vide.
Paramètres stringvar Une variable de chaîne chargée de recevoir le type de contenu.
Exemple
Cet exemple vous montre comment effectuer différentes actions sur votre page, en fonction du ContentType de la requête:
    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
Le code suivant peut servir à envoyer du contenu à la page d'exemple:
    <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>
Remarques
Il est possible d'utiliser cette propriété pour s'assurer que le type de contenu de la requête est bien celui que vous souhaitez. Cela peut permettre d'éviter de perdre son temps à traiter des requêtes invalides et d'empêcher des utilisateurs mal intentionnés d'essayer de simuler des requêtes à votre application à l'aide de contenus inattendus.

FilePath |
stringvar = Request.FilePath |
Renvoie une chaîne contenant le chemin virtuel de la requête client considérée. Le chemin virtuel comporte le nom du répertoire racine d'application, tous les sous-repertoires du chemin de requête et le nom du fichier demandé.
Paramètres stringvar Une variable de chaîne chargée de recevoir le chemin de fichier.
Exemple
Dans cet exemple, on affiche la propriété FilePath à l'intention de l'utilisateur.
    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
Remarques
Cette propriété est identique à la propriété Path répertoriée plus loin dans ce chapitre.

HttpMethod |
stringvar = Request.HttpMethod |
Renvoie une chaîne contenant la méthode (soit GET, POST ou HEAD) de la requête considérée.
Paramètres stringvar Une variable de chaîne chargée de recevoir la méthode HTTP de la requête considérée.
Exemple
Dans cet exemple, on utilise la propriété HttpMethod pour déterminer l'action à prendre dans le cas d'une requête donnée:
    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
Veuillez noter que l'on utilise Response.Write pour envoyer le message avant d'invoquer Response.End. Le fait d'invoquer Response.End entraîne l'interruption immédiate du traitement de la page, ce qui empêche également d'observer un quelconque effet des processus de contrôle du serveur. Le code d'une page effectuant une requête POST à la page d'exemple a l'aspect suivant:
    <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>
Remarques
En ASP classique, la méthode de requête était généralement récupérée à l'aide de la clé REQUEST_METHOD de la collection de ServerVariables. Souvent, cette clé servait à créer des pages de formulaire à présentation automatique par affichage d'un ensemble de champs de formulaires -lorsque la méthode GET était détectée- et par traitement du signal reçu des champs de formulaires dans le cas de la méthode POST. Les formulaires web d'ASP.NET fournissent un plombage intégré pour les formulaires à présentation automatique. Une fois qu'il a ajouté un formulaire doté de l'attribut runat="server" et incorporé un ou plusieurs contrôles de serveur d'entrée, le développeur n'a plus qu'à vérifier la propriété IsPostBack de la page pour déterminer si une requête POST ou GET a été reçue ou non, et exécuter le code souhaité en fonction de la propriété en question.

InputStream |
inputstream = Request.InputStream |
Renvoie un objet Stream (flux) contenant le corps de la requête HTTP entrante.
Paramètres inputstream Une variable d'objet de type Stream.
Exemple
Cet exemple utilise un tableau d'octets pour rechercher un caractère donné, puis copie ce caractère et le contenu de flux restant dans une chaîne. La directive @ Import figurant dans cet exemple doit être placée en haut de la page:
    <% @ 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
Le code suivant peut servir à envoyer du contenu à la page d'exemple:
    <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>
Le code renvoie comme résultat le premier A majuscule figurant dans le corps de la requête. Tous les caractères suivants sont renvoyés à la fin du flux.
Remarques
Cette propriété est utile si vous souhaitez appliquer un filtre d'octet au corps de la requête. Elle ne fonctionne qu'avec les requêtes POST, étant donné que celles-ci sont les seules requêtes HTTP dotées d'un corps de requête parmi celles qui sont utilisées habituellement.

IsAuthenticated |
boolvar = Request.IsAuthenticated |
Renvoie une valeur booléenne qui indique si la requête considérée provient d'un utilisateur authentifié ou non. Cette propriété concerne l'authentification vis-à -vis de la base de données de comptes NTLM.
Paramètres boolvar Une variable booléenne chargée de recevoir l'état d'authentification de l'utilisateur.
Exemple
Dans cet exemple, on vérifie si l'utilisateur est authentifié ou non et on envoie l'un des deux messages possibles, en fonction de l'état d'authentification de l'utilisateur. On remarquera que le message remis aux utilisateurs authentifiés utilise la propriété d'utilisateur de la page pour afficher le nom et le domaine de l'utilisateur considéré.
    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
Remarques
Outre celle associée à la classe HttpRequest , il existe une propriété IsAuthenticated dotée d'un rôle très similaire pour chacune des classes FormsIdentity, WindowsIdentity, et PassportIdentity . On observera que la propriété IsAuthenticated de la classe HttpRequest renvoie l'état d'authentification de l'utilisateur quelle que soit la méthode d'authentification utilisée.

IsSecureConnection |
boolvar = Request.IsSecureConnection |
Renvoie une valeur booléenne qui indique si la connexion considérée utilise des prises sécurisées (SSL) pour les communications ou pas.
Paramètres boolvar Une variable booléenne chargée de recevoir l'état SSL de la requête considérée.
Exemple
Cet exemple vous montre les différentes marches à suivre selon que la requête considérée a été effectuée ou non à l'aide d'une prise SSL:
    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
Remarques
On utilisera le plus souvent cette propriété pour déterminer si oui ou non il faut effectuer une requête nécessitant une connexion SSL afin de crypter les données sensibles (comme les numéros de carte de crédit) susceptibles d'êtres soumises au moyen de la page sollicitée. Par ailleurs, il est possible d'utiliser cette propriété sur une page utilisant ou non SSL pour déterminer comment effectuer un affichage sur la page en fonction de l'état SSL. Etant donné la baisse de performance associée au fait de crypter et de décrypter le contenu lors d'une communication SSL, il est généralement conseillé de diminuer le nombre et/ou la taille des graphiques utilisés au sein des pages en mode SSL. Avec cette propriété, le fait de ne pas activer le mode SSL pour la requête permet d'afficher un plus grand nombre de graphiques et/ou de le faire avec un plus haut pouvoir de résolution. Inversement, si SSL est activé, l'affichage portera sur un moins grand nombre de graphiques et/ou d'une résolution moindre.

Path |
stringvar = Request.Path |
Renvoie une chaîne contenant le chemin virtuel de la requête client considérée. Le chemin virtuel comporte le nom du répertoire racine d'application, des sous-repertoires du chemin de requête et le nom du fichier sollicité.
Paramètres stringvar Une variable de chaîne destinée à recevoir le chemin de fichier.
Exemple
Dans cet exemple, on affiche la propriété Path pour l'utilisateur:
    Sub Page_Load(  )
       Dim path As String
       path = Request.FilePath
       Message.Text = "The virtual path of the current request is: " & path
    End Sub
Remarques
Cette propriété est identique à la propriété FilePath décrite précédemment dans ce chapitre.

PathInfo |
stringvar = Request.PathInfo |
Renvoie une chaîne contenant toutes les informations supplémentaires en matière de chemin (y compris les informations de chemin ajoutées à une URL à la suite du nom de fichier de la ressource sollicitée) qui sont fournies dans le cadre de la requête considérée.
Paramètres stringvar Une variable de chaîne destinée à recevoir les informations supplémentaires en matière de chemin.
Exemple
Dans cet exemple, on inscrit à la fois les propriété Path et PathInfo dans le navigateur du client:
    Sub Page_Load(  )
       Message.Text = "Path = " & Request.Path & "<br/>"
       Message.Text &= "Additional Path Info = " & Request.PathInfo & "<br/>"
    End Sub
Remarques
PathInfo ne renvoie pas les informations telles que les valeurs de chaînes d'interrogation. PathInfo renvoie tous les caractères situés après un slash (/), à la suite du nom de ressource (fichier), y compris le slash lui-même.

PhysicalApplicationPath |
stringvar = Request.PhysicalApplicationPath |
Renvoie une chaîne contenant le chemin physique vers la racine de l'application considérée.
Paramètres stringvar Une variable de chaîne destinée à recevoir le chemin d'application.
Exemple
Dans cet exemple, on inscrit la propriété PhysicalApplicationPath dans le navigateur:
    Sub Page_Load(  )
       Dim physAppPath As String
       physAppPath = Request.PhysicalApplicationPath
       Message.Text = "Physical Application Path = " & physAppPath
    End Sub
Remarques
Cette propriété est utile lorsque vous souhaitez créer ou écrire dans un fichier au sein de votre application web. Plutôt que d'inscrire de façon explicite un chemin filesystem dans votre page, vous pouvez utiliser cette propriété conjointement à un nom de fichier pour créer ou éditer un fichier dans le même répertoire que la page contenant le code, quel que soit l'emplacement de la page.

PhysicalPath |
stringvar = Request.PhysicalPath |
Renvoie une chaîne contenant le chemin physique vers le fichier souhaité.
Paramètres stringvar Une variable de chaîne destinée à recevoir le chemin physique.
Exemple
Dans cet exemple, on inscrit la propriété PhysicalPath dans le navigateur:
    Sub Page_Load(  )
       Dim physicalPath As String
       physicalPath = Request.PhysicalPath
       Message.Text = "Physical Path = " & physicalPath
    End Sub
Remarques
Contrairement à la propriété PhysicalApplicationPath qui ne renvoie que le chemin vers la racine de l'application, la propriété PhysicalPath renvoie l'intégralité du chemin physique de la ressource souhaitée, y compris l'ensemble des dossiers considérés et le nom du fichier de ressource. Cette propriété peut s'avérer utile conjointement à la fonction Trace d'ASP.NET pour résoudre les situations dans lesquelles les fichiers que vous essayez de modifier ou de lire sont introuvables, ou lorsque les fichiers créés ne sont pas situés là où vous pensiez les trouver. Le fait d'ajouter des instructions Trace.Write à votre page pour inscrire les propriétés Path, PhysicalApplicationPath et PhysicalPath dans le journal de suivi (que vous pouvez activer en ajoutant l'attribut Trace="true" à la directive @ Page ) peut vous aider à résoudre ce genre de problèmes.

RawUrl |
stringvar = Request.RawUrl |
Renvoie une chaîne contenant l'URL brute de la requête considérée. L'URL brute est constituée de la portion de l'URL qui suit les informations de domaine. Ainsi, dans le cas de l'URL http://search.support.microsoft.com/kb/c.asp, l'URL brute est /kb/c.asp . L'URL brute comporte la chaîne d'interrogation, si elle existe.
Paramètres stringvar Une variable de chaîne destinée à recevoir l'URL brute.
Exemple
Dans cet exemple, on inscrit la propriété RawUrl dans le navigateur:
    Sub Page_Load(  )
       Dim stringvar As String
       stringvar = Request.RawUrl
       Message.Text = "The raw URL is: " & stringvar
    End Sub

RequestType |
stringvar = Request.RequestType |
La propriété RequestType renvoie une chaîne contenant le type de requête (soit GET ou POST) de la requête considérée.
Paramètres stringvar Une variable de chaîne destinée à recevoir le type de requête.
Exemple
Dans cet exemple, on inscrit la propriété RequestType dans le navigateur:
    Sub Page_Load(  )
       Dim stringvar As String
       stringvar = Request.RequestType
       Message.Text = "The request type is: " & stringvar
    End Sub
Remarques
Cette propriété est répertoriée dans la catégorie lecture/écriture; cependant, il n'est à vrai dire jamais utile de modifier sa valeur. Du point de vue de la lecture, cette propriété renvoie les mêmes informations que la propriété HttpMethod en lecture seule répertoriée précédemment dans ce chapitre. Si vous essayer de modifier sa valeur, la valeur de HttpMethod ne s'en trouve pas modifiée.

TotalBytes |
intvar = Request.TotalBytes |
Renvoie un nombre entier qui représente la taille du corps de requête HTTP. La propriété TotalBytes n'inclut pas la taille des en-têtes de requête HTTP, ni celle des valeurs de chaîne d'interrogation associées à une requête GET.
Paramètres intvar Une variable entière destinée à recevoir la taille, en octets, du corps de requête considéré.
Exemple
Dans cet exemple, on inscrit la propriété TotalBytes dans le navigateur:
    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
Le code suivant peut servir à envoyer du contenu à la page d'exemple:
    <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>
Remarques
Le comportement de cette propriété ressemble à celui de la propriété ContentLength décrit précédemment dans ce chapitre.

Url |
uriObj = Request.Url |
Renvoie une instance de la classe Uri contenant les propriétés qui décrivent l'URL sollicitée par l'utilisateur. La classe Uri comporte les propriétés Scheme (protocole), Port et Host.
Paramètres uriObj Une variable d'objet de type ValidatorCollection.
Exemple
Dans cet exemple, on utilise l'objet Uri renvoyé par la propriété Url pour inscrire des informations concernant l'URL de la requête considérée dans le navigateur:
    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
Remarques
Bien que la classe Uri renvoyée par cette propriété comporte à la fois des méthodes et des propriétés, vous risquez d'utiliser ces méthodes (en particulier les méthodes CheckHostName et CheckSchemeName) plutôt lors de la création initiale de vos propres ressources Uri que lors de la réception de l'instance Uri de la part de la propriété Url. Remarque concernant les URI: Les URI (Uniform Resource Identifier, par opposition à URL ou Uniform Resource Locator) constituent des versions plus générales d'URL et d'URN. A l'heure actuelle, la plupart des URI et des URL sont identiques, même si cela peut changer avec l'emploi de plus en plus fréquent des URN. En ce qui concerne la propriété Url, ces termes ont le même sens.

UrlReferrer |
uriObj = Request.UrlReferrer |
Renvoie une instance de la classe Uri contenant des propriétés qui décrivent l'URL de la ressource à partir de laquelle l'utilisateur a navigué vers la ressource considérée. Si l'utilisateur n'a pas navigué vers la ressource considérée (c'est à dire, s'il a accédé directement à la ressource en question), la propriété UrlReferrer renvoie la valeur Nothing .
Paramètres uriObj Une variable d'objet de type Uri.
Exemple
Dans cet exemple, on utilise l'objet Uri renvoyé par la propriété UrlReferrer pour inscrire des informations concernant l'URL de la ressource de référence dans le navigateur:
    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
Le code suivant permet d'accéder à la page d'exemple:
    <html>
       <head>
          <title>Link to UrlReferrer</title>
       </head>
    <body>
       <a href="UrlReferrer.aspx">Go to UrlReferrer.aspx</a>
    </body>
    </html>
Remarques
Cet échantillon de code permet de garantir que la propriété UrlReferrer renvoie une instance valide de la classe Uri . La propriété UrlReferrer renvoie la valeur Nothing si l'accès à la page a lieu directement, et non pas à partir d'un lien sur une autre page.

UserAgent |
stringvar = Request.UserAgent |
Renvoie une chaîne contenant l'en-tête User-Agent. La chaîne User-Agent permet d'identifier le navigateur (ou un autre logiciel client compatible HTTP, comme celui utilisé sur les téléphones portables, etc.) utilisé par le client pour effectuer la requête. En fonction du navigateur et de la plate-forme, cette chaîne peut également identifier le système d'exploitation utilisé par le client, ainsi que la version de la structure .NET installée (IE uniquement).
Paramètres stringvar Une variable de chaîne destinée à recevoir la chaîne User-Agent.
Exemple
Dans cet exemple, on inscrit la propriété UserAgent dans le navigateur:
    Sub Page_Load(  )
       Dim stringvar As String
       stringvar = Request.UserAgent
       Message.Text = "User Agent: " & stringvar
    End Sub
Remarques
Pour connaître les caractéristiques du navigateur client, il est en général plus facile d'utiliser les propriétés de l'objet HttpBrowserCapabilities renvoyé par la propriété Request.Browser. Cependant, il peut arriver que l'User-Agent d'un client donné renvoie des informations que la classe HttpBrowserCapabilities omet de vérifier. Dans ce cas, vous pouvez ajouter les informations souhaitées au gestionnaire de section de configuration <browserCaps> dans machine.config (reportez-vous aux chapitres 8 et 20 pour de plus amples informations sur la configuration ASP.NET) puis créez votre propre version de la classe HttpBrowserCapabilities en utilisant l'héritage de la classe intégrée et en y ajoutant la ou les propriétés particulières de l'attribut User-Agent qui vous intéressent. Ou bien, si vous ne souhaitez pas faire cet effort, contentez-vous de rechercher l'attribut désiré dans la chaîne User-Agent à l'aide de la propriété UserAgent.

UserHostAddress |
stringvar = Request.UserHostAddress |
Renvoie l'adresse IP du client qui effectue la requête.
Paramètres stringvar Une variable de chaîne destinée à recevoir l'adresse IP du client.
Exemple
Dans cet exemple, on inscrit les propriétés UserHostAddress, UserHostName et UserLanguages dans le navigateur:
    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 |
Renvoie une chaîne qui contient le nom d'hôte DNS du client qui effectue la requête.
Paramètres stringvar Une variable de chaîne destinée à recevoir le nom d'hôte.
Exemple
Reportez-vous à l'exemple concernant la propriété UserHostAddress.
Remarques
Si aucun serveur DNS n'est capable de déterminer l'adresse IP du client sous forme de nom DNS, la propriété UserHostName renvoie l'adresse IP du client (exactement comme la propriété UserHostAddress).

UserLanguages |
stringArray = Request.UserLanguages |
Renvoie un tableau de chaînes ordonné contenant la liste des langues prises en charge par le client.
Paramètres stringArray Une variable de tableau de chaîne destinée à recevoir la liste des langues prises en charge par le client.
Exemple
Reportez-vous à l'exemple concernant la propriété UserHostAddress.
Remarques
Pour tester cette propriété, vous pouvez configurer la prise en charge de langues supplémentaires dans votre navigateur. Dans Internet Explorer 6, sélectionnez les options Internet... à partir du menu Outils. Dans l'onglet Général de la boîte de dialogue Options Internet, cliquez sur le bouton Langues... Utilisez la boîte de dialogue Préférence de langue pour ajouter, supprimer, ou déplacer des langues à l'intérieur de la liste des langues préférées. Dans Netscape Navigator 6, sélectionnez Préférences... à partir du menu Modifier, puis sélectionnez le noeud Langues dans l'arborescence de gauche. Utilisez les options de la partie droite pour ajouter, supprimer, ou déplacer des langues dans la liste.
Ceci fait, si vous accédez à une page contenant le code indiqué dans l'exemple UserHostAddress, l'ensemble des langues que vous avez sélectionnées figurera dans l'ordre choisi.

Cookies |
HttpCookieCollection = Request.Cookies |
La collection Cookies renvoie une instance de la classe HttpCookieCollection contenant l'ensemble des cookies envoyés dans le cadre de la requête considérée. La classe HttpCookieCollection contient une instance de la classe HttpCookie pour chaque cookie transmis dans le cadre de la requête client. Les propriétés de ces instances HttpCookie peuvent être utilisées pour accéder aux informations en matière de cookie(s). Comme dans l'ASP classique, la collection de cookies est toujours mise en oeuvre sous forme de collection (en fait, la classe HttpCookieCollection hérite de la classe NameObjectCollectionBase de .NET). Toutefois, plutôt qu'une collection de clés et de valeurs de chaînes, l'implémentation ASP.NET est une collection de clés et d'objets de chaînes (instances de la classe HttpCookie ). Les cookies individuels sont récupérés sous forme de variables de type HttpCookie, ce qui permet d'avoir accès aux valeurs de cookies au travers des propriétés de classe. Les cookies de type dictionnaire (ceux qui comportent plusieurs valeurs) sont accessibles au moyen de la propriété Values de la classe HttpCookie , qui renvoie une classe NameValueCollection contenant les sous-clés et les valeurs de cookies. Vous pouvez aussi récupérer des valeurs individuelles au moyen des clés correspondantes à l'aide de la syntaxe suivante: HttpCookie.Values(" keyname ")
Paramètres HttpCookieCollection Une variable d'objet de type HttpCookieCollection.
Exemple
L'exemple récupère la collection de cookies à partir de la propriété Cookie et affiche en écriture, outre l'ensemble des sous-clés des cookies de dictionnaire, la clé et la valeur de chacun d'entre eux.
    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
Remarques
La mise en oeuvre ASP de la collection de cookies et la classe HttpCookieCollection renvoyée par la propriété Cookies comportent un jeu de propriétés communes; ces propriétés sont décrites dans la section 16.3. Même s'il est encore possible dans ASP.NET de récupérer un cookie individuel par sa clé de texte ainsi que par son index numérique, les différences en termes d'opération rendent la migration en bloc du code de traitement de cookies d'ASP vers ASP.NET impossible sans des modifications importantes. Par exemple, le code suivant générera des exceptions:
    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
Mis à part le fait que ce code ne déclare pas de façon explicite ses variables ou leurs types (deux données qui sont nécessaires par défaut dans ASP.NET), le code précédent échoue parce que la propriété Request.Cookies ( key ) renvoie une instance de HttpCookie, plutôt qu'une chaîne, et que l'instance HttpCookie ne peut pas être convertie de façon implicite en une chaîne de l'instruction Response.Write, qui s'attend à une chaîne. Par ailleurs, le fait d'invoquer Request.Cookies ( key ) ne permet pas d'obtenir les sous-clés d'un cookie de dictionnaire. Heureusement, les modifications nécessaires pour faire fonctionner le code précédent sont relativement simples et indiquées ci-dessous:
    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
Pour résoudre le premier problème, nous utilisons la méthode HttpCookie's Value afin d'obtenir la valeur du cookie sous forme de chaîne. La solution au deuxième problème consiste à invoquer la propriété Values de l'instance HttpCookie, ce qui nous permet de récupérer les sous-clés d'un cookie de dictionnaire. Un autre aspect insolite en ce qui concerne le passage de la manipulation essentiellement à base de texte des clés et des valeurs de cookie dans ASP à une manipulation à base de classes dans ASP.NET, c'est que la propriété Expires de la classe HttpCookie est disponible aussi bien pour la lecture que pour l'écriture d'un cookie. Dans ASP, néanmoins, le fait d'essayer de lire la propriété Expires d'un cookie entraînerait une erreur. Malheureusement, au moment d'imprimer ces lignes, la propriété Expires de HttpCookie ne renvoie en fait pas la date d'expiration du cookie. A la place, elle renvoie la valeur 12:00, ce qui indique que, contrairement aux apparences, cette propriété n'est pas conçue pour être lue. Enfin, contrairement à l'ASP classique, les collections d'ASP.NET démarrent à zéro, si bien que, la première valeur d'une collection ou d'un tableau est égale à 0 et non à 1. Il est important de s'en rappeler, particulièrement lorsque l'on souhaite récupérer des valeurs à l'aide de l'index correspondant.

Files |
HttpFileCollection = Request.Files |
La collection Files, qui est nouvelle dans ASP.NET, renvoie une collection de type HttpFileCollection qui contient l'ensemble des fichiers téléchargés à l'aide de la requête d'utilisateur considérée. Cette collection est spécialement utile en association avec le contrôle de serveur HtmlInputFile, qui fournit le plombage de base nécessaire au téléchargement des fichiers par une requête HTTP POST. Lorsqu'un utilisateur soumet un ou plusieurs fichiers (un par contrôle HtmlInputFile sur la page de soumission), vous pouvez récupérer les fichiers à l'aide de la collection Files.
Paramètres HttpFileCollection Une variable d'objet de type HttpFileCollection.
Exemple
L'exemple utilise deux contrôles de serveur HtmlInputFile et un bloc <script> côté serveur pour télécharger des fichiers et les traiter. Dans cet exemple, on remarque à la fois la section <form> de la page et ses contrôles, ainsi que le bloc <script> contenant la méthode UploadBtn_OnClick invoquée par l'événement onServerClick du contrôle HtmlInputButton:
    <!--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"/>
Remarques
Dans la version classique d'ASP, le téléchargement de fichier était un processus pénible qui comportait généralement la recherche et l'acquisition d'un contrôle de téléchargement tiers à utiliser sur la page ASP de réception pour analyser et enregistrer les fichiers téléchargés. Grâce à la collection Files, il n'est plus nécessaire de localiser et d'apprendre à utiliser les contrôles tiers pour télécharger des fichiers. C'est une mauvaise nouvelle pour les développeurs de contrôles (même s'il est probable qu'ils se rattraperont sur l'écriture de nouveaux contrôles de serveurs) mais une excellente chose pour les développeurs ASP.NET. Deux points importants concernant la collection Files à se rappeler pour télécharger avec succès des fichiers: Lorsque vous utilisez un formulaire HTML côté client (sans attribut runat="server"), donnez à l'attribut set the method du formulaire la valeurPOST. Donnez à l'attribut enctype du formulaire la valeurmultipart/form-data . Le téléchargement ne réussira que si vous effectuez ces deux opérations. On notera le fait que cet échantillon de code vérifie que la requête entrante est bien de type multipart/form-data avant d'essayer de récupérer les fichiers. Il n'est pas nécessaire d'utiliser le contrôle HtmlInputFile pour télécharger les fichiers qui peuvent être récupérés à l'aide de la collection Files. Tant que la page de soumission utilise la méthode POST et l'attribut multipart/form-data enctype , vous pouvez utiliser les balises d'entrée de fichiers HTML standard:
    <input type="file" id="myFile" name="myFile">
Remarquez l'utilisation qui est faite de l'attribut name , sans lequel la collection de fichiers ne contiendra pas le fichier téléchargé du contrôle.

Form |
NameValueCollection = Request.Form |
La collection Form renvoie une instance de la classe NameValueCollection contenant tous les champs de formulaires associés à une requête HTTP POST. Cette collection ne contiendra des données que si le type de contenu de la requête HTTP est soit application/x-www-form-urlencoded soit multipart/form-data . La collection Form constitue l'une des deux façons de récupérer des données, en fonction de la méthode HTTP utilisée pour soumettre les données. La collection Form récupère les données soumises par un formulaire HTML dont l'attribut method a pour valeur POST , alors que la collection QueryString (traitée plus loin dans cette section) récupère les valeurs soumises par les formulaires HTML dont l'attribut method a pour valeur GET .
Paramètres NameValueCollection Une variable d'objet de type NameValueCollection.
Exemple
Cet exemple montre la façon dont ASP.NET permet d'utiliser une page individuelle pour soumettre des valeurs à l'aide de HTTP POST et de récupérer et afficher les valeurs correspondantes à l'utilisateur. On y fait usage de la propriété IsPostBack de la classe Page pour déterminer si la requête constitue un résultat du formulaire soumis. Si la requête n'est pas un postback, les champs de formulaires sont affichés pour permettre à l'utilisateur d'entrer des valeurs. Si la requête est un postback, la page récupère la collection Form et affiche le nom et la valeur de chaque champ dans le navigateur.
    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"/>
Remarques
La collection Form comporte les mêmes propriétés et méthodes que celles décrites dans la section 16.3 et ajoute les méthodes suivantes: Get( Index | Key ) Renvoie le contenu de l'élément indiqué dans la NameValueCollection sous forme d'une chaîne délimitée par des virgules. GetValues( Index | Key ) Renvoie le contenu de l'élément indiqué dans la NameValueCollection sous forme de tableau de chaînes.

Headers |
NameValueCollection = Request.Headers |
La collection Collection.Headers renvoie une instance de la classe NameValueCollection contenant l'ensemble des en-têtes HTTP envoyés avec la requête considérée. Cette collection fournit les mêmes informations que celles renvoyées en invoquant la collection Request.ServerVariables avec la clé ALL_HTTP .
Paramètres NameValueCollection Une variable d'objet de type NameValueCollection.
Exemple
Dans cet exemple, on inscrit les en-têtes HTTP associés à la requête dans le navigateur, tout d'abord à l'aide de la méthode ServerVariables ("ALL_HTTP"), puis à l'aide de la collection 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
Remarques
La collection Headers renvoie uniquement les en-têtes HTTP envoyés dans le cadre de la requête considérée, contrairement à la collection ServerVariables (décrite plus loin dans cette section), qui contient des clés pour chaque en-tête HTTP, qu'une valeur ait été transmise ou non. Si vos besoins se limitent à inscrire les en-têtes HTTP dans un fichier ou à les afficher dans le navigateur, il peut s'avérer plus simple d'utiliser la collection ServerVariables. Si, par contre, vous devez accéder à un en-tête donné à l'aide du nom correspondant ou examiner l'ensemble de la collection, utilisez plutôt la collection Headers.

Params |
NameValueCollection = Request.Params |
La collection Collection.Params renvoie une instance de la classe NameValueCollection contenant les paires clé/valeur des collections QueryString, Form, ServerVariables et Cookies. Vous pouvez utiliser la collection Params pour transférer toutes ces collections dans un fichier ou dans le navigateur et pour réparer une application ou pour répertorier les valeurs de formulaires que reçoit votre application, aussi bien via GET (collection QueryString) que via POST (collection Form).
Paramètres NameValueCollection Une variable d'objet de type NameValueCollection.
Exemple
Dans cet exemple, on inscrit dans le navigateur les clés et les valeurs contenues dans la collection Params:
    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
Le code suivant peut servir à envoyer du contenu vers la page d'exemple:
    <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>
Remarques
Les collections sont répertoriées dans l'ordre suivant: QueryString Form Cookies ServerVariables
Même s'il est possible de peupler à la fois les collections Form et QueryString (par exemple, si une paire nom/valeur de chaîne d'interrogation est ajoutée à l'URL de l'attribut action d'un formulaire à l'aide de la méthode POST), vous verrez normalement l'un ou l'autre, mais pas les deux.

QueryString |
NameValueCollection = Request.QueryString |
La collection QueryString renvoie une instance de la classe NameValueCollection contenant l'ensemble des clés et des valeurs associées à la chaîne d'interrogation (en général par soumission d'un formulaire HTML qui utilise la méthode GET au lieu de la méthode POST).
Paramètres NameValueCollection Une variable d'objet de type NameValueCollection.
Exemple
Dans cet exemple, on inscrit le contenu de la collection QueryString dans le navigateur:
    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
Le code suivant peut être utilisé pour envoyer du contenu vers la page d'exemple (on remarquera que l'attribut de méthode de formulaire a reçu la valeur GET, ce qui permet d'envoyer la valeur dans le cadre de la chaîne d'interrogation):
    <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>
Remarques
Un des avantages de la collection QueryString par rapport à la collection Form, c'est qu'il n'est pas toujours nécessaire de demander à l'utilisateur de soumettre un formulaire pour s'en servir. Etant donné que les valeurs de chaîne d'interrogation sont associées à l'URL, il est relativement simple d'ajouter de façon statique les chaînes d'interrogation aux liens figurant dans les pages ou de créer de façon dynamique des balises d'ancrage avec les valeurs de chaînes associées. En fait, de nombreux stocks en ligne utilisent cette méthode pour gérer leurs pages de catalogue (par transfert d'un ID de produit associé à un lien vers la page conçue pour afficher le produit). Cette page peut alors récupérer l'ID à l'aide de la collection QueryString. Etant donné que les valeurs de chaînes d'interrogation sont transmises sous forme de texte simple associé à l'URL, elles sont plus sujettes au piratage que les valeurs transmises dans le cadre d'une opération POST. Si vous devez transmettre des données importantes ou des données qui, en cas de piratage, peuvent entraîner des problèmes pour votre application, il vous faudra envisager de crypter les données avant de les ajouter à la chaîne d'interrogation ou d'utiliser une autre méthode pour les transmettre. Certains caractères utilisés pour le traitement des chaînes d'interrogation, y compris &, ?, %, et + doivent être codés pour éviter toute confusion entre leur utilisation dans votre paire clé/valeur et leur rôle en tant que caractères spéciaux dans une chaîne d'interrogation. Le tableau suivant établit une liste de codages pour chacun de ces caractères spéciaux:
Caractère | Codage
--- | ---
& | %26
? | %3f
% | %25
+ | %2b
| %20
Au lieu de mémoriser ces valeurs, vous pouvez vous simplifier l'existence grâce à la méthode UrlEncode fournie par la classe HttpServerUtility (décrite dans le chapitre 18), qui remplace de façon automatique chaque caractère spécial par le codage correspondant dans une chaîne qui lui parvient.

ServerVariables |
NameValueCollection = Request.ServerVariables |
Paramètres NameValueCollection Une variable d'objet de type NameValueCollection.
Exemple
Dans cet exemple, comme dans les exemples précédents liés à une collection, on inscrit le contenu de la collection ServerVariables dans le navigateur:
    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
Remarques
Non seulement il est possible de récupérer l'ensemble des valeurs en parcourant les clés, mais vous pouvez accéder aux valeurs individuelles si vous connaissez la clé correspondante. La liste suivante indique les clés disponibles pour la collection ServerVariable: ALL_HTTP Renvoie une chaîne contenant l'ensemble des en-têtes HTTP et où chaque nom d'en-tête figure sous la forme HTTP_ headername , dans lequel headername est le nom de l'en-tête HTTP entièrement écrit en majuscules. ALL_RAW Fournit les mêmes informations que ALL_HTTP, mais les noms d'en-têtes ne sont pas entièrement en majuscules et ne sont pas précédés de HTTP_ . APPL_MD_PATH Renvoie le chemin de l'application dans la méta base IIS. APPL_PHYSICAL_PATH Renvoie le chemin physique qui correspond à APPL_MD_PATH . AUTH_TYPE Renvoie la méthode d'authentification utilisée pour valider l'accès à un contenu protégé. AUTH_USER Renvoie le nom d'utilisateur (username) de l'utilisateur authentifié sous forme brute. AUTH_PASSWORD Renvoie le mot de passe entré dans la boîte de dialogue d'authentification du navigateur, en supposant que l'authentification de base a été utilisée. LOGON_USER Renvoie le nom du compte Windows auquel l'utilisateur considéré est connecté. REMOTE_USER Renvoie la chaîne username envoyée par le navigateur avant tout filtre d'authentification. CERT_COOKIE Renvoie un identifiant de chaîne unique du certificat client. CERT_FLAGS Renvoie les balises de bit qui indiquent si un certificat est présent (bit0) et si l'autorité de certificat du certificat de client figure dans la liste des autorités de certificat reconnues sur le serveur (bit1). CERT_ISSUER Renvoie l'émetteur du certificat de client. CERT_KEYSIZE Renvoie le nombre de bits de la clé SSL (40 ou 128, par exemple). CERT_SECRETKEYSIZE Renvoie le nombre de bits figurant dans la clé privée du serveur. CERT_SERIALNUMBER Renvoie le numéro de série du certificat de client. CERT_SERVER_ISSUER Renvoie l'émetteur du certificat de serveur. CERT_SERVER_SUBJECT Renvoie le champ de sujet du certificat de serveur. CERT_SUBJECT Renvoie le champ de sujet du certificat de client. CONTENT_LENGTH Renvoie la longueur du contenu figurant dans le corps de la requête HTTP. CONTENT_TYPE Renvoie le type MIME du contenu de la requête HTTP. GATEWAY_INTERFACE Renvoie le numéro de révision de la spécification CGI utilisée par le serveur. HTTPS Renvoie soit on , soit off , selon que la requête provienne d'une connexion avec prise sécurisée (HTTPS) ou pas. HTTPS_KEYSIZE Renvoie la taille, en bits, de la clé SSL. HTTPS_SECRETKEYSIZE Renvoie le nombre de bits contenus dans la clé privée du serveur. HTTPS_SERVER_ISSUER Renvoie l'émetteur du certificat de serveur. HTTPS_SERVER_SUBJECT Renvoie le champ de sujet du certificat de serveur. INSTANCE_ID Renvoie l'ID de l'instance IIS associée à la requête. Sauf s'il y a plus d'une instance d'IIS activée, cette valeur est toujours 1. INSTANCE_META_PATH Renvoie le chemin de méta base à l'instance d'IIS qui répond à la requête considérée. LOCAL_ADDR Renvoie l'adresse du serveur sur lequel la requête a été reçue. Utile pour les serveurs disposant de plusieurs NIC et adresses IP quand on veut déterminer l'adresse qui a reçu la requête. PATH_INFO Renvoie toutes les informations de chemin supplémentaires associées à la requête. Reportez-vous à la propriété the.PathInfo décrite précédemment dans ce chapitre pour de plus amples informations. PATH_TRANSLATED Renvoie le chemin physique qui correspond au chemin virtuel de la requête. QUERY_STRING Renvoie la chaîne d'interrogation brute (si elle existe) associée à la requête. REMOTE_ADDR Renvoie l'adresse IP de la machine qui effectue la requête. REMOTE_HOST Renvoie le nom DNS de la machine qui effectue la requête, s'il existe. Sinon, renvoie l'adresse IP. REQUEST_METHOD Renvoie la méthode de requête HTTP (GET, POST, etc.) utilisée dans la requête. SCRIPT_NAME Renvoie un chemin virtuel vers la page en cours d'exécution. SERVER_NAME Renvoie le nom de serveur, le nom DNS, ou l'adresse IP du serveur. SERVER_PORT Renvoie le numéro de port sur lequel la requête a été reçue. SERVER_PORT_SECURE Renvoie une chaîne contenant soit 0, soit 1, selon que la requête a été reçue sur un port sécurisé (1) ou pas (0). SERVER_PROTOCOL Renvoie le nom et la version du protocole utilisé pour traiter la requête client. Pour IE 5.5 et IIS 5, ce nom et cette version seront "HTTP/1.1". SERVER_SOFTWARE Renvoie le nom et la version du logiciel de serveur web. URL Renvoie l'URL de base de la requête (c'est à dire, tout ce qui suit le nom de domaine). HTTP_CONNECTION Renvoie le type de connexion établi. HTTP_ACCEPT Renvoie la valeur de l'en-tête HTTP Accept. HTTP_ACCEPT_ENCODING Renvoie la valeur de l'en-tête HTTP Accept-Encoding. HTTP_ACCEPT_LANGUAGE Renvoie la valeur de l'en-tête HTTP Accept-Language. HTTP_HOST Renvoie la valeur de l'en-tête HTTP Host. HTTP_USER_AGENT Renvoie la valeur de l'en-tête HTTP User-Agent.

BinaryRead |
byteArray = Request.BinaryRead(byteCount) |
Renvoie a tableau d'octets contenant le nombre d'octets indiqué par byteCount.
Paramètres byteArray Une variable de tableau de type Byte destinée à recevoir le nombre d'octets indiqué à partir de la méthode. byteCount Un nombre entier qui indique le nombre d'octets à renvoyer.
Remarques
Cette méthode fournit une compatibilité à rebours avec les applications ASP classiques. Pour un nouveau développement, le fait d'utiliser d'autres moyens (comme la collection Files, etc.) est préférable pour obtenir les résultats pour lesquels cette méthode a été utilisée.

MapPath |
    stringvar = Request.MapPath(virtualPath)
    stringvar = Request.MapPath(virtualPath, _
                  baseVirtualDirectory, allowCrossMapping)
La La méthode MapPath, qui figurait dans l'objet Server dans l'ASP classique, vous permet de récupérer sur le serveur le chemin physique correspondant à un chemin virtuel donné. Dans ASP.NET, cette méthode est surchargée, ce qui signifie qu'elle peut être invoquée à l'aide de deux jeux d'arguments différents, comme l'illustre le code précédent. Le premier style, qui est le même que dans l'ASP classique, transfert simplement dans une chaîne contenant le chemin virtuel à associer. Le second ajoute l'argument baseVirtualDirectory qui définit une base à partir de laquelle vous pouvez résoudre les chemins relatifs, et l'argument allowCrossMapping qui vous permet d'associer des chemins virtuels qui appartiennent à d'autres applications.
Paramètres stringvar Une variable de chaîne destinée à recevoir le chemin physique associé. virtualPath Un argument de chaîne contenant le chemin virtuel à associer. baseVirtualDirectory Un argument de chaîne contenant un chemin de base à utiliser pour déterminer des chemins relatifs. allowCrossMapping Un argument booléen qui indique si les chemins peuvent être associés dans l'ensemble des applications.
Exemple
L'exemple associe le répertoire chemin/QuickStart des échantillons SDK de la structure .NET et inscrit le résultat dans le navigateur:
    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
Remarques
Dans l'exemple précédent, si nous avions donné à la variable BoolCross la valeur False et invoqué l'échantillon de code de l'extérieur de l'application QuickStart, il en résulterait une HttpException, étant donné que l'argument doit avoir la valeur True pour associer des chemins dans l'ensemble des applications.

SaveAs |
Request.SaveAs(filename, includeHeaders) |
Saves la requête HTTP considérée sur le disque, à l'aide de l'argument filename comme le chemin et le nom de fichier devant servir à enregistrer la requête.
Paramètres filename Un argument de chaîne contenant le chemin et le nom de fichier devant servir à enregistrer la requête. includeHeaders Un argument booléen qui indique s'il faut enregistrer les informations d'en-tête HTTP au sein de la requête ou pas. Remarquez que, sauf dans le cas d'une requête POST (ou d'un autre type de requête comportant un corps de requête), aucune information n'est enregistrée si l'argument en question a la valeur False .
Exemple
Dans cet exemple, on inscrit les en-têtes de requête HTTP dans le navigateur (pour effectuer des comparaisons), puis on enregistre la requête considérée à la fois avec et sans informations d'en-tête:
    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
Remarques
Cette méthode peut s'avérer très utile pour le débogage car elle permet de vérifier l'ensemble des informations envoyées dans une requête donnée (ce qui est particulièrement utile dans le cas des requêtes POST).