Objet Session |
L'une des principales difficultés rencontrées lors de la création d'une application Web complète consiste à conserver une trace d'informations spécifiques aux utilisateurs lorsqu'ils naviguent sur votre site, sans pour autant les forcer à s'identifier lors de chaque demande envoyée au serveur. Parmi les données que vous devez stocker, citons l'identification de l'utilisateur, ses éventuelles autorisations de sécurité et, dans des applications plus perfectionnées, les préférences utilisateur qui vous permettent de personnaliser l'apparence de votre site Web en fonction des options sélectionnées par l'utilisateur. Le principal problème de la gestion d'informations spécifiques aux utilisateurs réside dans les limitations du protocole HTTP 1.0 standard actuel. Bien que le protocole HTTP 1.0 dispose d'un mécanisme de connexions persistantes qui permettent de conserver l'identification des utilisateurs et des données spécifiques à ceux-ci, son utilité est restreinte. Sans entrer dans les détails techniques, le protocole HTTP 1.0 permet aux navigateurs clients d'envoyer des messages Keep-Alive aux serveurs proxy. Dans les grandes lignes, ces messages indiquent au serveur proxy qu'il doit maintenir une connexion avec le client demandeur. Toutefois, il arrive souvent que ces demandes de connexion ne soient pas reconnues par le serveur proxy. Ce problème du serveur proxy entraîne la coupure de la connexion entre le serveur proxy et le serveur Web demandé. Bref, la conservation de connexions à des serveurs Web est susceptible de rencontrer des erreurs et est dès lors peu fiable sous HTTP 1.0, qui est toujours de loin le protocole le plus fréquemment utilisé par les navigateurs clients. La solution de Microsoft Internet Information Server (et d'autres serveurs Web) à ce problème consiste à employer le mécanisme HTTP d'état client persistant (plus connu sous le nom de cookies) pour identifier l'utilisateur. IIS gère ce mécanisme via l'emploi de l'objet intégré Session. L'objet Session représente la session de l'utilisateur actuel sur le serveur Web. Il est spécifique à chaque utilisateur ; ses propriétés et méthodes permettent de manipuler les informations sur le serveur qui sont spécifiques à l'utilisateur pendant toute la durée de sa connexion. Cette durée est définie comme le moment de la première demande, par le client, d'une page dans votre application Web, suivi de 20 minutes (il s'agit d'une valeur par défaut qui peut être modifiée ; reportez-vous à la section "Timeout", plus loin dans ce chapitre) après la dernière demande de l'utilisateur au serveur Web. Une session utilisateur peut être démarrée de trois manières : Un utilisateur qui n'est pas encore connecté au serveur demande une page ASP qui se trouve dans une application contenant un fichier GLOBAL.ASA avec du code pour l'événement Session_OnStart. Un utilisateur demande une page ASP dont le script stocke des information dans n'importe quelle variable de niveau session. Un utilisateur demande une page ASP dans une application dont le fichier GLOBAL.ASA lance un objet à l'aide de la balise <OBJECT>, le paramètre SCOPE étant fixé à Session. Notez qu'une session d'utilisateur est spécifique à une application précise sur votre site Web. En fait, il est possible de maintenir des informations de session pour plusieurs applications à la fois si l'une d'elles se trouve dans un répertoire virtuel qui est placé sous le répertoire virtuel qui désigne une autre application. Le serveur Web identifie chaque utilisateur à l'aide d'une valeur SessionID unique. Cette variable SessionID est attribuée à chaque utilisateur au début de sa session sur le serveur Web et est stockée dans la mémoire du serveur Web. La variable SessionID est stockée sur le client par l'enregistrement, sur l'ordinateur de l'utilisateur, d'un cookie contenant SessionID. Ce cookie est envoyé au serveur à chaque fois que l'utilisateur effectue une demande. Pour identifier l'utilisateur, le serveur récupère le cookie et le fait correspondre à un SessionID stocké en mémoire. Outre la variable SessionID, vous pouvez stocker d'autres informations spécifiques à chaque utilisateur. Vous pouvez initialiser (ou modifier) n'importe quelle variable de niveau session, n'importe où dans n'importe quel script ASP. Pour garantir qu'une variable de niveau session soit bien initialisée selon une valeur précise, vous pouvez créer du code dans la procédure d'événement Session_OnStart du fichier GLOBAL.ASA. Cette procédure d'événement est lancée au début de la session de l'utilisateur. Le fichier GLOBAL.ASA (voir chapitre 11) est un fichier spécial que vous pouvez coder de manière spécifique pour chaque application ASP. Le code de ce fichier est traité lorsque la session de l'utilisateur débute. Comme nous l'avons vu plus tôt, l'objet Session est très important pour le stockage d'informations au sujet des différents utilisateurs. Vous pouvez également utiliser l'objet Session pour traiter certains problèmes spécifiques aux clients qui ne sont pas en langue anglaise et qui demandent des informations à votre site Web.

Commentaires/Dépannage |
L'un des aspects les plus importants à garder à l'esprit lorsque vous utilisez l'objet Session est sa portée. Toute information stockée au niveau d'une session reste valide pendant toute la durée de la session de l'utilisateur dans une application précise. Par exemple, supposons que votre code traite une variable de niveau session qui a été définie dans le contexte de l'application Search de votre site Web. Le répertoire virtuel de cette application, /search, correspond au répertoire physique suivant :
    D:\www\apps\search
Le script actuel, SearchStart.ASP, se trouve dans ce répertoire. Supposons que vous ayez initialisé une variable de niveau session, strSearchPref, dans ce script. L'utilisateur passe à un autre script d'application, ContribMain.ASP, qui se trouve dans une autre application dont le répertoire virtuel, /contrib, correspond au répertoire physique suivant :
    D:\www\apps\contrib
Si cet utilisateur ne revient pas à un script dans le répertoire virtuel qui contient l'application Search dans les 20 minutes (ou toute autre durée fixée pour la session), la variable de niveau session strSearchPref est réinitialisée. Il s'agit là d'une importante source d'erreurs dans les applications Web complexes. Les variables de niveau session d'une session d'utilisateur expirent lorsque la session se termine, même si le temps passé en dehors de l'application l'a été dans des applications du même site Web. Une manière d'éviter ce problème consiste à imbriquer les applications. Par exemple, vous pouvez placer le répertoire virtuel /contrib sous le répertoire search, comme dans le chemin suivant :
    D:\www\apps\search\contrib
Avec cette configuration, toutes les demandes envoyées au chemin virtuel de l'application Contribution, /contrib, demeurent dans le contexte de l'application Search. Il est possible de modifier le délai par défaut après lequel une session d'utilisateur prend fin. Vous pouvez le faire pour deux raisons. Il se peut que vous souhaitiez sauvegarder les informations sur la session de l'utilisateur pendant plus de 20 minutes. Par exemple, il se peut que vous sachiez à l'avance qu'un utilisateur quittera votre site pendant plus de 20 minutes puis y reviendra. L'autre cas de figure suppose que vous vouliez mettre fin aux informations sur la session de l'utilisateur plus tôt. Par exemple, il se peut que vous sachiez que les utilisateurs ne restent pas connectés à votre site Web pendant très longtemps, et vous voulez réduire la consommation de mémoire du serveur qui va de pair avec l'enregistrement des informations de session. Pour savoir comment cette information peut être modifiée par rapport à la valeur par défaut, reportez-vous à la section "Timeout", plus loin dans ce chapitre. Ce stockage d'informations de niveau session repose sur l'emploi de cookies envoyés au client puis renvoyés au serveur. Que se passe-t-il si l'utilisateur a désactivé les cookies ou emploie un ancien navigateur qui ne les prend pas en charge ? Si vous employez Windows NT ou Basic Authentication, vous pouvez identifier l'utilisateur à partir de l'élément LOGON_USER de la collection ServerVariables de l'objet Request. Ces informations vous permettront de récupérer des données spécifiques à l'utilisateur dans une base de données ou un fichier texte sur le serveur. Si vous n'employez pas Windows NT ou Basic Authentication, il est peu probable que vous puissiez identifier l'utilisateur. Auparavant, il était possible d'utiliser l'adresse IP d'un utilisateur pour l'identifier, mais avec la génération dynamique d'adresses IP via DHCP et les pare-feu, cette information est désormais inutile pour l'identification des utilisateurs.

CodePage |
Session.CodePage (= intCodePageValue)
Définit ou récupère la page de code qui sera utilisée par le serveur Web pour afficher du contenu dynamique dans le script actuel. Une page de code est un jeu de caractères qui contient tous les caractères alphanumériques et la ponctuation employés par une langue précise.
Paramètres
intCodePageValue Entier non signé correspondant à un jeu de caractères précis installé sur le serveur. La définition de la propriété CodePage permet au système d'afficher le contenu à l'aide de ce jeu de caractères. Le tableau suivant présente quelques-unes des valeurs valides pour ce paramètre :
Valeur de CodePage | Langue
932 | Japonais (Kanji)
950 | Chinois
1252 | Anglais (États-Unis) et la plupart des langues européennes
Exemple
    <%

    ' In the following code, assume that the original code
    ' page setting is 1252 for American English. The
    ' example demonstrates the use of the CodePage property
    ' of the Session object to temporarily set the character
    ' set to Chinese so the text sent to the browser uses the
    ' Chinese character set:
    Dim uintOrigCodePage
    Dim uintChineseCodePage

    uintChineseCodePage = 950
    uintOrigCodePage = Session.CodePage

    Session.CodePage = uintChineseCodePage
    %>
    ' +-----------------------------------------------------------+
    ' | This text is sent to the client browser using the         |
    ' | Chinese character set.                                    |
    ' +-----------------------------------------------------------+
    <%

    ' Remember to reset your CodePage property if you don't want
    ' the rest of of the text created and placed into the HTML
    ' stream to be displayed using the new character set.
    Session.CodePage = uintOrigCodePage

    %>
Remarques
N'oubliez pas que, par défaut, les pages ASP emploient le jeu de caractères que vous définissez pour la page de script à l'aide de la directive CODEPAGE (voir chapitre 11). La définition de la propriété CodePage ne remplace ce principe que pour le texte envoyé au navigateur. Le texte des scripts est toujours communiqué entre ASP et votre script, ou entre votre script et les composants ActiveX, à l'aide du jeu de caractères déclaré dans la directive CODEPAGE.

LCID |
Session.LCID (= intLCID)
La langue représente une préférence d'utilisateur relative à la mise en forme de certaines informations. Par exemple, les dates emploient le format mois/jour/année dans certaines langues, comme l'anglais des États-Unis. Chaque langue est identifiée par son LCID (ID de langue) unique. Ce code est défini dans le système d'exploitation. Vous pouvez définir l'identificateur de langue pour le contenu de vos scripts à l'aide de la propriété LCID de l'objet Session. La propriété LCID représente l'identificateur de langue valide qui servira pour afficher du contenu dynamique dans le navigateur Web.
Paramètres
intLCID Identificateur de langue (32 bits) valide.
Exemple
    <%

    ' The following code demonstrates the use of the LCID property
    ' to temporarily set the locale identifier to Standard French.

    Dim intOrigLCID
    Dim intFrenchLCID

    intFrenchLCID = 1036
    intOrigLCID = Session.LCID

    Session.LCID = intFrenchLCID
    %>
    ' +-----------------------------------------------------------+
    ' | This text sent to the client browser will be formatted    |
    ' | according to the rules set by the locale identifier for   |
    ' | Standard French. For example, dates would be formatted    |
    ' | using the Day/Month/Year format, instead of the U.S.      |
    ' | standard Month/Day/Year.                                  |
    ' +-----------------------------------------------------------+
    <%

    ' The next line resets the LCID property:
    Session.LCID = intOrigLCID

    %>
Remarques
Employant une syntaxe similaire à la propriété CodePage, la propriété LCID permet de définir les règles de mise en forme des dates et heures, ainsi que les règles relatives au classement alphabétique des chaînes. Si vous utilisez la directive ASP LCID, vous définissez l'identificateur de langue pour l'environnement du script sur le serveur. La propriété Session.LCID utilise cette valeur comme valeur par défaut. Si vous voulez envoyer des informations de chaîne ou de date/heure au client en employant des règles de mise en forme différentes, vous devez définir la propriété LCID de l'objet Session. Toutefois, cette définition n'a aucune influence sur la manière dont les chaînes et les valeurs date/heure sont mises en forme à l'intérieur du script.

SessionID |
Session.SessionID
Valeur en lecture seule qui identifie de manière unique la session de chaque utilisateur actuel. Cette valeur, qui possède le type de données Long, est stockée sous la forme d'un cookie sur l'ordinateur client. Au cours d'une session d'utilisateur, le navigateur de l'utilisateur envoie ce cookie au serveur Web afin d'identifier l'utilisateur.
Paramètres
None
Exemple
    <%

    ' The following code retrieves the current SessionID for
    ' a given user:

    Dim lngUserSessionId

    lngUserSessionId = Session.SessionID

    %>
Remarques
La propriété SessionID est générée la première fois qu'un utilisateur demande une page sur le serveur Web. Le serveur Web crée une valeur pour la propriété SessionID en employant un algorithme complexe, après quoi il stocke cette valeur sous la forme d'un cookie sur l'ordinateur de l'utilisateur. Par la suite, à chaque fois que l'utilisateur demande une page sur le serveur Web, ce cookie est envoyé au serveur dans l'en-tête de la demande HTTP. Le serveur peut ainsi identifier l'utilisateur grâce à son SessionID. Le cookie n'est réinitialisé que quand le client redémarre son navigateur ou lorsque le gestionnaire du site redémarre le serveur Web. Notez que le cookie SessionID persiste dans le navigateur client et est envoyé au serveur Web (qui le reconnaît) jusqu'à ce qu'un des deux ordinateurs (client ou serveur Web) soit redémarré. Cette période n'a aucun rapport avec la propriété Timeout de l'objet Session. Par exemple, supposons que la session d'un utilisateur se termine ou soit abandonnée à l'aide de la méthode Abandon de l'objet Session. Ensuite, l'utilisateur (qui n'a pas redémarré son navigateur) visite de nouveau le site. Si le serveur Web n'a pas non plus été redémarré depuis la fin de la dernière session, il ouvrira une nouvelle session pour l'utilisateur, mais en employant le même SessionID, qui est renvoyé au serveur Web dans le cadre de la demande HTTP. Ce dernier point est important et mérite qu'on s'y arrête. Vous ne pouvez supposer qu'une valeur SessionID identifie un utilisateur de manière unique que si le navigateur client et les applications du serveur Web n'ont pas été redémarrés. N'utilisez pas cette valeur comme clé principale, par exemple, car elle est réinitialisée à chaque fois que le navigateur ou le serveur est arrêté et redémarré. En outre, n'oubliez pas que les navigateurs qui ne prennent pas les cookies en charge ou qui les ont désactivés n'envoient pas le SessionID dans l'en-tête de la demande HTTP. Dans un tel cas, vous devez utiliser une autre méthode pour identifier les utilisateurs. Vous pouvez également interdire à l'application Web d'utiliser des cookies en employant la directive de pré-traitement EnableSessionState (pour plus d'informations, reportez-vous au chapitre 11). Pour gérer les informations sans employer de cookies, vous pouvez ajouter les informations provenant de chaque demande dans la QueryString, ou publier les informations d'identification à partir d'un élément de formulaire masqué sur votre page.

Timeout |
Session.Timeout (=intMinutes)
Le délai, en minutes, pendant lequel le serveur Web conserve les informations sur la session d'un utilisateur sans demander ou actualiser une page. Cette valeur est fixée par défaut 20 minutes.
Paramètres
intMinutes Le nombre de minutes pendant lequel le serveur Web conserve les informations sur la session.
Exemple
    <%

    ' The following code resets the Timeout property of the
    ' Session object from its default of 20 minutes to 5
    ' minutes.

    Session.Timeout = 5

    %>
Remarques
L'emploi de la propriété Timeout est très simple. Vous pouvez lui donner une valeur aussi élevée que vous le souhaitez, mais notez que cette propriété influe directement sur la consommation de mémoire de chaque session utilisateur sur le serveur Web. Il peut être utile de fixer une valeur plus basse (comme dans l'exemple) si les utilisateurs ne visitent votre site que pendant de courtes périodes. Par contre, si chaque page fait l'objet d'une visite de plus longue durée (par exemple, si une page fournit une calculatrice scriptée côté client), il peut s'avérer nécessaire d'augmenter cette valeur. Notez qu'au contraire de la plupart des propriétés de l'objet Session, cette propriété influe sur toutes les sessions utilisateur, et pas uniquement sur la session actuelle. Si vus fixez la valeur de la propriété Timeout de l'objet Session à 120 minutes, les informations sur les sessions de tous les utilisateurs resteront dans la mémoire du serveur Web 120 minutes après leur dernière demande ou actualisation d'une page.

Collection Contents |
    Session.Contents.Item("Pi") = 3.14
  Contient les variables et les objets ajoutés avec une portée de niveau session par un script (c.à-d. pas via la balise <OBJECT>). La collection Contents de l'objet Session, comme les autres collections ASP, possède les propriétés suivantes : Item Récupère la valeur d'un membre précis de la collection Contents. Vous pouvez indiquer de quel membre il s'agit à l'aide d'une clé de chaîne (dont vous pouvez obtenir la valeur au moyen de l'index, via la propriété Key décrite plus loin dans cette section) ou à l'aide d'un numéro d'index. Par exemple, pour initialiser un élément de la collection Contents possédant une valeur de Pi, vous pouvez employer une ligne de code semblable à la suivante :
      Session.Contents.Item("Pi") = 3.14
  Dans la ligne de code précédente, l'élément désiré de la collection est défini à l'aide de la valeur de clé "Pi". Après cette initialisation, vous pouvez récupérer la valeur de cet élément de la collection Contents au moyen de la ligne de code suivante :
      dblMyVar = Session.Contents.Item("Pi")
  Pour des raisons qui vont devenir évidentes dans quelques instants, supposons qu'il s'agisse du premier élément ajouté à la collection Contents. Vous pouvez également récupérer la valeur d'un élément de la collection Contents en utilisant son index dans la collection au lieu d'une clé, comme le montre la ligne de code suivante :
      dblMyVar = Session.Contents.Item(1)
  Il faut utiliser 1 (un) et non 0 (zéro) pour représenter le premier élément de la collection Contents. Ce point mérite d'être mentionné, car l'emploi d'un zéro dans cette ligne de code entraînerait l'initialisation de la variable dblMyVar avec une valeur indéfinie. Cette situation ne provoquerait malheureusement pas une erreur. Elle produirait simplement une variable mal initialisée :
      dblMyVar = Session.Contents.Item(0) ' WRONG.
  Item est la propriété par défaut de la collection Contents, qui est à son tour la collection par défaut de l'objet Application. Ceci signifie que les trois lignes de code suivantes sont interprétées de manière identique dans votre application :
      Session.Contents.Item("Pi") = 3.14
      Session.Contents("Pi") = 3.14
      Session("Pi") = 3.14
  De même, on pourrait supposer que les trois lignes de code suivantes sont elles aussi équivalentes :
      Session.Contents.Item(1) = 3.14159
      Session.Contents(1) = 3.14159
      Session(1) = 3.14159
  Toutefois, ce n'est le cas que si le premier élément de la collection Contents a été défini précédemment à l'aide d'une clé. Bien que ceci ne soit pas indiqué dans la documentation d'ASP, pour pouvoir utiliser l'une des deux premières lignes de code ci-dessus, l'élément doit avoir été défini précédemment à l'aide d'une clé. Par exemple, supposons que vous décidiez d'ajouter un second élément à la collection Contents. Vous ne pouvez pas l'initialiser à l'aide d'une des lignes de code suivantes :
      Session.Contents.Item(2) = 3.14159     ' WRONG.
      Session.Contents(2) = 3.14159          ' WRONG.
  Malheureusement, cette exception comporte elle-même une exception. Vous pouvez employer le code suivant pour initialiser une seconde variable :
      Session(2) = 3.14159
  Au vu de ce manque de cohérence, il est évident qu'il est toujours plus prudent d'utiliser une clé au lieu d'un index pour faire référence à la valeur d'un élément spécifique de la collection Contents. Il est en outre important d'utiliser une clé pour faire référence à un membre précis de la collection Contents, car il peut arriver que l'index de ce membre soit modifié. Par exemple, supposons que le code suivant figure dans votre application :
      Session("strFirstName") = "Arthur"
      Session("strMiddleName") = "Keyton"
      Session("strLastName") = "Weissinger"
  En supposant que ces variables sont les trois premières à avoir été ajoutées à la collection Contents, vous pourriez ensuite faire référence à chacune d'elle à l'aide de leur index :
      strFirst = Session(1)
      strMiddle = Session(2)
      strLast = Session(3)
  Toutefois, si vous utilisez la méthode Remove, qui supprime totalement une variable de la collection (voir plus loin dans ce chapitre), pour supprimer la variable strMiddleName, les numéros d'index vont changer :
      Session.Contents.Remove("strMiddleName")

      strFirst = Session(1)       ' Initializes to "Arthur"
      strMiddle = Session(2)      ' Initializes to "Weissinger"
      strLast = Session(3)        ' Initializes to Undefined.
  Key Représente le nom d'un élément précis de la collection Contents. Nous avons vu précédemment que la valeur de chaque élément était représentée par la propriété Item. De même, le nom de chaque élément est représenté par sa propriété Key. Si vous ignorez le nom d'une clé spécifique, vous pouvez l'obtenir à l'aide de sa référence ordinale. Par exemple, supposons que vous vouliez connaître le nom de clé du troisième élément de la collection, puis récupérer la valeur de cet élément. Vous pouvez utiliser le code suivant :
      strKeyName = Session.Contents.Key(3)
      strKeyValue = Session.Contents.Item(strKeyName)
Count Renvoie le nombre actuel d'éléments dans la collection. Tout comme les autres collections ASP, vous pouvez récupérer la valeur de n'importe quel champ de la collection Contents par l'intermédiaire de la propriété Item. Toutefois, comme expliqué ailleurs dans ce manuel, dans les exemples suivants, la syntaxe a été abrégée de manière à ne pas montrer explicitement l'emploi de la propriété Item. Par exemple :
    strSecurityCode = Session("UserSecurityCode")
est une forme abrégée de :
    strSecurityCode = Session.Contents.Item("UserSecurityCode")
Pour plus d'informations sur les propriétés Item, Key et Count d'une collection, reportez-vous à la discussion de la section 4.2 du chapitre 4. Jusque la version 3.0 d'ASP, les éléments stockés dans la collection Contents restaient en mémoire jusqu'à la fin de la session de l'utilisateur. Par contre, ASP 3.0 ajoute deux méthodes qui permettent de supprimer des membres de la collection.

Remove |
Session.Contents.Remove(Key | Index)
Supprime un membre précis de la collection Contents. Nouveauté de IIS 5.0, la méthode Remove permet de supprimer de la mémoire une variable spécifique de la collection Contents de la session sans supprimer toutes les autres. La méthode Remove est un ajout important à la collection Contents, car elle permet d'améliorer le contrôle et le nettoyage de la mémoire. Elle permet de supprimer de la mémoire certains éléments de votre collection sans pour autant abandonner la session de l'utilisateur. Comme nous l'avons vu précédemment pour la propriété Item de la collection Contents, il est très important d'employer une clé de chaîne au lieu d'un index lors de l'appel de la méthode Remove. L'index d'un élément peut changer au cours de la durée de vie de l'application, et votre appel de Remove peut provoquer des résultats imprévisibles.
Paramètres
Key Une variable de chaîne qui spécifie le nom du membre précis de la collection Contents à supprimer. Index Une variable entière qui spécifie l'index du membre précis de la collection Contents à supprimer.
Exemple
Le script suivant supprime deux membres de la collection Contents :
    <%
    ' This script assumes you have been "carrying around" various form
    ' variables for an online membership request form. The user has filled
    ' out the form, she has a username and is now a member. Now you would
    ' like to remove her form data which you stored in Session variables
    ' because it was convenient and the form's security had to be relatively
    ' high.
    strFirstName = Session("strFirstName")
    strLastName  = Session("strLastName")

    .
    .
    .
    Session.Contents.Remove("strFirstName")
    Session.Contents.Remove("strLastName")
    .
    .
    .
    %>

RemoveAll |
Session.Contents.RemoveAll
Supprime tous les membres de la collection Contents. Nouveauté de IIS 5.0, la méthode RemoveAll permet de supprimer de la mémoire toutes les variables de niveau session, sans pour autant abandonner la session. Tout comme la méthode Remove, la méthode RemoveAll est un ajout important à la collection Contents, car elle permet d'améliorer le contrôle et le nettoyage de la mémoire. Elle permet de supprimer toutes les variables de niveau session, sans pour autant abandonner la session.
Paramètres
None
Exemples :
Le script suivant supprime tous les membres de la collection Contents :
    <%
    ' This script assumes you have been "carrying around" various form
    ' variables for an online membership request form. The user has
    ' filled out the form, she has a username
    ' and is now a member. Now you would like to remove her form data which
    ' you stored in Session variables because it was convenient and the
    ' form's security had to be relatively high.
    ' strFirstName = Session("strFirstName")
    ' strLastName  = Session("strLastName")

    .
    .
    .
    Session.Contents.RemoveAll
    .
    .
    .
    %>
Le script suivant est le premier de deux scripts ASP que l'utilisateur va visiter (le premier redirige le navigateur de l'utilisateur vers le second). Dans ce premier script, les variables de niveau session de l'utilisateur sont créées (SessionVar1, SessionVar2 et SessionVar3).
    <HTML>
    <HEAD><TITLE>Session Contents Example Page1</TITLE></HEAD>
    <BODY>
    <%
    Dim strVar1
    Dim strVar2
    Dim strVar3

    strVar1 = "Session Variable 1"
    strVar2 = "Session Variable 2"
    strVar3 = "Session Variable 3"

    ' Each of the next three varieties of syntax
    ' are equivalent.
    Session.Content.Item("SessionVar1") = strVar1
    Session.Content("SessionVar2") = strVar2
    Session("SessionVar3") = strVar3

    Response.Redirect SessionPage2.asp
    %>
    </BODY>
    </HTML>
Dans le second script, nous allons examiner les éléments actuels de la collection Contents de l'objet Session.
    <HTML>
    <HEAD><TITLE>Session Contents Example Page2</TITLE></HEAD>
    <BODY>
    <%
    Dim intContentsCount
    Dim strAppStatus
    Dim strKey
    Dim intCounter
    Dim objMyComponent
    Dim arystrNames( )

    intContentsCount = Session.Contents.Count
    strAppStatus = "Open"
    %>
    There are <%= intContentsCount %> items in the
    Session's Contents collection. <BR>
    <%
    For Each strKey in Session.Contents
    %>
       The next item in Session's Contents collection<BR>
       has <%= strKey %> as its key and
       <%= Session.Contents(strKey) %>
       as its value.<BR>
    <%
    Next

    ' Set the AppStatus item in the Contents collection.
    ' If this Session variable has been created before this,
    ' this line resets its value. If it has not been
    ' created, this line creates it.
    strAppStatus = "Page2...InProcess..."
    Session("AppStatus") = strAppStatus

    %>
    The first three elements of the Session's Contents
    collection are as follows: <BR>
    <%
    ' Retrieve the first three elements of the Contents
    ' collection.
    For intCounter = 1 to 3
    %>
       <%= Session.Contents(intCounter) %> <BR>
    <%
    Next
    %>
    A second trip through the first three items.
    <%
    ' This could just as accurately have been written
    ' like this:
    For intCounter = 1 to 3
    %>
       <%= Session.Contents.Item(intCounter) %> <BR>
    <%
    Next

    ' Add an object to the Contents collection, then use that
    ' object's PrintDoc method through the Contents collection.
    ' (NOTE: For more on the Server object, see Chapter 9.)

    '************************************************************
    ' If you try this script on your own, it will raise an error
    ' because of the lack of the Server component.
    '************************************************************
    Set objMyComponent = Server.CreateObject("MyComp.clsSpecial")
    Session ("objRef") = objMyComponent

    ' Call the object's method through the Contents collection.
    Session ("objRef").PrintDoc
    %>
    </BODY>
    </HTML>
Remarques
Si vous ajoutez une variable d'objet à la collection Contents de l'objet Session, vous pouvez accéder aux méthodes et propriétés de cet objet à l'aide de la syntaxe Contents. Par exemple, le code suivant crée une instance de l'objet MyServerComp puis fait référence à sa propriété LastUpdated :
    Dim datLastUpdated
    Set Session.Contents(objSessionMyObj)  =  _
       Server.CreateObject("MyCompanyDLL.MyServerComp")
    datLastUpdated = Session.Contents(objSessionMyObj).LastUpdated
Lorsque vous ajoutez un tableau à la collection Contents, ajoutez-le en entier. Lorsque vous modifiez un élément du tableau, récupérez une copie du tableau, modifiez l'élément puis ajoutez de nouveau le tableau entier à la collection Contents. L'exemple suivant fait la démonstration de ce principe :
    <% Response.Buffer = True%>
    <HTML>
    <HEAD><TITLE>Session Array Example</TITLE></HEAD>
    <BODY>
    <%
    ' Create an array variable and add it to the
    ' Contents collection.
    ReDim arystrNames(3)

    arystrNames(0) = "Chris"
    arystrNames(1) = "Julie"
    arystrNames(2) = "Vlad"
    arystrNames(3) = "Kelly"

    Session.Contents("arystrUserNames") = arystrNames
    %>
    The second name in the User Names array is <BR>
    <%= Session("arystrUserNames")(1) %>
    <%

    ' Change an element of the array being held in the
    ' Contents collection. Use a different (new) array
    ' to temporarily hold the contents. Creating a new
    ' array is the safest way to work with Session
    ' arrays because most of the time you cannot be
    ' guaranteed how many elements are contained
    ' in a Session array created in another script.
    arystrNames2 = Session("arystrUserNames")
    arystrNames2(1) = "Mark"

    Session("arystrUserNames") = arystrNames2
    ' The second name is now Mark.
    %>
    <BR><BR>Now, the second name in the User Names array is <BR>
    <%= Session("arystrUserNames")(1) %><BR>
    <BR><BR><BR><BR><BR>
    NOTE: The first element of the Contents collection is still
    1, not 0 -- even though the first element of the array in element 1
    ("arystrUserNames") is 0:<BR><BR>
    <%= Session.Contents(1)(0)%> <BR>
    </BODY></HTML>
Les objets créés dans le fichier GLOBAL.ASA ne sont pas véritablement lancés sur le serveur avant le premier appel d'une propriété ou d'une méthode de cet objet. Si vous voulez utiliser un objet précis dans une transaction à l'aide de l'objet ObjectContext, ne donnez pas à cet objet une portée de niveau application ou session. Un objet utilisé dans une transaction est détruit à la fin de la transaction, et toute référence ultérieure à ses propriétés ou tout appel de ses méthodes produira une erreur. Vous noterez que la collection Contents (et StaticObjects) de l'objet Session est très semblable à la collection Contents de l'objet Application. Bien que la collection Contents soit la collection par défaut de l'objet Session, un comportement inhabituel la distingue de la collection Contents de l'objet Application : il est impossible de récupérer directement un élément à partir de l'objet Session, car vos références implicites à la collection Contents (la collection par défaut de l'objet Session) et la méthode Item (la valeur par défaut de la collection) ne peuvent pas être résolues correctement. Supposons le code suivant :
    <HTML>
    <HEAD><TITLE>Strange Behaviour</TITLE></HEAD>
    <BODY>
    <%
    Session.Contents.Item("Item1") = "SessionVar1"
    Session.Contents.Item("Item2") = "SessionVar2"
    Session.Contents.Item("Item3") = "SessionVar3"
    %>
    . . . [additional code]
Comme la collection Contents est la collection par défaut de l'objet Session, vous pouvez faire référence à Item2 au moyen de la ligne de code suivante :
    strNewVar = Session("Item2")
Toutefois, au contraire de la collection Contents de l'objet Application, vous ne pouvez pas faire référence à ce même élément à l'aide de la ligne de code suivante. Cette ligne sera ignorée ou provoquera une erreur, en fonction de la variable que vous tentez de récupérer :
    strNewVar = Session(2)
Toutefois :
    strNewVar = Session.Contents.Item(2)
ou :
    strNewVar = Session.Contents(2)
fonctionneront sans problème. Je n'ai trouvé nulle part de référence à ce comportement, mais il s'est avéré constant dans IIS et Personal Web Server.

Collection StaticObjects |
    strFirstObjName = _
       Session.StaticObjects.Key(1)
  Contient tous les objets de niveau session qui sont ajoutés à l'application à l'aide de la balise <OBJECT>. Vous pouvez utiliser la collection StaticObjects pour récupérer les propriétés d'un objet précis de la collection. Vous pouvez également l'employer pour utiliser une méthode précise d'un objet spécifique de la collection. La collection StaticObjects de l'objet Session, comme les autres collections ASP, possède les propriétés suivantes : Item Représente la valeur d'un élément précis de la collection. Pour définir un élément, vous pouvez utiliser un numéro d'index ou une clé. Key Représente le nom d'un élément précis de la collection. Par exemple :
      strFirstObjName = _
         Session.StaticObjects.Key(1)
  récupère le nom du premier élément de la collection StaticObjects de l'objet Session. Utilisez la valeur de la propriété Key pour récupérer la valeur d'un élément selon son nom. Par exemple, supposons que le premier élément soit nommé objMyObject. Le code :
      strKey = Session.StaticObjects.Key(1)
      Session.StaticObjects.Item(strKey).Printer = "Epson 540"
définit ensuite la valeur de la propriété Printer de l'élément objMyObject dans la collection StaticObjects de l'objet Session. Count Renvoie le nombre actuel d'éléments dans la collection. Tout comme les autres collections ASP, vous pouvez récupérer la valeur de n'importe quel champ de la collection StaticObjects par l'intermédiaire de la propriété Item. Toutefois, comme expliqué ailleurs dans ce manuel, dans les exemples suivants, la syntaxe a été abrégée de manière à ne pas montrer explicitement l'emploi de la propriété Item. Par exemple :
    strPrinterName = Session.StaticObjects("objMyObj").Printer
est une forme abrégée de :
    strPrinterName = Session.StaticObjects.Item("objMyObj").Printer
Pour plus d'informations sur les propriétés Item, Key et Count d'une collection, reportez-vous à la discussion de la section 4.2 du chapitre 4.
Exemple
    ' < FROM GLOBAL.ASA >
    ' This code resides in the GLOBAL.ASA file at the
    ' root of the current application. The following
    ' <OBJECT> tag is only processed once for the current
    ' application.
    ' See Chapter 11 for more details on the GLOBAL.ASA file.

    <OBJECT RUNAT=Server
    SCOPE=Session
    ID=AppInfo1
    PROGID="MSWC.MyInfo">
    </OBJECT>

    <OBJECT RUNAT=Server
    SCOPE=Session
    ID=AppInfo2
    PROGID="MSWC.MyInfo">
    </OBJECT>

    ' <>

    <%
    ' The following code initializes the AppInfo1 component.
    ' This initialization code can reside anywhere.
    AppInfo1.PersonalName = "Gertrude Stein"
    AppInfo1.PersonalAddress = "233 Main Street"

    AppInfo2.PersonalName = "David Davidson"
    AppInfo2.PersonalAddress = "19A West Avenue"

    ' The following code uses the StaticObjects collection
    ' of the Session object to retrieve the value
    ' of the PersonalName property of both AppInfo1 and AppInfo2.
    For Each objInfo In Session.StaticObjects
    %>
       The personal name is <BR>
       <%= Session.StaticObjects(objInfo).PersonalName%>
    <%
    Next
    %>

    There are <%= Session.StaticObjects.Count %> items
    in the Session's StaticObjects collection.
Remarques
La collection StaticObjects de l'objet Session permet d'accéder à n'importe quel objet lancé au niveau d'une session à l'aide d'une balise <OBJECT>. Les objets démarrés à l'aide de Server. CreateObject ne sont pas accessibles via cette collection. L'exemple consacré à StaticObjects dans la documentation de IIS 5.0 par Microsoft suggère que si vous effectuez une itération dans cette collection, vous pourrez faire référence à chaque propriété de l'objet. Cette affirmation est quelque peu trompeuse, car elle semble indiquer que la collection représente en fait toutes les propriétés des objets, et non les objets proprement dit. Si vous voulez accéder aux propriétés ou aux méthodes d'objets dans la collection StaticObjects, vous devez utiliser l'opérateur point en dehors des parenthèses qui entourent Key, suivi du nom de la propriété ou de la méthode, comme indiqué ci-dessous :
    <%= Session.StaticObjects(objInfo).PersonalName%>
Cette ligne de code fonctionne, car Session.StaticObjects(objInfo) renvoie une référence à l'objet objInfo. Les objets créés dans le fichier GLOBAL.ASA ne sont pas véritablement lancés sur le serveur avant le premier appel d'une propriété ou d'une méthode de cet objet. Dès lors, il est impossible d'utiliser la collection StaticObjects pour accéder aux propriétés et méthodes de ces objets avant qu'un autre code de votre application a provoqué leur lancement sur le serveur. Si vous voulez utiliser un objet précis dans une transaction à l'aide de l'objet ObjectContext, ne donnez pas à cet objet une portée de niveau application ou session. Un objet utilisé dans une transaction est détruit à la fin de la transaction, et toute référence ultérieure à ses propriétés ou tout appel de ses méthodes produira une erreur.

Abandon |
Session.Abandon
Libère la mémoire utilisée par le serveur Web pour stocker des informations au sujet d'une session d'utilisateur précise. Elle n'influe par contre pas sur les informations des sessions des autres utilisateurs. Si la méthode Abandon n'est pas appelée de manière explicite, le serveur Web conserve toutes les informations de session jusqu'à ce que la session expire.
Paramètres
None
Exemple
Le script suivant permet à l'utilisateur de cliquer sur un lien qui redirige son navigateur vers une page qui effacera ses variables de session :
    <HTML>
    <HEAD><TITLE>Session Abandon Example Page1</TITLE></HEAD>
    <BODY>
    Click <A HREF = "/SessionAbandonPage2.asp">here</A> to reset your user preferences.
    </BODY>
    </HTML>
Le script suivant efface véritablement les variables de session :
    <HTML>
    <HEAD><TITLE>Session Abandon Example Page2</TITLE></HEAD>
    <BODY>
    <%

    ' The following code abandons the current user session.
    ' Note that the actual information stored for the current
    ' user session is not released by the server until the
    ' end of the current Active Server Pages.

    Session.Abandon

    %>
    Your user preferences have now been reset.
    </BODY>
    </HTML>
Remarques
Si vous faites un usage intensif de la collection Contents de l'objet Session, la méthode Abandon peut s'avérer très pratique. Supposons par exemple que de nombreuses préférences d'utilisateur soient enregistrées sous la forme de variables de session. Vous voulez les supprimer toutes et autoriser l'utilisateur à en sélectionner de nouvelles. Sans la méthode Abandon, vous devriez supprimer chaque variable de la collection Contents manuellement, une tâche fastidieuse si vous utilisez plusieurs variables. La méthode Abandon permet de tout supprimer via une seule ligne de code. La méthode Abandon est en fait traitée par le serveur Web après le traitement du reste du script de la page actuelle. Toutefois, lorsque le traitement de la page actuelle est terminée, toute demande de page par l'utilisateur lance une nouvelle session sur le serveur Web. Dans l'exemple suivant, la variable de session intUserAge est disponible pour votre script jusqu'à la fin de la page. La méthode Abandon ne supprime pas la variable de la mémoire avant la fin de la page :
    Session("intUserAge") = 23
    Session.Abandon
    [...More Code...]
    ' The current line successfully retrieves the value of
    ' intUserAge.
    intAgeCategory = CInt(Session("intUserAge") / 10)
    [...End of Script. Session information is removed from web memory now...]

Session_OnEnd |
Session_OnEnd
Déclenché lorsque la session de l'utilisateur expire ou lorsque vos scripts appellent la méthode Abandon de l'objet Session. La procédure d'événement OnEnd, si elle existe, se trouve dans le fichier GLOBAL.ASA pour l'application qui contient la page demandée.
Paramètres
None
Exemple
    <SCRIPT LANGUAGE = "VBScript" RUNAT = Server>

    Sub Session_OnEnd

       ' If the user has a search results recordset open, close
       ' it:
       If IsObject(adoRSResults) Then
          Set adoRSResults = Nothing
       End If

    End Sub

    </SCRIPT>
Remarques
Dans le code de la procédure d'événement OnEnd, vous ne pouvez accéder qu'aux objets Application, Server et Session. Plus important encore, vous ne pouvez pas accéder aux objets Response et Request, si bien qu'il est impossible de rediriger le client ou d'envoyer des cookies à l'ordinateur client (ni en recevoir depuis celui-ci). L'une des fonctions potentielles de l'événement OnEnd consiste à écrire des informations relatives à l'utilisateur dans un fichier journal ou un autre fichier texte sur le serveur, afin de pouvoir les réutiliser ultérieurement. Si c'est là votre intention, vous devez vous souvenir de plusieurs remarques importantes. Tout d'abord, avant de pouvoir sauvegarder des informations, elles doivent être enregistrées dans une variable de session, car, comme nous l'avons indiqué plus haut, vous ne pouvez pas accéder à l'objet Request, qui est la source la plus courante d'informations sur les utilisateurs. Le code suivant fait la démonstration d'une méthode possible de stockage d'une variable de niveau session :
    <SCRIPT LANGUAGE = "VBScript" RUNAT = Server>

    Sub Session_OnEnd

       ' Assume that SessionVar1 contains some user-preference
       ' information.

       ' It is not important that you understand exactly what is
       ' happening in the following code (you can learn more about
       ' File objects in Chapter 19). Just suffice it to say
       ' that these lines of code write the value of the
       ' SessionVar1 Session variable to the text file
       ' UserPref.txt.
       Set fs = Server.CreateObject("Scripting.FileSystemObject")
       Set f = fs.GetFile("d:\UserPref.txt")
       Set ts = f.OpenAsTextStream(ForAppending,_
                        TristateUseDefault)
       ts.Write Session(SessionVar1)
       ts.Close

       ' Note that more often than not, if you want to save this
       ' information to the server at the end of a user's session,
       ' it may very well be more efficient to store it to a
       ' database than to a text file. However, the general
       ' principal (of storing Session variable information in
       ' the OnEnd event) is similar.

    End Sub

    </SCRIPT>
Notez qu'il est impossible d'utiliser la méthode AppendToLog de l'objet Response, car ce dernier n'est pas disponible. En outre, si vous avez l'intention d'écrire directement sur le disque dur du serveur Web, vous devez connaître le chemin d'accès physique du fichier dans lequel vous voulez écrire. En effet, même si vous avez accès à l'objet Server, vous ne pouvez pas utiliser sa méthode MapPath dans l'événement OnEnd (pour plus d'informations sur la méthode MapPath, reportez-vous à la section "MapPath" du chapitre 9).

Session_OnStart |
Session_OnStart
Déclenché à chaque fois qu'un utilisateur qui n'a pas encore lancé de session sur le serveur Web demande une page au serveur. Le code de l'événement OnStart de l'objet Session, s'il existe, est traité avant tout le code de la page demandée. La procédure d'événement OnStart, si elle existe, se trouve dans le fichier GLOBAL.ASA pour l'application qui contient la page demandée.
Paramètres
None
Exemple
    <SCRIPT LANGUAGE = "VBScript" RUNAT = Server>

    Sub Session_OnStart

       Dim strSiteStartPage
       Dim strCurrentPage
       Dim timUserStartTime
       Dim strUserIPAddress
       Dim strUserLogon

       ' Use the OnStart event to initialize session-level
       ' variables that your scripts can use throughout the
       ' the duration of the user's session.
       Session("timUserStartTime") = Now( )
       Session("strUserIPAddress") = _
               Request.ServerVariables("REMOTE_ADDR")

       ' Use the OnStart event to redirect the client if
       ' she attempts to enter the site from somewhere
       ' other than the site's home page.
       strCurrentPage = Request.ServerVariables("SCRIPT_NAME")
       strSiteStartPage = "/apps/home/startpage.asp"

       If StrComp(strCurrentPage, strSiteStartPage, 1) Then
          Response.Redirect(strSiteStartPage)
       End If

       ' You can also use the OnStart event of the Session
       ' object to assess user security access from the very
       ' beginning of the user's session. Note this code requires
       ' use of either the Basic authentication or Windows
       ' NT Challenge Response access control on the web server.
       strUserLogon = Request.ServerVariables("LOGON_USER")
       [...Code to Determine Security Level...]

    End Sub

    </SCRIPT>
Remarques
Si le navigateur du client ne prend pas en charge les cookies, ou si l'utilisateur les a désactivés manuellement, l'événement Session_OnStart est traité à chaque fois que l'utilisateur demande une page sur le site. Aucune session n'est démarrée ni conservée. Tout comme l'événement OnEnd, l'une des fonctions potentielles de l'événement OnStart consiste à écrire des informations relatives à l'utilisateur dans un fichier journal ou un autre fichier texte sur le serveur, afin de pouvoir les réutiliser ultérieurement. Si vous comptez faire ceci, notez qu'il est impossible d'utiliser la méthode AppendToLog de l'objet Response. En outre, si vous avez l'intention d'écrire directement sur le disque dur du serveur Web, vous devez connaître le chemin d'accès physique du fichier dans lequel vous voulez écrire. En effet, même si vous avez accès à l'objet Server, tout comme dans le cas de l'événement OnEnd de l'objet Session, vous ne pouvez pas utiliser la méthode MapPath de l'objet Server dans l'événement Session_OnStart.