Vous êtes sur la page 1sur 58

Module 14 : Gestion d'état

Table des matières

Vue d'ensemble 1
Leçon : Gestion d'état 2
Leçon : Variables d'application
et de session 13
Leçon : Sessions avec et sans cookies 24
Contrôle des acquis 34
Atelier 14 : Stockage de données
d'application et de session 36
Les informations contenues dans ce document, y compris les adresses URL et les références à des
sites Web Internet, pourront faire l'objet de modifications sans préavis. Sauf mention contraire, les
sociétés, les produits, les noms de domaine, les adresses de messagerie, les logos, les personnes,
les lieux et les événements utilisés dans les exemples sont fictifs et toute ressemblance avec des
sociétés, produits, noms de domaine, adresses de messagerie, logos, personnes, lieux et
événements existants ou ayant existé serait purement fortuite. L'utilisateur est tenu d'observer la
réglementation relative aux droits d'auteur applicable dans son pays. Sans limitation des droits
d'auteur, aucune partie de ce manuel ne peut être reproduite, stockée ou introduite dans un système
d'extraction, ou transmise à quelque fin ou par quelque moyen que ce soit (électronique,
mécanique, photocopie, enregistrement ou autre), sans la permission expresse et écrite de
Microsoft Corporation.

Les produits mentionnés dans ce document peuvent faire l'objet de brevets, de dépôts de brevets en
cours, de marques, de droits d'auteur ou d'autres droits de propriété intellectuelle et industrielle de
Microsoft. Sauf stipulation expresse contraire d'un contrat de licence écrit de Microsoft, la
fourniture de ce document n'a pas pour effet de vous concéder une licence sur ces brevets,
marques, droits d'auteur ou autres droits de propriété intellectuelle.

 2002 Microsoft Corporation. Tous droits réservés.

Microsoft, MS-DOS, Windows, Windows NT, Active Directory, ActiveX, BizTalk, Hotmail,
IntelliSense, Jscript, MSN, MSDN, PowerPoint, Visio, Visual Basic, Visual C++, Visual C#,
Visual J#, Visual Studio, Win32 et Windows Media sont soit des marques déposées de Microsoft
Corporation, soit des marques de Microsoft Corporation, aux États-Unis d'Amérique et/ou dans
d'autres pays.

Les autres noms de produit et de société mentionnés dans ce document sont des marques de leurs
propriétaires respectifs.
Module 14 : Gestion d'état 1

Vue d'ensemble

! Gestion d'état
! Variables d'application et de session
! Sessions avec et sans cookies

********************Document a l'usage exclusif de l'instructeur********************

Introduction Microsoft® ASP.NET vous permet de gérer l'état dans une application Web.
L'état est la capacité d'une application Web à conserver des informations
utilisateur.
Dans ce module, vous apprendrez à gérer l'état dans une application Web
ASP.NET.
Objectifs À la fin de ce module, vous serez à même d'effectuer les tâches suivantes :
! décrire la gestion d'état et ses différentes options dans une application Web
ASP.NET ;
! utiliser des variables d'application et de session pour la gestion d'état dans
des applications Web ASP.NET ;
! utiliser des sessions avec et sans cookies pour la gestion d'état dans des
applications Web ASP.NET.
2 Module 14 : Gestion d'état

Leçon : Gestion d'état

! Qu'est-ce que la gestion d'état ?


! Types de gestion d'état
! Gestion d'état côté serveur
! Gestion d'état côté client
! Fichier global.asax

********************Document a l'usage exclusif de l'instructeur********************

Introduction La connexion établie entre un utilisateur (l'ordinateur client) et un serveur Web


est appelée une session. Les sessions peuvent couvrir plusieurs pages Web et
sont suivies par la gestion d'état.
La gestion d'état est le processus qui vous permet de conserver les mêmes
informations au sein de plusieurs demandes d'une même page Web ou de pages
différentes.
Dans cette leçon, vous étudierez tout d'abord en détail la gestion d'état et les
raisons pour lesquelles elle est importante. Vous apprendrez la gestion d'état
côté serveur et côté client. Vous étudierez également le fichier global.asax.
Objectifs de la leçon À la fin de cette leçon, vous serez à même d'effectuer les tâches suivantes :
! décrire la gestion d'état ;
! identifier les différents types d'options de gestion d'état ;
! décrire la gestion d'état côté serveur ;
! décrire la gestion d'état côté client ;
! décrire les différents événements qui sont gérés par le fichier global.asax.
Module 14 : Gestion d'état 3

Qu'est-ce que la gestion d'état ?


Sans gestion d'état Avec gestion d'état
Login.aspx Login.aspx
Veuillez entrer vos Veuillez entrer vos
informations de informations de
connexion : connexion :
Prénom Prénom
Jean Jean
Nom Nom
Lebrun Lebrun

Envoyer
Envoyer Envoyer
Envoyer Serveur
Serveur Web
Web
Serveur
Serveur Web
Web
Greetings.aspx Greetings.aspx
Bonjour
Bonjour
Jean Lebrun
Je
Je ne
ne me
me souviens
souviens
pas
pas de
de vous
vous !!

********************Document a l'usage exclusif de l'instructeur********************

Introduction Tout comme les technologies qui reposent sur le protocole HTTP (Hypertext
Transfer Protocol), les formulaires Web sont sans état, ce qui signifie qu'ils
n'indiquent pas automatiquement si des demandes successives proviennent
toutes d'un même client ou si une instance de navigateur isolée affiche
actuellement une page ou un site Web. En outre, les pages Web sont détruites et
recréées à chaque nouvelle demande transmise au serveur Web. Par conséquent,
la longévité des informations contenues dans une page est inférieure au cycle de
vie de celle-ci.
Gestion d'état ASP.NET offre des capacités de gestion d'état qui permettent d'enregistrer des
informations sur le serveur, même lorsque l'utilisateur change de page, ce qui
permet d'assurer la continuité des informations utilisateur (l'état) tout au long
d'une visite sur un site Web.
Si l'état est conservé entre plusieurs pages, les informations d'origine fournies
par les utilisateurs peuvent être réutilisées, ce qui signifie qu'ils ne doivent pas
entrer les mêmes informations à chaque renvoi d'une page vers le serveur.
Exemple Dans l'illustration ci-dessus, l'utilisateur Jean Lebrun entre son nom dans le
formulaire login.aspx. Une fois ces informations personnelles entrées, elle sont
envoyées vers le serveur, et la page suivante, le formulaire greetings.aspx,
s'affiche. Sans gestion d'état, les informations entrées par l'utilisateur dans la
première page seraient perdues.
Grâce à la gestion d'état dans votre application Web, vous pouvez conserver
l'état dans plusieurs pages Web. Ainsi, lorsque les informations personnelles de
l'utilisateur sont envoyées vers le serveur, la deuxième page (le formulaire
greetings.aspx) accueille l'utilisateur par son nom, Jean Lebrun, qui a été entré
dans le formulaire login.aspx (première page de l'application Web).
4 Module 14 : Gestion d'état

Types de gestion d'état

Gestion d'état côté serveur Gestion d'état côté client

État de l'application Cookies


! Les informations sont
! Le fichier texte enregistre des
accessibles à l'ensemble des
informations pour maintenir
utilisateurs d'une application
l'état
Web
État de la session Propriété ViewState
! Les informations sont
! Conserve les valeurs entre
uniquement accessibles à
plusieurs demandes pour la
l'utilisateur d'une session
même page
spécifique
Base de données
Chaînes de requête
! Dans certains cas, utilisez la
prise en charge de la base de ! Informations ajoutées à la fin
données pour conserver l'état d'une URL
sur votre site Web

********************Document a l'usage exclusif de l'instructeur********************

Introduction ASP.NET offre deux types de gestion d'état qui permettent de conserver l'état
lors des allers-retours vers le serveur. Le choix du type de gestion d'état dépend
principalement de la nature de votre application Web.
Gestion d'état Les deux types de gestion d'état sont les suivants :
côté client et côté
serveur ! Côté serveur
Les options de gestion d'état côté serveur utilisent les ressources du serveur
pour stocker les informations d'état. Ces options offrent une plus grande
sécurité que celles côté client.
! Côté client
Les options de gestion d'état côté client n'utilisent pas les ressources du
serveur pour stocker les informations d'état. Les options côté client offrent
une sécurité minimale, mais accroissent les performances du serveur, car
elles ne lui font pas appel pour conserver l'état.

Côté serveur La gestion d'état côté serveur contient en outre différentes options, notamment :
! État d'application
Les informations d'état d'application sont disponibles pour tous les
utilisateurs d'une application Web (telles que le stockage du nombre de
visiteurs d'une application Web).
! État de session
Dans un état de session, les informations sont uniquement disponibles pour
l'utilisateur d'une session d'application Web spécifique (telles que le
stockage du modèle de couleurs favori d'un utilisateur).
Module 14 : Gestion d'état 5

! Base de données Microsoft SQL Server™ ou serveur d'état


Une autre option de gestion d'état côté serveur consiste à utiliser la
technologie des bases de données. Vous pouvez avoir recours à une base de
données SQL Server ou à un serveur d'état pour stocker des informations
spécifiques à l'utilisateur lorsque celles-ci sont volumineuses. La base de
données SQL Server ou un serveur d'état peut être utilisé conjointement
avec l'état de session et des cookies.
! Objet Cache
Vous pouvez également gérer l'état au niveau de l'application à l'aide de
l'objet Cache.

Remarque Pour plus d'informations sur l'objet Cache, consultez le


module 15, « Configuration, optimisation et déploiement d'une application
Web Microsoft ASP.NET », du cours 2333A, Développement d'applications
Web Microsoft ASP.NET à l'aide de Visual Studio .NET.

Côté client La gestion d'état côté serveur offre également différentes options pour
conserver l'état. Ces options sont les suivantes :
! Cookies
Un cookie est un fichier texte qui peut être utilisé pour stocker de petites
quantités d'informations nécessaires à la conservation d'état.
! Propriété ViewState
La propriété ViewState des formulaires Web est une structure intégrée qui
conserve automatiquement les valeurs de plusieurs demandes de la même
page. Elle est conservée sur la page en tant que champ masqué.
! Chaînes de requête
Une chaîne de requête correspond aux informations qui sont ajoutées à la fin
d'une adresse URL (Uniform Resource Locator). Vous trouverez ci-dessous
un exemple typique :
http://www.contoso.com/listwidgets.aspx?category=basic&price=100
Dans l'URL précédente, la chaîne de requête débute par le point
d'interrogation (?) et contient deux paires attribut-valeur, category et price.

Remarque Ce module traite uniquement des cookies. Pour plus d'informations


sur la propriété ViewState et les chaînes de requête, consultez la documentation
de Visual Studio .NET.
6 Module 14 : Gestion d'état

Gestion d'état côté serveur


! L'état de l'application est un mécanisme de stockage
global, accessible à partir de toutes les pages de
l'application Web
! L'état de la session est limité à la session actuelle du
navigateur
" Les valeurs sont conservées par l'intermédiaire des
variables d'application et de session
" Évolutivité
! La session ASP.NET est identifiée par la chaîne
SessionID
Serveur
Serveur Web
Web
Ordinateur
Ordinateur client
client
Variables d'application et de
session
SessionID

********************Document a l'usage exclusif de l'instructeur********************

Introduction ASP.NET offre plusieurs options de gestion d'état côté serveur. Les états de
l'application et de session en font partie. Cette rubrique traite en détail de ces
deux options.

État d'application ASP.NET permet la gestion d'état d'application grâce à une instance de la classe
HttpApplicationState pour chaque application Web active. L'état d'application
est un mécanisme de stockage global qui est accessible à partir de toutes les
pages de l'application Web, ce qui le rend très utile pour le stockage des
informations utilisateur qui doivent être conservées lors des allers-retours vers
le serveur et entre les pages.
L'état d'application est une structure de dictionnaire clé-valeur, créée à chaque
demande d'une URL spécifique. Cette structure vous permet de stocker les
informations spécifiques à l'application entre chaque demande de page. Une
fois les informations spécifiques à l'application ajoutées à l'état d'application, le
serveur en assure la gestion.
Variables d'application ASP.NET contient les variables d'application nécessaires à la conservation de
l'état d'application. Les données idéales à insérer dans les variables d'application
sont celles qui sont partagées par plusieurs sessions et qui changent peu.

État de session ASP.NET permet la gestion d'état de session grâce à une instance de la classe
HttpSessionState pour chaque session d'application Web active.
L'état de session est similaire à l'état d'application, excepté qu'il est limité à la
session de navigateur en cours. Lorsque plusieurs utilisateurs utilisent une
application Web, chacun d'entre eux possède un état de session différent. En
outre, lorsqu'un utilisateur quitte une application Web, puis y retourne de
nouveau, son état de session est différent de celui qu'il possédait auparavant.
Module 14 : Gestion d'état 7

L'état de session est structuré comme un dictionnaire clé-valeur, dans lequel


sont stockées des informations spécifiques à la session qui doivent être
conservées entre les demandes de pages et les allers-retours vers le serveur. Une
fois les informations spécifiques à l'application ajoutées à l'état de session, le
serveur en assure la gestion. Vous pouvez configurer ASP.NET pour sérialiser
et stocker automatiquement les informations de session dans une base de
données SQL Server ou sur un serveur d'état.
Variables de session ASP.NET contient les variables de session nécessaires à la conservation de
l'état de session. Les données idéales à insérer dans les variables d'état de
session sont celles qui sont temporaires, sensibles et spécifiques à une session
donnée.

Remarque Les états d'application et de session sont implémentés sous la forme


de tables de hachage et les données y sont stockées sur la base d'associations de
paires clé/valeur. Une table de hachage est identique au concept de l'objet
dictionary.

Évolutivité ASP.NET permet d'utiliser l'état de session dans des configurations


multi-ordinateur et multitraitement, ce qui optimise les scénarios d'évolutivité
d'une application Web.
Identification et suivi Chaque session d'application Web active est identifiée et suivie à l'aide d'une
d'une session chaîne SessionID sur 120 bits, qui contient uniquement les caractères ASCII
autorisés dans les URL. Les chaînes SessionID sont communiquées dans les
demandes client-serveur, soit par l'intermédiaire d'un cookie HTTP, soit dans
une URL modifiée qui intègre la chaîne SessionID, appelée communément
SessionID sans cookie, selon la configuration des paramètres de l'application
Web.
La gestion d'état côté serveur requiert un cookie pour stocker la SessionID sur
l'ordinateur client. Étant donné que la durée de vie d'une SessionID est très
courte (le temps de la session), ASP.NET utilise le même mécanisme pour
stocker les informations de session dans une base de données SQL Server ou
sur un serveur d'état et pour permettre à l'application d'être évolutive, mais non
pour un stockage à long terme. Si vous souhaitez implémenter un stockage à
long terme des informations de session utilisateur, vous devez demander aux
utilisateurs d'entrer leurs informations personnelles, puis implémenter votre
propre solution de stockage. Celle-ci utilisera une base de données dans laquelle
les informations personnelles des utilisateurs inscrits seront stockées en
permanence.
8 Module 14 : Gestion d'état

Gestion d'état côté client


! Utilisation des cookies pour maintenir l'état
" Cookies persistants
" Cookies temporaires ou non persistants
! Moins fiable que les options de gestion d'état côté serveur
" L'utilisateur peut supprimer des cookies
! Moins sûr que les options de gestion d'état côté serveur
! Quantité d'informations limitée
" Restrictions côté client relatives à la taille des fichiers
Serveur
Serveur Web
Ordinateur
Ordinateur client
client

Cookies

********************Document a l'usage exclusif de l'instructeur********************

Introduction La plupart des applications Web utilisent des cookies pour la gestion d'état côté
client.
Cookies Un cookie est une petite quantité de données qui est stockée soit dans un fichier
texte dans le système de fichiers de l'ordinateur client, soit dans la mémoire de
la session du navigateur client. Lorsque le serveur envoie une page vers le
client, il envoie également un cookie qui contient des informations spécifiques à
la page.
Vous pouvez utiliser des cookies pour stocker des informations relatives à un
client, à une session ou à une application spécifique. Les cookies sont stockés
sur l'ordinateur client, et lorsque le navigateur demande une page, il envoie les
informations contenues dans le cookie. Le serveur est autorisé à lire le cookie et
à en extraire la valeur. Chaque cookie contient des informations sur le domaine
dont il est issu. Un même domaine peut émettre plusieurs cookies.
Types de cookies Il existe deux types de cookies :
! Temporaires
Les cookies temporaires, appelés également cookies de la session ou
cookies non persistants, sont stockés uniquement dans la mémoire du
navigateur. Lorsque le navigateur est arrêté, ils sont supprimés.
! Persistants
Les cookies persistants sont identiques aux cookies temporaires, mais ils
possèdent une période d'expiration définie. Lorsqu'un navigateur demande
une page qui crée un cookie persistant, il enregistre celui-ci sur le disque dur
de l'utilisateur. Les cookies persistants peuvent résider pendant plusieurs
mois, voire plusieurs années, sur l'ordinateur client. Microsoft Internet
Explorer stocke ces cookies dans un fichier appelé
nomutilisateur@nomdomaine.txt, qui est créé sur le disque dur du client.
Module 14 : Gestion d'état 9

Expiration Les cookies temporaires expirent à la fin de la session du navigateur. Les


cookies permanents, quant à eux, peuvent résider indéfiniment sur l'ordinateur
client, mais sont soumis aux règles d'expiration de celui-ci.
Les utilisateurs peuvent également décider de supprimer les cookies stockés sur
leur ordinateur avant la date d'expiration de ces derniers. Pour cette raison, il est
impossible de garantir la conservation d'un cookie persistant jusqu'à sa date
d'expiration.
Sécurité Les cookies sont moins sécurisés que les options de la gestion d'état côté
serveur. Ils peuvent être en outre falsifiés. Les utilisateurs peuvent manipuler
les cookies qui se trouvent sur leur ordinateur, et compromettre ainsi la sécurité
ou entraîner l'échec de l'application qui dépend du cookie.
Informations limitées La quantité d'informations qu'un cookie peut stocker est limitée, car les
ordinateurs clients imposent des restrictions en matière de taille des fichiers. En
outre, un cookie peut contenir 4 kilo-octets (Ko) d'informations au maximum.
10 Module 14 : Gestion d'état

Fichier global.asax

! Un seul fichier global.asax par application Web


! Stocké dans la racine virtuelle de l'application Web
! Utilisé pour gérer les événements d'application
et de session
! Le fichier global.asax est facultatif

********************Document a l'usage exclusif de l'instructeur********************

Introduction Le fichier global.asax est un fichier déclaratif utilisé pour gérer des événements
lors de l'exécution de votre application Web.
Les caractéristiques du fichier global.asax sont les suivantes :
! Chaque application Web ASP.NET prend en charge un seul fichier
global.asax.
! Le fichier global.asax est stocké dans la racine virtuelle de l'application
Web.
! Le fichier global.asax peut gérer des événements d'application et de session
(début et fin) pour initialiser les variables d'application et de session.
! Le fichier global.asax est facultatif. Si vous ne le définissez pas, la structure
de page ASP.NET suppose que vous n'avez défini aucun gestionnaire
d'événements d'application ou de session.
Module 14 : Gestion d'état 11

Fichier global.asax (suite)


Client
Demande
Demande Réponse
Réponse

Serveur Web ASP.NET

IIS
IIS

Runtime
Runtime HTTP
HTTP de
de ASP.NET
ASP.NET
Application_BeginRequest
Application_BeginRequest

Application_AuthenticateRequest
Application_AuthenticateRequest

Application_AuthorizeRequest
Application_AuthorizeRequest Application_EndRequest
Application_EndRequest

Application_ResolveRequestCache
Application_ResolveRequestCache Application_UpdateRequestCache
Application_UpdateRequestCache

Application_AquireRequestState
Application_AquireRequestState Application_ReleaseRequestState
Application_ReleaseRequestState

Application_PreRequestHandlerExecute
Application_PreRequestHandlerExecute Application_PostRequestHandlerExecute
Application_PostRequestHandlerExecute

Exécution
Exécution de
de la
la page
page

********************Document a l'usage exclusif de l'instructeur********************

Introduction Le fichier global.asax est un fichier déclaratif utilisé pour gérer des événements
lors de l'exécution de votre application Web.
Catégories Le fichier global.asax prend en charge les trois catégories d'événements
d'événements suivantes :
! les événements qui sont déclenchés lors d'une demande de page ;
! les événements qui sont déclenchés lors de l'envoi de la page demandée ;
! les événements d'application conditionnels.

Événements déclenchés Le tableau ci-dessous répertorie les événements déclenchés lors d'une demande
lors d'une demande de de page.
page
Nom de l'événement Description

Application_BeginRequest Cet événement est déclenché à la


réception d'une nouvelle demande.
Application_AuthenticateRequest Cet événement indique que la demande
est prête à être authentifiée.
Application_AuthorizeRequest Cet événement indique que la demande
est prête à être autorisée.
Application_ResolveRequestCache Cet événement est utilisé par le module
de cache de sortie pour arrêter le
traitement des demandes mises en cache.
Application_AcquireRequestState Cet événement indique que l'état doit
être obtenu par demande.
Application_PreRequestHandlerExecute Cet événement indique que le
gestionnaire de demandes est sur le point
de s'exécuter.
12 Module 14 : Gestion d'état

Événements déclenchés Le fichier Global.asax contient également des événements qui sont déclenchés
lors de l'envoi de la lorsque la page demandée est renvoyée vers le client. Ces événements sont
page demandée répertoriés dans le tableau suivant :
Nom de l'événement Description

Application_PostRequestHandlerExecute Cet événement devient disponible


lorsque le gestionnaire (une page
ASP.NET ou un service Web, par
exemple) a terminé son travail.
Application_ReleaseRequestState Cet événement est appelé lorsque l'état
de la demande doit être stocké, après
son traitement par
l'application Web ASP.NET.
Application_UpdateRequestCache Cet événement indique que le traitement
du code est terminé et que le fichier est
prêt à être ajouté au cache d'ASP.NET.
Application_EndRequest Cet événement correspond au dernier
événement appelé lorsque l'application
Web ASP.NET se termine.

Événements Les événements d'application conditionnels sont des événements qui peuvent
d'application être ou non levés lors du traitement d'une demande. Le tableau suivant
conditionnels répertorie quelques-uns des événements d'applications conditionnels les plus
courants :
Nom de l'événement Description

Application_Start Cet événement est levé lorsqu'une


application Web ASP.NET démarre.
Application_End Cet événement est également un
événement à occurrence unique.
Contrairement à l'événement
Application_Start, il est levé lorsqu'une
application Web ASP.NET s'arrête.
Session_Start Cet événement est levé lorsqu'une
session d'un utilisateur est ouverte dans
une application Web ASP.NET.
Session_End Contrairement à l'événement
Session_Start, cet événement est levé
lorsqu'une une session d'un utilisateur est
fermée.
Application_Error Cet événement est déclenché lorsqu'une
erreur non gérée se produit dans une
application Web ASP.NET.
Module 14 : Gestion d'état 13

Leçon : Variables d'application et de session


! Initialisation des variables d'application et de
session
! Utilisation des variables d'application et de
session
! Démonstration : Utilisation des variables de
session
! Durée des variables d'application et de session
! Évolutivité du stockage des variables
d'application et de session
! Enregistrement des variables d'application et de
session dans une base de données

********************Document a l'usage exclusif de l'instructeur********************

Introduction Vous pouvez utiliser des variables d'application et de session pour partager des
informations entre les pages d'une application ASP.NET. Dans cette leçon, vous
apprendrez à initialiser et à utiliser des variables d'application et de session.
Vous étudierez également la spécification de la durée des variables
d'application et de session, ainsi que l'impact de ces dernières sur l'évolutivité
du stockage. Enfin, vous apprendrez à enregistrer des variables d'application et
de session dans une base de données.
Objectifs de la leçon À la fin de cette leçon, vous serez à même d'effectuer les tâches suivantes :
! initialiser des variables d'application et de session ;
! définir et lire des variables d'application et de session ;
! modifier la durée des variables d'application et de session ;
! décrire les méthodes en processus et hors processus utilisées pour stocker
l'état de session ;
! enregistrer des variables d'application et de session dans une base de
données.
14 Module 14 : Gestion d'état

Initialisation des variables d'application et de session


! Les variables sont initialisées dans global.asax
" L'objet Application partage les informations
entre tous les utilisateurs d'une application Web

Sub
Sub Application_Start(s
Application_Start(s As
As Object,e
Object,e As
As EventArgs)
EventArgs)
Application("Nombre_visiteurs")
Application("Nombre_visiteurs") == 00
End
End Sub
Sub

protected
protected void
void Application_Start(Object
Application_Start(Object sender,EventArgs
sender,EventArgs e)
e)
{{
Application["Nombre_visiteurs"] = 0;
Application["Nombre_visiteurs"] = 0;
}}

" L'objet Session enregistre les informations pour


une session utilisateur particulière

********************Document a l'usage exclusif de l'instructeur********************

Introduction Les variables d'application et de session sont initialisées dans les procédures
d'événement Start des objets Application et Session du fichier global.asax.
Variables de session L'objet Session permet de stocker les informations nécessaires à une session
utilisateur spécifique. Les variables stockées dans l'objet Session ne sont pas
ignorées lorsque l'utilisateur se déplace dans les pages de l'application Web.
Elles persistent tout au long de la session utilisateur.
L'exemple de code ci-dessous illustre l'utilisation des variables de session pour
stocker le modèle de couleurs favori d'une session utilisateur donnée.
Visual Basic® .NET Sub Session_Start(ByVal Sender As Object, _
ByVal e As EventArgs)
Session("Couleur_arrière_plan") = "beige"
Session("Couleur_premier_plan") = "noir"
End Sub

C# protected void Session_Start(Object sender, EventArgs e)


{
Session["Couleur_arrière_plan"] = "beige";
Session["Couleur_premier_plan"] = "noir";
}
Module 14 : Gestion d'état 15

Variables d'application L'objet Application permet de partager des informations d'état parmi tous les
utilisateurs d'une application Web. Un objet Application est créé lorsque le
premier utilisateur de l'application Web demande un fichier .aspx. Il est détruit
lorsque tous les utilisateurs ont quitté l'application Web, puis celle-ci est
déchargée.
Par exemple, vous pouvez stocker le nombre total de visiteurs d'un site Web
dans une variable au niveau de l'application :
Visual Basic .NET Sub Application_Start(ByVal Sender As Object, _
ByVal e As EventArgs)
Application("Nombre_visiteurs") = 0
End Sub

C# protected void Application_Start(Object sender, EventArgs e)


{
Application["Nombre_visiteurs"] = 0;
}
16 Module 14 : Gestion d'état

Utilisation des variables d'application et de session


! Définition des variables d'application et de session
Session("Couleur_arrière_plan")
Session("Couleur_arrière_plan") == "bleu"
"bleu"
Application.Lock()
Application.Lock()
Application("Nombre_visiteurs")
Application("Nombre_visiteurs") +=
+= 11
Application.UnLock()
Application.UnLock()

Session["Couleur_arrière_plan"]
Session["Couleur_arrière_plan"] == "bleu";
"bleu";
Application.Lock();
Application.Lock();
Application["Nombre_visiteurs"]
Application["Nombre_visiteurs"] ==
(int)Application["Nombre_visiteurs"]
(int)Application["Nombre_visiteurs"] ++ 1;
1;
Application.UnLock();
Application.UnLock();
! Lecture des variables d'application et de session
strBgColor
strBgColor == Session("Couleur_arrière_plan")
Session("Couleur_arrière_plan")
lblNbVisitor.Text
lblNbVisitor.Text == Application("Nombre_visiteurs")
Application("Nombre_visiteurs")
strBgColor
strBgColor == (string)Session["Couleur_arrière_plan"];
(string)Session["Couleur_arrière_plan"];
lblNbVisitor.Text
lblNbVisitor.Text == Application["Nombre_visiteurs"].ToString();
Application["Nombre_visiteurs"].ToString();

********************Document a l'usage exclusif de l'instructeur********************

Introduction Pour utiliser des variables d'application et de session dans ASP.NET, vous
devez simplement avoir recours à une clé de chaîne et définir une valeur.
Définition des variables Pour définir la variable de session, vous devez fournir une clé qui identifie
d'application et de l'élément que vous stockez, à l'aide d'une instruction :
session
Session("Couleur_arrière_plan") = "bleu"

L'instruction ci-dessus ajoute la clé Couleur_arrière_plan à l'état de session et


lui attribue la valeur bleu.
Étant donné que les variables d'application sont accessibles dans un
environnement multi-utilisateurs, vous devez empêcher plusieurs utilisateurs ou
applications de mettre à jour les données Application simultanément.
ASP.NET contient un ensemble de méthodes de verrouillage simples,
Application.Lock() et Application.UnLock(), qui peut être utilisé pour
autoriser un seul accès à la fois. Le code suivant illustre l'utilisation des
méthodes Application.Lock() et Application.UnLock() :
Visual Basic .NET Application.Lock()
Application("Nombre_visiteurs") += 1
Application.UnLock()

C# Application.Lock();
Application["Nombre_visiteurs"] =
(int)Application["Nombre_visiteurs"] + 1;
Application.UnLock();
Module 14 : Gestion d'état 17

Lecture des variables Pour utiliser une variable de session ou d'application dans une page
d'application et de ASP.NET, vous devez simplement lire la valeur de l'objet Session ou
session Application :
Visual Basic.NET strBgColor = Session("Couleur_arrière_plan")
lblNbVisitor.Text = Application("Nombre_visiteurs")

C# strBgColor = (string)Session["Couleur_arrière_plan"];
lblNbVistitor.Text =
Application["Nombre_visiteurs"].ToString();
18 Module 14 : Gestion d'état

Démonstration : Utilisation des variables de session

! Initialisation d'une variable de session


(un nombre) dans global.asax
! Accès à la variable de session à partir
d'une page
! Accès à la variable de session à partir
d'une autre page et modification
! Nouvel accès à la variable de session
à partir de la première page

********************Document a l'usage exclusif de l'instructeur********************

Introduction Au cours de cette démonstration, vous apprendrez à utiliser des variables de


session.
Le code de cette démonstration figure dans les projets Mod14VB et Mod14CS
de la solution 2333Demos.

! Pour exécuter la démonstration


1. Ouvrez le projet Mod14VB ou Mod14CS de la solution 2333Demos.
2. Ouvrez la page code-behind du fichier global asax.
3. Initialisez une variable de session, appelée intNombre, et affectez-lui la
valeur 3 en ajoutant le code suivant à la procédure d'événement
Session_Start :
Visual Basic .NET Session("intNombre") = 3

C# Session["intNombre"] = 3;

4. Ouvrez les fichiers UsingSessionVar1.aspx et UsingSessionVar2.aspx.


La variable de session est récupérée, puis affichée dans la procédure
d'événement Page_Load.
5. Générez et parcourez la page UsingSessionVar1.
La valeur 3 de la variable de session s'affiche.
6. Cliquez sur Page Suiv.
La page UsingSessionVar2.aspx s'ouvre, incrémente la variable de session
de 4, puis affiche la nouvelle valeur, 7.
7. Cliquez sur Page précédente pour retourner à la page
UsingSessionVar1.aspx, qui affiche la nouvelle valeur de la variable de
session.
Module 14 : Gestion d'état 19

Durée des variables d'application et de session


! Les variables de session ont une durée définie
d'après le dernier accès.
" 20 minutes par défaut
! La durée de la session peut être modifiée dans
Web.config :
<configuration>
<configuration>
<system.web>
<system.web>
<sessionState
<sessionState timeout="10"
timeout="10" />
/>
</system.web>
</system.web>
</configuration>
</configuration>
! Les variables d'application persistent jusqu'au
déclenchement de l'événement Application_End

********************Document a l'usage exclusif de l'instructeur********************

Introduction Le protocole HTTP est un protocole sans état. Un serveur Web ne dispose
d'aucun moyen pour déterminer le moment précis où un utilisateur quitte un site
Web. À défaut, il détecte qu'un certain laps de temps s'est écoulé depuis la
dernière demande d'une page. Il suppose alors que l'utilisateur a quitté le site
Web, et supprime tous les éléments de l'état de session associés à celui-ci.
Durée de session par Par défaut, une session se termine lorsqu'un utilisateur n'a pas demandé de page
défaut au cours des 20 dernières minutes. Si un même utilisateur demande une page
après ce délai, il est considéré en tant que nouvel utilisateur.

Remarque La définition de délais de session plus courts permet à votre site


Web d'économiser des ressources sur votre serveur Web. Si vous estimez que
l'utilisateur restera plus de 20 minutes sur votre site Web, vous devez par contre
définir une durée de session plus longue.

Modification de la durée Vous pouvez modifier la durée de session dans le fichier Web.config. Les
de session fichiers Web.config sont des fichiers XML (Extensible Markup Language)
standard et lisibles, que vous pouvez ouvrir et modifier dans n'importe quel
éditeur de texte. Dans le fichier Web.config suivant, la durée de session est
définie à 10 minutes :
<configuration>
<system.web>
<sessionState timeout="10" />
</system.web>
</configuration>

Variables d'application Les variables d'application persistent jusqu'au déclenchement de l'événement


Application_End. Celui-ci est levé juste avant la fin de toutes les instances
d'application.
20 Module 14 : Gestion d'état

Évolutivité du stockage des variables d'application et de session


! Par défaut, l'état de la session est géré pendant le processus
! Inconvénient du stockage pendant le processus :
" Non évolutif
! ASP.NET fournit un stockage hors processus de l'état de
session
" L'état peut être stocké dans une base de données SQL Server
ou un serveur d'état
! Avantages du stockage hors processus :
Serveur d'état
" Évolutif
Ferme Web

Variables d'application
et de session

- ou -

SQL
Client
Variables d'application et de session
********************Document a l'usage exclusif de l'instructeur********************

Introduction Par défaut, l'état de session est géré en processus. Cela signifie que toutes les
informations ajoutées à l'état de session sont stockées sur le serveur Web qui
exécute l'application ASP.NET. Ce type de stockage en processus présente
plusieurs inconvénients importants.
Inconvénient du L'un des principaux inconvénients liés au stockage de l'état de session en
stockage en processus processus est qu'il limite l'évolutivité de votre site Web. Vous ne pouvez pas
configurer plusieurs serveurs pour gérer des demandes.
Hors processus ASP.NET propose deux méthodes qui permettent de stocker l'état de session
hors processus. Vous pouvez réaliser les opérations suivantes :
! gérer l'état de session à l'aide d'une base de données SQL Server ;
! gérer l'état de session à l'aide d'un serveur d'état distinct.
Vous pouvez utiliser n'importe quel serveur Microsoft Windows® en tant
que serveur d'état.

Pour stocker l'état de session hors processus, vous devez modifier le fichier
Web.config en attribuant la valeur sqlserver ou stateserver au mode
sessionstate, puis en spécifiant l'emplacement du serveur. Les options
sqlserver et stateserver sont presque identiques : la première conserve
toutefois les informations dans SQL Server au lieu de les stocker dans la
mémoire de l'ordinateur.
Module 14 : Gestion d'état 21

Avantage du stockage L'avantage principal lié à la séparation du stockage de l'état de l'application


hors processus Web est que vous pouvez utiliser un serveur d'état externe ou un ordinateur
exécutant SQL pour stocker l'état de session, ce qui rend l'application Web plus
évolutive. Pour que des applications Web ASP.NET soient évolutives, l'état de
session doit être distribué entre plusieurs serveurs qui forment un
environnement batterie de serveurs Web (Web farm). Dans un environnement
batterie de serveurs Web, plusieurs serveurs sont configurés pour gérer les
demandes, ce qui permet le routage dynamique des utilisateurs d'un serveur à
l'autre sans aucune perte des variables d'application et de session. En outre, les
variables de session peuvent être récupérées à partir de n'importe quel serveur
de la batterie de serveurs Web, car elles sont stockées sur un ordinateur
exécutant SQL Serveur distinct ou un serveur d'état.
22 Module 14 : Gestion d'état

Enregistrement des variables d'application et de session dans une


base de données
1!1 Configuration de l'état de la session dans Web.config
" Mode défini sur sqlserver ou stateserver

<sessionState
<sessionState mode="SQLServer"
mode="SQLServer"
sqlConnectionString="data
sqlConnectionString="data source=Nom_SQL_Server;
source=Nom_SQL_Server;
Integrated
Integrated security=true"
security=true" />
/>

2!2 Puis, configuration du serveur SQL

c:\>
c:\> OSQL
OSQL –S
–S Nom_SQL_Server
Nom_SQL_Server –E
–E <InstallSqlState.sql
<InstallSqlState.sql
" OSQL crée plusieurs procédures stockées et bases de
données temporaires pour le stockage des variables

********************Document a l'usage exclusif de l'instructeur********************

Introduction Pour enregistrer des variables d'application et de session dans une base de
données SQL Server ou sur un serveur d'état, vous devez effectuer les deux
tâches suivantes :
1. configurer l'état de session dans le fichier Web.config de votre serveur
Web ;
2. configurer le serveur SQL Server ou le serveur d'état.

Configuration de l'état Dans le fichier Web.config, vous devez modifier les paramètres de
de session dans le configuration en attribuant les valeurs sqlserver ou stateserver au mode
fichier Web.config de sessionstate. Ensuite, vous devez configurer l'attribut sqlconnectionstring de
votre serveur Web telle sorte qu'il identifie le nom de l'ordinateur exécutant SQL Server ou du
serveur d'état.
Le code suivant illustre la définition de l'état de session dans le cas de
l'utilisation du mode sqlserver avec sécurité intégrée :
<sessionState mode="SQLServer"
sqlConnectionString="data source=Nom_SQL_Server;
Integrated security=true" />

Configuration du Pour configurer le serveur SQL Server, vous devez utiliser l'outil de ligne de
serveur SQL Server commande OSQL.exe de SQL Server.
OSQL.exe installe la base de données appelée ASPState, dans laquelle les
variables d'application et de session seront stockées.
Module 14 : Gestion d'état 23

Pour installer la base de données ASPState avec sécurité intégrée, utilisez la


syntaxe suivante :
c:\> OSQL –S Nom_SQL_Server -E <InstallSqlState.sql

Important Les commutateurs de la commande OSQL respectent la casse.

Si vous utilisez un serveur d'état au lieu d'un serveur SQL Server, vous devez
démarrer le service Windows ASP.NET au lieu d'installer une base de données.
24 Module 14 : Gestion d'état

Leçon : Sessions avec et sans cookies

! Utilisation des cookies pour stocker les données


de session
! Application pratique dirigée : Utilisation des
variables et des cookies
! Récupération des informations contenues dans
un cookie
! Utilisation des sessions sans cookie
! Configuration des sessions sans cookie

********************Document a l'usage exclusif de l'instructeur********************

Introduction Les cookies permettent à une application Web qui s'exécute sur un serveur Web
de forcer un client à retourner des informations au serveur Web à chaque
demande HTTP. Ces informations permettent de conserver l'état avec le client
dans plusieurs demandes. Les cookies sont envoyés vers le client dans l'en-tête
HTTP d'une demande du client ou dans une réponse du serveur.
Dans cette leçon, vous apprendrez à utiliser des cookies pour stocker des
données de session, puis à récupérer les données d'un cookie. Vous étudierez
également les sessions sans cookie et leur configuration.
Objectifs de la leçon À la fin de cette leçon, vous serez à même d'effectuer les tâches suivantes :
! utiliser des cookies pour stocker des données de session ;
! récupérer les informations d'un cookie ;
! décrire les sessions sans cookie ;
! configurer une session sans cookie.
Module 14 : Gestion d'état 25

Utilisation des cookies pour stocker les données de session


! Création d'un cookie :
HttpCookie
HttpCookie objCookie
objCookie == new
new HttpCookie("monCookie");
HttpCookie("monCookie");
HttpCookie
DateTime
HttpCookie
DateTime objCookie
nowobjCookie
now == new
new HttpCookie("myCookie");
== DateTime.Now;
DateTime.Now; HttpCookie("myCookie");
DateTime
DateTime now
now == DateTime.Now;
DateTime.Now;
objCookie.Values.Add("Durée",
objCookie.Values.Add("Durée", now.ToString());
now.ToString());
objCookie.Values.Add("Time",
objCookie.Values.Add("Time", now.ToString());
objCookie.Values.Add("Couleur_premier_plan",
now.ToString());"blanc");
objCookie.Values.Add("Couleur_premier_plan", "blanc");
objCookie.Values.Add("ForeColor",
objCookie.Values.Add("ForeColor", "White");
objCookie.Values.Add("Couleur_arrière_plan",
"White"); "bleu");
objCookie.Values.Add("Couleur_arrière_plan", "bleu");
objCookie.Values.Add("BackColor",
objCookie.Values.Add("BackColor", "Blue");
"Blue");
objCookie.Expires
objCookie.Expires == now.AddHours(1);
now.AddHours(1);
Response.Cookies.Add(objCookie);
Response.Cookies.Add(objCookie); Pour créer un
Response.Cookies.Add(objCookie);
Response.Cookies.Add(objCookie); cookie persistant,
spécifiez l'heure
! Un cookie contient des d'expiration

informations sur le nom du domaine


Set-Cookie:
Set-Cookie: Nomutilisateur=Jean+Lebrun;
Nomutilisateur=Jean+Lebrun; path=/;
path=/;
domain=microsoft.com;
domain=microsoft.com;
Expires=mardi
Expires=mardi 01-févr.-05
01-févr.-05 00.00.01
00.00.01 GMT
GMT

********************Document a l'usage exclusif de l'instructeur********************

Introduction Vous pouvez créer des cookies à l'aide de la propriété Cookies de l'objet
Response et de la classe Request. La propriété Cookies est une instance de la
classe HttpCookieCollection et représente une collection de cookies.
Création d'un cookie Le code suivant permet de créer un cookie intitulé monCookie :
Visual Basic .NET Dim objCookie As New HttpCookie("monCookie")
Dim now As DateTime = DateTime.Now

C# HttpCookie objCookie = new HttpCookie("monCookie");


DateTime now = DateTime.Now;

Le code suivant ajoute une paire de clés et leurs valeurs :


Visual Basic .NET objCookie.Values.Add("Durée", now.ToString())
objCookie.Values.Add("Couleur_premier_plan", "blanc")
objCookie.Values.Add("Couleur_arrière_plan", "bleu")

C# objCookie.Values.Add("Durée", now.ToString());
objCookie.Values.Add("Couleur_premier_plan", "blanc");
objCookie.Values.Add("Couleur_arrière_plan", "bleu");

Création d'un cookie Le code suivant permet de définir le délai d'expiration d'un cookie à une
persistant heure :
Visual Basic .NET objCookie.Expires = now.AddHours(1)

C# objCookie.Expires = now.AddHours(1);
26 Module 14 : Gestion d'état

Si vous n'ajoutez pas le code précédent, le cookie que vous créez est
temporaire. Un cookie temporaire est ajouté à la mémoire du navigateur, mais
n'est pas enregistré dans un fichier. Lorsqu'un utilisateur ferme son navigateur,
il est supprimé de la mémoire.
L'ajout du code de délai d'expiration transforme le cookie temporaire en cookie
persistant. Le cookie persistant est enregistré sur le disque dur. Si un utilisateur
ferme son navigateur, puis l'ouvre de nouveau, il peut accéder à la même page
Web jusqu'à l'expiration du cookie persistant. L'expiration du cookie persistant
dépend du délai d'expiration défini dans le code. Dans l'exemple précédent, le
cookie persistant sera supprimé au bout d'une heure.

Remarque Les cookies persistants sont souvent utilisés pour stocker des
informations relatives au nom et à l'ID d'un utilisateur pour que celui-ci soit
identifié par le serveur lors de sa prochaine visite du site Web.

Le code suivant ajoute un nouveau cookie à la collection de cookies de l'objet


Response :
Visual Basic .NET Response.Cookies.Add(objCookie)

C# Response.Cookies.Add(objCookie);

Fonctionnement Supposons que vous souhaitez créer un cookie (Nomutilisateur) qui contient le
d'un cookie nom d'un des visiteurs de votre site Web. Pour le créer, le serveur Web envoie
un en-tête HTTP, comme illustré dans le code suivant :
Set-Cookie: Nomutilisateur=Jean+Lebrun; path=/;
domain=microsoft.com;
Expires=mardi 01-févr.-05 00.00.01 GMT

Dans l'exemple de code précédent, l'en-tête donne au navigateur l'instruction


d'ajouter une entrée à son fichier de cookie. Le navigateur ajoute le cookie
Nomutilisateur avec la valeur Jean Lebrun.
Dans l'exemple de code précédent, l'attribut domain restreint les sites vers
lesquels le navigateur peut envoyer le cookie. Le cookie peut être envoyé
uniquement vers le site Web Microsoft.com. Il ne sera jamais envoyé vers un
autre site Web sur Internet.
Une fois créé par le serveur Web, le cookie est renvoyé par le navigateur dans
chaque demande qu'il effectue au site Web. Le navigateur renvoie le cookie
dans un en-tête qui ressemble à l'exemple suivant :
Cookie: Nomutilisateur: Jean+Lebrun

Les cookies stockés dans un fichier texte sont persistants. Par défaut, le fichier
texte se trouve dans le dossier \Documents and Settings\
nom_utilisateur\Cookies.
Si vous utilisez Internet Explorer, les cookies persistants sont stockés dans un
fichier texte au format suivant :
Nomutilisateur@nomdomaine.txt
Module 14 : Gestion d'état 27

Application pratique dirigée : Utilisation des variables et des


cookies

! Les stagiaires devront :


" Comprendre l'utilisation des
variables d'application et de
session, ainsi que des cookies
persistants, pour stocker les
informations de l'utilisateur
! Durée approximative : 15 minutes

********************Document a l'usage exclusif de l'instructeur********************

Introduction Dans cette application pratique, vous découvrirez comment utiliser des
variables d'application et de session, ainsi que des cookies persistants pour
stocker des informations utilisateur.
Test des fonctionnalités ! Connexion à l'application Web
1. Ouvrez Internet Explorer et naviguez jusqu'à la page suivante :
http://ordinateur_instructeur/Mod14VB/default.aspx ou
http://ordinateur_instructeur/Mod14CS/default.aspx.
2. Tapez votre nom dans la zone de texte, sélectionnez une couleur dans la
zone de liste déroulante, puis cliquez sur Envoyer.
Vous êtes redirigé vers la page results.aspx, qui affiche votre nom, la
couleur choisie et la date et l'heure de votre dernier accès à la page
default.aspx. La page results.aspx affiche également le nombre de visiteurs.
3. Actualisez le navigateur plusieurs fois.
Chaque actualisation entraîne une augmentation du nombre de visiteurs,
mais votre nom et votre couleur restent affichés.
4. Fermez Internet Explorer.
5. Rouvrez Internet Explorer, puis naviguez jusqu'à la page suivante :
http://ordinateur_instructeur/Mod14VB/results.aspx ou
http://ordinateur_instructeur/Mod14CS/results.aspx.
Votre nom apparaît, mais pas la couleur que vous aviez choisie. La date et
l'heure de votre dernier accès à la page default.aspx sont également affichés.
28 Module 14 : Gestion d'état

6. Fermez Internet Explorer.


Pourquoi, selon vous, votre nom a-t-il été mémorisé par le site Web, mais
pas votre couleur ?
____________________________________________________________

____________________________________________________________

Comment la page effectue-t-elle le suivi du nombre de visiteurs ?


____________________________________________________________

____________________________________________________________

! Affichage du code
1. Dans la barre d'adresses de l'Explorateur Windows, tapez les adresses
suivantes :
\\ordinateur_instructeur\c$\inetpub\wwwroot\mod14VB ou
\\ordinateur_instructeur\c$\inetpub\wwwroot\mod14CS
et appuyez sur ENTRÉE.
2. Ouvrez la page code-behind de la page Default.aspx.
Dans la procédure d'événement btnSubmit_Click, quelles sont les deux
actions qui se produisent ?
____________________________________________________________

____________________________________________________________
Module 14 : Gestion d'état 29

3. Dans l'Explorateur Windows, double-cliquez sur results.aspx.vb ou


results.aspx.cs pour ouvrir la page code-behind associée dans
Visual Studio .NET.
Dans la procédure d'événement Page_Load, comment le nombre de
visiteurs de la page est-il stocké ?
____________________________________________________________

____________________________________________________________

Pourquoi le code est-il placé dans une instruction If dans la procédure


d'événement Page_Load ?
____________________________________________________________

____________________________________________________________

4. Fermez Visual Studio .NET.

! Affichage du cookie
1. Dans l'Explorateur Windows, naviguez jusqu'au dossier suivant :
2. C:\Documents and Settings\Student\Cookies
>

Remarque Si vous n'êtes pas connecté en tant que Student, naviguez


jusqu'au dossier Cookies correspondant à votre compte utilisateur.

3. Double-cliquez sur le cookie student@ordinateur_instructeur[n].txt, où n


représente le nombre d'instance.
Quelles informations sont contenues dans ce cookie ?
____________________________________________________________

____________________________________________________________

4. Fermez le Bloc-notes et l'Explorateur Windows.


30 Module 14 : Gestion d'état

Récupération des informations contenues dans un cookie

! Lecture du cookie
Dim
Dim objCookie
objCookie As
As HttpCookie
HttpCookie == Request.Cookies("monCookie")
Request.Cookies("monCookie")

HttpCookie
HttpCookie objCookie
objCookie == Request.Cookies["monCookie"];
Request.Cookies["monCookie"];

! Récupération des valeurs du cookie


lblTime.Text
lblTime.Text == objCookie.Values("Durée")
objCookie.Values("Durée")
lblTime.ForeColor
lblTime.ForeColor == System.Drawing.Color.FromName
System.Drawing.Color.FromName __
(objCookie.Values("Couleur_premier_plan"))
(objCookie.Values("Couleur_premier_plan"))
lblTime.BackColor
lblTime.BackColor == System.Drawing.Color.FromName
System.Drawing.Color.FromName __
(objCookie.Values("Couleur_arrière_plan"))
(objCookie.Values("Couleur_arrière_plan"))

lblTime.Text
lblTime.Text == objCookie.Values["Durée"];
objCookie.Values["Durée"];
lblTime.ForeColor
lblTime.ForeColor == System.Drawing.Color.FromName
System.Drawing.Color.FromName
(objCookie.Values["Couleur_premier_plan"]);
(objCookie.Values["Couleur_premier_plan"]);
lblTime.BackColor
lblTime.BackColor == System.Drawing.Color.FromName
System.Drawing.Color.FromName
(objCookie.Values["Couleur_arrière_plan"]);
(objCookie.Values["Couleur_arrière_plan"]);

********************Document a l'usage exclusif de l'instructeur********************

Introduction La récupération des informations contenues dans un cookie implique la lecture


de celui-ci et la récupération de ses paires clé/valeur.
Lecture d'un cookie Un cookie est renvoyé vers le serveur par le client dans un en-tête HTTP
« Cookie: » Cet en-tête peut contenir plusieurs cookies, séparés par des
points-virgules. Pour lire un cookie existant, vous devez accéder à la collection
de cookies de l'objet Request, comme l'illustre le code suivant :
Visual Basic® .NET Dim objCookie As HttpCookie = Request.Cookies("monCookie")

C# HttpCookie objCookie = Request.Cookies["monCookie"];

Récupération des Le code suivant illustre les valeurs qui doivent être récupérées dans un
valeurs du cookie cookie :
Visual Basic .NET lblTime.Text = objCookie.Values("Durée")
lblTime.ForeColor = System.Drawing.Color.FromName _
(objCookie.Values("Couleur_premier_plan"))
lblTime.BackColor = System.Drawing.Color.FromName _
(objCookie.Values("Couleur_arrière_plan"))

C# lblTime.Text = objCookie.Values["Durée"];
lblTime.ForeColor = System.Drawing.Color.FromName
(objCookie.Values["Couleur_premier_plan"]);
lblTime.BackColor = System.Drawing.Color.FromName
(objCookie.Values["Couleur_arrière_plan"]);
Module 14 : Gestion d'état 31

Utilisation des sessions sans cookie

! Chaque session active est identifiée et suivie à l'aide


d'un ID de session
! Les ID de session sont communiqués aux demandes
client-serveur à l'aide d'un cookie HTTP ou ils sont
inclus dans l'URL
! Sessions sans cookie
" Les informations concernant les ID de session sont
codées dans les URL
http://server/(h44a1e55c0breu552yrecobl)/page.aspx
http://server/(h44a1e55c0breu552yrecobl)/page.aspx
" Les URL absolus ne peuvent pas être utilisés
" La plupart des navigateurs imposent une taille
maximum de 255 caractères aux URL, ce qui limite
l'utilisation des ID de sessions sans cookie

********************Document a l'usage exclusif de l'instructeur********************

Introduction Chaque session active est identifiée et suivie à l'aide d'une SessionID. La
SessionID est communiquée dans des demandes client-serveur à l'aide d'un
cookie HTTP ou dans une URL. Par défaut, la SessionID est stockée dans des
cookies.
Les utilisateurs peuvent toutefois désactiver à l'aide d'une option les cookies
dans leur navigateur. Si un cookie ne peut pas être ajouté dans le navigateur
d'un utilisateur, chaque demande effectuée par ce dernier démarre une nouvelle
session utilisateur. Toutes données de session associées à cet utilisateur sont
alors perdues à chaque nouvelle demande de page.
Sessions sans cookie La structure de page ASP.NET contient une option qui permet d'activer des
sessions sans cookie. Les sessions sans cookie vous permettent de tirer parti des
états de session, même si la prise en charge des cookies est désactivée dans le
navigateur.
Lorsqu'un utilisateur effectue une première demande avec les sessions sans
cookie activées, l'URL utilisée pour la demande contient automatiquement la
SessionID de l'utilisateur. Par exemple, lorsque l'utilisateur demande la page
http://server/page.aspx, la demande est automatiquement remplacée par l'URL
suivante :
http://server/(h44a1e55c0breu552yrecobl)/page.aspx

La partie de l'URL qui figure entre parenthèses correspond à la SessionID de


l'utilisateur actuel.
Une fois la SessionID incorporée dans l'URL de la première demande de page,
elle suit l'utilisateur tout au long de sa visite du site Web.
32 Module 14 : Gestion d'état

Limites liées à L'utilisation des sessions sans cookie présente les limites suivantes :
l'utilisation des sessions
sans cookie ! Si vous choisissez d'utiliser des sessions sans cookie, vous ne pouvez pas
utiliser des URL absolues pour lier les pages entre elles. Vous devez
concevoir votre site Web de telle sorte que chaque lien utilise une URL
relative à la page en cours.
! La plupart des navigateurs limitent la taille d'une URL à 255 caractères.
Module 14 : Gestion d'état 33

Configuration des sessions sans cookie

! L'état de la session est configuré dans la section


<SessionState> de Web.config
! Set cookieless = true

<sessionState
<sessionState cookieless="true"
cookieless="true" />
/>

********************Document a l'usage exclusif de l'instructeur********************

Introduction Pour activer les sessions sans cookie, vous devez simplement modifier un
attribut unique dans le fichier Web.config.
Configuration d'une La seule opération nécessaire à l'activation des sessions sans cookie est
session sans cookie l'attribution de la valeur true à l'attribut cookieless dans la section
<sessionstate> du fichier Web.config, comme l'illustre le code suivant :
<sessionState cookieless="true"/>
34 Module 14 : Gestion d'état

Contrôle des acquis

! Gestion d'état
! Variables d'application et de session
! Sessions avec et sans cookies

********************Document a l'usage exclusif de l'instructeur********************

1. Comment activez-vous les sessions sans cookie dans une application Web ?

2. Quelles sont les trois catégories d'événements qui sont gérées par le fichier
global.asax ?

3. Quel est l'emplacement du fichier global.asax d'une application ?

4. Une application Web peut-elle posséder plusieurs fichiers global.asax ?


Module 14 : Gestion d'état 35

5. Quelles sont les deux étapes que vous devez effectuer dans ASP.NET pour
utiliser des variables de session dans une batterie de serveurs Web ?

6. Quelle est la différence entre un cookie temporaire et un cookie persistant ?

7. Quel élément utilisez-vous pour conserver la SessionID d'une variable de


session ?
36 Module 14 : Gestion d'état

Atelier 14 : Stockage de données d'application et de


session
Page
Page de
de
connexion
connexion
Login.aspx
Login.aspx Page
Page
d'accueil
d'accueil En-tête
En-tête de
de
Coho
Winery
Avantages
Avantages page
page ASPState
Default.aspx
Default.aspx Header.ascx
Header.ascx
Composant
Composant
Inscription
Inscription du
du menu
menu
Register.aspx
Register.aspx Class1.vb
Class1.vbou
ou Class1.cs
Class1.cs Web.
config tempdb

Plans
Plans de
de Assurance
Assurance Soins
Soins
Assurance
Assurance vie
vie
Life.aspx
Life.aspx
retraite
retraite maladie
maladie dentaires
dentaires
Retirement.aspx
Retirement.aspx Medical.aspx
Medical.aspx Dental.aspx
Dental.aspx

Application Contrôle
Contrôle Service
Service
Prospectus
Prospectus Médecins
Médecins
Web de Prospectus.aspx
Prospectus.aspx Doctors.aspx
Doctors.aspx
utilisateur
utilisateur Web
Web XML
XML
l'atelier namedate.ascx
namedate.ascx dentalService1.asmx
dentalService1.asmx

Fichiers
XML Doctors Dentists

********************Document a l'usage exclusif de l'instructeur********************

Objectifs À la fin de cet atelier, vous serez à même d'effectuer les tâches suivantes :
! créer des variables d'application et de session, puis les utiliser pour stocker
et récupérer des informations ;
! créer, lire et écrire des informations à partir de cookies persistants ;
! stocker des variables de session dans une base de données Microsoft® SQL
Server™.

Remarque Cet atelier étant axé sur les concepts de ce module, il ne respecte
pas les recommandations Microsoft relatives à la sécurité.

Conditions préalables Pour aborder cet atelier, vous devez disposer de connaissances élémentaires
dans les domaines suivants :
! Création de variables d'application et de session
! Création de cookies

Scénario Coho Winery offre de nombreux avantages à ses employés. Dans les ateliers du
cours 2333A, Développement d'applications Web Microsoft ASP.NET à l'aide
de Visual Studio .NET, vous créerez un site Web qui permettra aux employés de
sélectionner et de définir les avantages qu'ils auront choisis.
Dans cet atelier, vous utiliserez des variables d'application et de session pour
améliorer la navigation dans le site Web Benefits.
Durée approximative de
cet atelier :
90 minutes
Module 14 : Gestion d'état 37

Exercice 0
Mise en place de l'atelier
Pour réaliser cet atelier, vous devez avoir créé un projet d'application Web
intitulé Benefits et un projet de bibliothèque de classes intitulé BenefitsList. Ces
projets peuvent être créés à l'aide de Microsoft Visual Basic® .NET ou de
Microsoft Visual C#™ .NET.
Si vous ne les avez pas encore créés, procédez comme suit :

! Création de la solution ApplicationAtelier2333


Important Effectuez cette procédure uniquement si vous n'avez pas encore créé
le fichier de solution ApplicationAtelier2333.

• À l'aide de Microsoft Visual Studio® .NET, créez une solution nommée


ApplicationAtelier2333 :
a. Dans le menu Fichier, pointez sur Nouveau, puis cliquez sur Nouvelle
solution.
b. Dans la boîte de dialogue Nouveau projet, tapez
ApplicationAtelier2333 dans la zone de texte Nom, puis cliquez sur
OK.

! Création du projet Benefits


Important Effectuez cette procédure uniquement si vous n'avez pas encore créé
le projet Benefits ou si vous avez supprimé ce projet conformément aux
instructions de l'annexe A, « Récupération d'un atelier », du cours 2333A,
Développement d'applications Web Microsoft ASP.NET à l'aide de Visual
Studio .NET.

• Créez un projet d'application Web ASP.NET que vous nommerez


BenefitsVB ou BenefitsCS dans la solution ApplicationAtelier2333 :
a. Dans le menu Fichier, pointez sur Nouveau, puis cliquez sur Projet.
b. Dans la boîte de dialogue Nouveau projet, cliquez sur Projets
Visual Basic ou sur Projets Visual C# dans la liste Types de projets.
c. Dans la liste Modèles, cliquez sur Application Web ASP.NET.
Définissez l'Emplacement à http://localhost/BenefitsVB pour le projet
Visual Basic .NET ou à http://localhost/BenefitsCS pour le projet
Visual C#™.
d. Cliquez sur Ajouter à la solution, puis sur OK.

Attention Lorsque vous ajoutez un projet à une solution, il est important de


respecter les majuscules. Il se peut que vous utilisiez certains formulaires
Web prédéfinis dans cet atelier ou dans d'autres ateliers du cours 2333A,
Développement d'applications Web Microsoft ASP.NET à l'aide de Visual
Studio .NET. Par conséquent, vérifiez que le projet Benefits est orthographié
avec une majuscule, comme indiqué.
38 Module 14 : Gestion d'état

! Mise à jour du projet Benefits


1. Dans Visual Studio .NET, ouvrez le fichier de solution
ApplicationAtelier2333.
2. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur
BenefitsVB ou sur BenefitsCS, pointez sur Ajouter, puis cliquez sur
Ajouter un élément existant.
3. Naviguez jusqu'aux fichiers du projet.
Pour le projet Visual Naviguez jusqu'au dossier
Basic .NET dossier_installation\Labfiles\Lab14\VB\Starter\BenefitsVB.
Pour le projet Visual C# Naviguez jusqu'au dossier
dossier_installation\Labfiles\Lab14\CS\Starter\BenefitsCS.
4. Dans la zone Types de fichiers de la boîte de dialogue Ajouter un élément
existant – Benefits, cliquez sur Tous les fichiers (*.*).
5. Sélectionnez tous les fichiers du dossier, puis cliquez sur Ouvrir.
6. Cliquez sur Oui si vous êtes invité à remplacer ou recharger les fichiers.

! Création de la bibliothèque de classes BenefitsList


Important Effectuez uniquement cette procédure si vous n'avez pas encore créé
le projet BenefitsList ou si vous avez supprimé ce projet conformément aux
instructions de l'annexe A, « Récupération d'un atelier », du cours 2333A,
Développement d'applications Web Microsoft ASP.NET à l'aide de Visual
Studio .NET.

• Créez un projet de bibliothèque de classes.


Pour le projet Visual Créez un projet de bibliothèque de classes Visual Basic .NET, nommez-le
Basic .NET BenefitsListVB, puis ajoutez-le à la solution ApplicationAtelier2333 :
a. Dans le menu Fichier, pointez sur Nouveau, puis cliquez sur Projet.
b. Dans la boîte de dialogue Nouveau projet, cliquez sur Projets
Visual Basic dans la liste Types de projets.
c. Dans la liste Modèles, cliquez sur Bibliothèque de classes, puis tapez
BenefitsListVB dans le champ Nom.
d. Cliquez sur Ajouter à la solution, puis sur OK.
Pour le projet Visual C# Créez un projet de bibliothèque de classes Visual C# .NET, nommez-le
BenefitsListCS, puis ajoutez-le à la solution ApplicationAtelier2333 :
a. Dans le menu Fichier, pointez sur Nouveau, puis cliquez sur Projet.
b. Dans la boîte de dialogue Nouveau projet, cliquez sur Projets
Visual C# dans la liste Types de projets.
c. Dans la liste Modèles, cliquez sur Bibliothèque de classes, puis tapez
BenefitsListCS dans le champ Nom.
d. Cliquez sur Ajouter à la solution, puis sur OK.

Attention Vérifiez que avez mis le projet en majuscules (BenefitsList).


Module 14 : Gestion d'état 39

! Mise à jour du projet BenefitsList


1. Dans Visual Studio .NET, ouvrez le fichier de solution
ApplicationAtelier2333.
2. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur
BenefitsListVB ou sur BenefitsListCS, pointez sur Ajouter, puis cliquez
sur Ajouter un élément existant.
3. Naviguez jusqu'aux fichiers du projet :
Pour le projet Visual Naviguez jusqu'au dossier
Basic .NET dossier_installation\Labfiles\Lab14\VB\Starter\BenefitsListVB.
Pour le projet Visual C# Naviguez jusqu'au dossier
dossier_installation\Labfiles\Lab14\CS\Starter\BenefitsListCS.
4. Dans la zone Types de fichiers de la boîte de dialogue Ajouter un élément
existant – BenefitsList, cliquez sur Tous les fichiers (*.*).
5. Sélectionnez tous les fichiers du dossier, puis cliquez sur Ouvrir.
6. Cliquez sur Oui si vous êtes invité à remplacer ou recharger les fichiers.

! Création d'une référence au composant BenefitsList dans le projet


Benefits
• Dans le projet Benefits de la solution ApplicationAtelier2333, effectuez les
étapes suivantes pour ajouter une référence au composant BenefitsList que
vous venez de créer :
a. Cliquez avec le bouton droit sur le projet BenefitsVB ou BenefitsCS
dans l'Explorateur de solutions, puis cliquez sur Ajouter une référence.
b. Dans la boîte de dialogue Ajouter une référence, sous l'onglet Projets,
double-cliquez sur le projet BenefitsListVB ou BenefitsListCS.
c. Cliquez sur le composant BenefitsListVB ou BenefitsListCS dans la
liste Composants sélectionnés, puis sur OK.
Le composant est ajouté au dossier References dans l'Explorateur de
solutions.
40 Module 14 : Gestion d'état

! Création du service Web XML ServiceDentaire


Important Effectuez cette procédure uniquement si vous n'avez pas encore créé
le projet ServiceDentaire ou si vous avez supprimé ce projet conformément aux
instructions de l'annexe A, « Récupération d'un atelier », du cours 2333A,
Développement d'applications Web Microsoft ASP.NET à l'aide de Visual
Studio .NET.

• Créez un projet de service Web XML.


Pour le projet Visual Créez un projet de service Web XML Visual Basic .NET, appelez-le
Basic .NET ServiceDentaireVB, puis ajoutez-le à la solution ApplicationAtelier2333 :
a. Dans le menu Fichier, pointez sur Nouveau, puis cliquez sur Projet.
b. Dans la boîte de dialogue Nouveau projet, cliquez sur Projets
Visual Basic dans la liste Types de projets.
c. Dans la liste Modèles, cliquez sur Service Web ASP.NET, puis
définissez l'Emplacement à http://localhost/ServiceDentaireVB.
d. Cliquez sur Ajouter à la solution, puis sur OK.

Attention Vérifiez que vous avez mis le projet en majuscules


(ServiceDentaireVB).

Pour le projet Créez un projet de service Web XML Visual C# .NET, appelez-le
Visual C# .NET ServiceDentaireCS, puis ajoutez-le à la solution ApplicationAtelier2333 :
a. Dans le menu Fichier, pointez sur Nouveau, puis cliquez sur Projet.
b. Dans la boîte de dialogue Nouveau projet, cliquez sur Projets
Visual C# dans la liste de Types de projets.
c. Dans la liste Modèles, cliquez sur Service Web ASP.NET, puis
définissez l'Emplacement à http://localhost/ServiceDentaireCS.
d. Cliquez sur Ajouter à la solution, puis sur OK.

Attention Vérifiez que vous avez mis le projet en majuscules


(ServiceDentaireCS).

! Mise à jour du projet ServiceDentaire


1. Dans Visual Studio .NET, ouvrez le fichier de solution
ApplicationAtelier2333.
2. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur
ServiceDentaireVB ou ServiceDentaireCS, pointez sur Ajouter, puis
cliquez sur Ajouter un élément existant.
3. Naviguez jusqu'aux fichiers du projet :
Pour le projet en Naviguez jusqu'au dossier
Visual Basic .NET dossier_installation\Labfiles\Lab14\VB\Starter\ServiceDentaireVB.
Microsoft Visual C#™ Naviguez jusqu'au dossier
.NET dossier_installation\Labfiles\Lab14\VB\Starter\ServiceDentaireCS.
4. Dans la zone Types de fichiers de la boîte de dialogue Ajouter un élément
existant – ServiceDentaire, cliquez sur Tous les fichiers (*.*).
Module 14 : Gestion d'état 41

5. Sélectionnez tous les fichiers du dossier, puis cliquez sur Ouvrir.


6. Cliquez sur Oui si vous êtes invité à remplacer ou recharger les fichiers.
7. Générez le service Web XML ServiceDentaire. Pour ce faire, cliquez avec
le bouton droit sur le projet ServiceDentaireVB ou ServiceDentaireCS
dans l'Explorateur de solutions, puis cliquez sur Générer.

! Ajout d'une référence Web au service Web ServiceDentaire dans le


projet Benefits
1. Dans le projet Benefits de la solution ApplicationAtelier2333, effectuez les
étapes suivantes pour ajouter une référence Web au service Web XML
ServiceDentaire :
a. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur
BenefitsVB ou BenefitsCS, puis cliquez sur Ajouter une référence
Web.
b. Dans la zone de texte Adresse, tapez
http://localhost/ServiceDentaireVB/DentalService1.asmx ou
http://localhost/ServiceDentaireCS/DentalService1.asmx, puis
appuyez sur ENTRÉE.
La référence Web ServiceDentaire1 s'affiché.
c. Cliquez sur Ajouter la référence.
La référence Web est ajoutée dans le dossier Web References du projet.
2. Dans l'Explorateur de solutions, développez le dossier Web References,
cliquez avec le bouton droit sur localhost, puis cliquez sur Renommer.
3. Tapez RéfWebDentaire, puis appuyez sur ENTRÉE.
4. Générez la solution en cliquant sur Générer la solution dans le menu
Générer.
42 Module 14 : Gestion d'état

Exercice 1
Utilisation de variables de session
Dans cet exercice, vous stockerez le nom et la date de naissance de l'utilisateur
dans des variables de session. Le contrôle utilisateur namedate.ascx et la page
life.aspx utiliseront les informations de ces variables de session, si elles
existent, pour remplir les zones de texte appropriées. Si les variables de session
n'existent pas encore, elles seront créées par l'une des deux pages.
Scénario Dans l'application Web actuelle, l'utilisateur doit entrer les mêmes informations
dans plusieurs pages. Par exemple, il doit indiquer son nom et sa date de
naissance dans les pages soins médicaux et assurance vie. Pour simplifier
l'utilisation de cette application Web, vous utiliserez un cookie pour stocker ces
informations dans des variables de session afin que l'utilisateur n'ait pas à les
entrer plusieurs fois.

! Obtention et définition des variables de session dans la page life.aspx


1. Dans Visual Studio .NET, ouvrez la page code-behind de la page life.aspx
du projet Benefits.
2. Dans la procédure d'événement Page_Load, ajoutez du code pour obtenir
les variables de session Nom et Date de naissance, mais uniquement
lorsque la page n'est pas republiée.
3. Définissez le contenu de la variable de session Nom comme propriété Text
de la zone de texte txtName, et celui de la variable de session Date de
naissance comme propriété Text de la zone de texte txtBirth.
4. Votre code doit ressembler à ce qui suit :
Visual Basic .NET If Not (Page.IsPostBack) Then
Dim strName As String = CStr(Session("Nom"))
Dim strBirth As String = CStr(Session("Date de
naissance"))
txtName.Text = strName
txtBirth.Text = strBirth
End If

Visual C# if (!Page.IsPostBack)
{
string strName = (string)Session["Nom"];
string strBirth = (string)Session["Date de naissance"];
txtName.Text = strName;
txtBirth.Text = strBirth;
}
Module 14 : Gestion d'état 43

5. Dans la procédure d'événement cmdSave_Click, recherchez le commentaire


suivant :
Visual Basic .NET 'TODO Atelier 14 : Définir des variables de session

Visual C# //TODO Atelier 14 : Définir des variables de session

Remarque Si cette section de code ne figure pas dans votre fichier


life.aspx, vous pouvez la copier dans le fichier life.aspx qui se trouve dans
le dossier dossier_installation\Labfiles\Lab14\VB\Starter\BenefitsVB ou
dossier_installation\Labfiles\Lab14\VB\Starter\BenefitsCS.

6. En dessous de ce commentaire, ajoutez du code qui attribue le texte de la


zone de texte txtName à la variable de session Nom et le texte de la zone de
texte txtBirth, à la variable de session Date de naissance.
7. Votre code doit ressembler à ce qui suit :
Visual Basic .NET Session("Nom") = txtName.Text
Session("Date de naissance") = txtBirth.Text

Visual C# Session["Nom"] = txtName.Text;


Session["Date de naissance"] = txtBirth.Text;

! Obtention et définition des variables de session dans la page


code-behind de la page namedate.ascx
1. Ouvrez le fichier namedate.ascx.vb ou namedate.ascx.cs.
Il s'agit du contrôle utilisateur du formulaire Web medical.aspx qui affiche
le nom et la date de naissance de l'utilisateur.
2. Dans la procédure d'événement Page_Load, ajoutez du code pour récupérer
les variables de session Nom et Date de naissance, mais uniquement
lorsque la page n'est pas republiée.
3. Définissez le contenu de la variable de session Nom comme propriété Text
de la zone de texte txtName et celui de la variable de session Date de
naissance, comme propriété Text de la zone de texte txtBirth.
4. Votre code doit ressembler à ce qui suit :
Visual Basic .NET If Not (Page.IsPostBack) Then
Dim strName As String = CStr(Session("Nom"))
Dim strBirth As String = CStr(Session("Date de
naissance"))
txtName.Text = strName
txtBirth.Text = strBirth
End If

Visual C# if (!Page.IsPostBack)
{
string strName = (string)Session["Nom"];
string strBirth = (string)Session["Date de naissance"];
txtName.Text = strName;
txtBirth.Text = strBirth;
}
44 Module 14 : Gestion d'état

5. Dans l'instruction Get de la propriété publique strName, ajoutez une ligne


de code avant l'instruction Return pour attribuer à la variable de session
Nom le texte de la zone de texte txtName.
L'instruction Get doit ressembler à ce qui suit :
Visual Basic .NET Get
Session("Nom") = txtName.Text
Return txtName.Text
End Get

Visual C# get
{
Session["Nom"] = txtName.Text;
return txtName.Text;
}

6. Dans l'instruction Get de la propriété publique dtDate, ajoutez une ligne de


code avant l'instruction Return pour attribuer à la variable de session Date
de naissance le texte de la zone de texte txtBirth.
L'instruction Get doit ressembler à ce qui suit :
Visual Basic .NET Get
Session("Date de naissance") = txtBirth.Text
Return CDate(txtBirth.Text)
End Get

Visual C# get
{
Session["Date de naissance"] = txtBirth.Text;
return Convert.ToDateTime(txtBirth.Text);
}

! Test du code
1. Générez et parcourez la page life.aspx.
2. Dans le navigateur, tapez votre nom dans la zone de texte Nom, votre date
de naissance dans la zone de texte Date de naissance, puis 400 dans la zone
de texte Couverture.
3. Cliquez sur Enregistrer.
4. Cliquez sur le lien Médical situé en haut du formulaire Web life.aspx.
Votre nom et votre date de naissance apparaissent dans le formulaire Web
medical.aspx. Ces valeurs ont été obtenues à partir des variables de session.
5. Modifiez votre nom dans la zone de texte Nom, puis cliquez sur
Enregistrer.
6. Cliquez sur le lien Assurance vie et vérifiez que votre nom a été modifié
dans le formulaire Web life.aspx.
Module 14 : Gestion d'état 45

Exercice 2
Utilisation des cookies
Dans cet exercice, vous utiliserez des cookies pour stocker tous les avantages
sélectionnés par l'utilisateur. Lorsque l'utilisateur retournera dans la page
default.aspx, celle-ci affichera ses sélections.
Scénario Avant de terminer le processus d'inscription des avantages, l'utilisateur doit
pouvoir afficher ses sélections dans une seule page. Vous avez choisi de
répertorier les avantages sélectionnés dans la page default.aspx. Pour ce faire,
vous utiliserez un cookie persistant.
Pour les pages medical.aspx et life.aspx, vous ajouterez du code qui permet de
lire les valeurs du cookie, de les mettre à jour et de réécrire le cookie.

! Configuration de la page d'accueil


1. Ouvrez la page default.aspx.
2. Ajoutez deux étiquettes et deux contrôles de zone de texte en bas du
formulaire Web de sorte qu'il ressemble à l'illustration ci-après.
46 Module 14 : Gestion d'état

3. Appelez la première zone de texte txtDoctor et la deuxième, txtLife.


4. Ouvrez la page default.aspx.vb ou default.aspx.cs.
5. Dans la procédure d'événement Page_Load, ajoutez le code nécessaire pour
lire les informations contenues dans un cookie appelé Benefits. Insérez-le
juste après la condition Page.IsPostBack.
6. Déclarez deux variables, strDoc et strLife, qui contiendront les valeurs
médecins et vie du cookie Benefits.
7. Si le cookie existe et qu'il n'est pas vide, définissez strDoc comme propriété
Text de la zone de texte txtDoctor, et strLife comme propriété Text de la
zone de texte txtLife.
Votre code doit ressembler à ce qui suit :
Visual Basic .NET Dim objGetCookie As HttpCookie = _
Request.Cookies("Benefits")
Dim strDoc As String
Dim strLife As String

If Not objGetCookie Is Nothing Then


strDoc = objGetCookie.Values("médecin")
strLife = objGetCookie.Values("vie")
txtDoctor.Text = strDoc
txtLife.Text = strLife
End If

Visual C# HttpCookie objGetCookie =


Request.Cookies["Benefits"];
string strDoc;
string strLife;

if (objGetCookie != null)
{
strDoc = objGetCookie.Values["médecin"];
strLife = objGetCookie.Values["vie"];
txtDoctor.Text = strDoc;
txtLife.Text = strLife;
}

8. Enregistrez le fichier default.aspx.


Module 14 : Gestion d'état 47

! Stockage du médecin sélectionné


1. Ouvrez la page medical.aspx.vb ou medical.aspx.cs.
2. Dans la procédure d'événement cmdSave_Click, ajoutez le code nécessaire
à la récupération des informations contenues dans le cookie Benefits, mais
seulement si celui-ci existe et n'est pas vide.
Ce code ajouté doit comporter deux variables de chaînes qui contiennent les
valeurs médecin et assurance vie stockées dans le cookie. Votre code doit
ressembler à ce qui suit :
Visual Basic .NET Dim objCookie As HttpCookie = Request.Cookies("Benefits")
Dim strDoc As String
Dim strLife As String

If Not objCookie Is Nothing Then


strDoc = objCookie.Values("médecin")
strLife = objCookie.Values("vie")
End If

Visual C# HttpCookie objGetCookie = Request.Cookies["Benefits"];


string strDoc ="";
string strLife ="";

if (objGetCookie != null)
{
strDoc = objGetCookie.Values["médecin"];
strLife = objGetCookie.Values["vie"];
}

3. Ajoutez le code pour effectuer les tâches suivantes :


a. Mettre à jour la valeur de la variable strDoc selon le contenu de la zone
de texte txtDoctor.
b. Créer un objet de cookie, objNouveauCookie, portant le nom Benefits.
Cette tâche permet de remplacer le cookie Benefits par un nouveau
cookie qui contient des informations mises à jour.
c. Définir la date d'expiration du cookie Benefits à 30 jours à compter de la
date d'aujourd'hui.
d. Ajouter deux valeurs, médecin et vie, au cookie. Ces valeurs
contiendront respectivement strDoc et strLife.
e. Écrire le cookie objNewCookie.
48 Module 14 : Gestion d'état

Votre code doit ressembler à ce qui suit :


Visual Basic .NET strDoc = txtDoctor.Text
Dim objNewCookie As New HttpCookie("Benefits")
objNewCookie.Expires = DateTime.Now.AddDays(30)
objNewCookie.Values.Add("médecin", strDoc)
objNewCookie.Values.Add("vie", strLife)
Response.Cookies.Add(objNewCookie)

Visual C# strDoc = txtDoctor.Text;


HttpCookie objNewCookie = new HttpCookie("Benefits");
objNewCookie.Expires = DateTime.Now.AddDays(30);
objNewCookie.Values.Add("médecin", strDoc);
objNewCookie.Values.Add("vie", strLife);
Response.Cookies.Add(objNewCookie);

4. Enfin, vous devez ajouter dans la procédure d'événement cmdSave_Click le


code qui redirxige l'utilisateur vers la page default.aspx. Votre code doit
ressembler à ce qui suit :
Visual Basic .NET Response.Redirect("default.aspx")

Visual C# Response.Redirect("default.aspx");

5. Enregistrez le fichier medical.aspx.vb ou medical.aspx.cs.

! Stockage des assurances vie sélectionnées


1. Ouvrez le fichier life.aspx.vb ou life.aspx.cs.
2. Dans la procédure d'événement cmdSave_Click, ajoutez le code nécessaire
à la récupération des informations contenues dans le cookie Benefits, mais
seulement si celui-ci existe et n'est pas vide.
Ce code est identique à celui que vous avez ajouté dans la page
medical.aspx.
3. Recherchez la ligne de code suivante :
Visual Basic .NET 'TODO Atelier 14 : Générez la chaîne

Visual C# //TODO Atelier 14 : Générez la chaîne

Remarque Si cette section de code ne figure pas dans votre fichier


life.aspx, vous pouvez la copier dans le fichier life.aspx qui se trouve dans
le dossier dossier_installation\Labfiles\Lab14\VB\Starter\BenefitsVB ou
dossier_installation\Labfiles\Lab14\VB\Starter\BenefitsCS.
Module 14 : Gestion d'état 49

4. Supprimez la mise en commentaire du code en dessous de ce commentaire.


Ce code génère une chaîne qui comprend les options d'assurance vie
sélectionnées et la valeur entrée en tant que montant couvert.
5. Ajoutez du code pour créer et écrire dans le cookie Benefits.
Ce code est identique à celui que vous avez ajouté dans la page
medical.aspx.
6. Ajoutez du code pour rediriger la page vers la page default.aspx.
7. Lorsque vous aurez terminé, votre procédure d'événement cmdSave_Click
doit ressembler à ce qui suit :
Visual Basic .NET If Page.IsValid Then
lblMessage.Text = "Valide !"

'TODO Atelier 14 : Définir les variables de session


Session("Nom") = txtNom.Text
Session("Date de naissance") = txtBirth.Text

Dim objCookie As HttpCookie = _


Request.Cookies("Benefits")
Dim strDoc As String
Dim strLife As String

If Not objCookie Is Nothing Then


strDoc = objCookie.Values("médecin")
strLife = objCookie.Values("vie")
End If

If (chkShortTerm.Checked) Then
If (chkLongTerm.Checked) Then
strLife = "Court terme et long terme"
Else
strLife = "Court terme"
End If
ElseIf (chkLongTerm.Checked) Then
strLife = "Long terme"
End If
strLife &= ": Coverage = $" & txtCoverage.Text

Dim objNewCookie As New HttpCookie("Benefits")


objNewCookie.Expires = DateTime.Now.AddDays(30)
objNewCookie.Values.Add("médecin", strDoc)
objNewCookie.Values.Add("vie", strLife)
Response.Cookies.Add(objNewCookie)
Response.Redirect("default.aspx")

End If

Remarque Vous pouvez copier et coller ce code à partir du fichier


dossier_installation\Labfiles\Lab14\VB\Starter\life.txt.
50 Module 14 : Gestion d'état

Visual C# if (Page.IsValid)
{
lblMessage.Text = "Valide !";

TODO Atelier 14 : Définir les variables de session


Session["Nom"] = txtNom.Text;
Session["Date de naissance"] = txtBirth.Text;

HttpCookie objCookie =
Request.Cookies["Benefits"];
string strDoc ="";
string strLife ="";

if (objCookie != null)
{
strDoc = objCookie.Values["médecin"];
strLife = objCookie.Values["vie"];
}

if (chkShortTerm.Checked)
{
if (chkLongTerm.Checked)
{
strLife = "Court terme et long terme";
}
else
{
strLife = "Court terme";
}
}
else if (chkLongTerm.Checked)
{
strLife = "Long terme";
}

strLife += ": Coverage = $" + txtCoverage.Text;

HttpCookie objNewCookie = new HttpCookie("Benefits");


objNewCookie.Expires = DateTime.Now.AddDays(30);
objNewCookie.Values.Add("médecin", strDoc);
objNewCookie.Values.Add("vie", strLife);
Response.Cookies.Add(objNewCookie);
Response.Redirect("default.aspx");
}

Remarque Vous pouvez copier et coller ce code à partir du fichier


dossier_installation\Labfiles\Lab14\CS\Starter\life.txt.

8. Enregistrez le fichier default.aspx.vb ou default.aspx.cs.


Module 14 : Gestion d'état 51

! Test du cookie
1. Générez et parcourez default.aspx.
2. Cliquez sur le lien Médical.
3. Fournissez les informations requises, puis cliquez sur Enregistrer.
4. Vous êtes redirigé vers la page default.aspx, et les informations relatives à
votre médecin sont affichées.
5. Cliquez sur le lien Assurance vie.
6. Fournissez les informations requises, sélectionnez la couverture à court
terme, à long terme ou les deux, puis cliquez sur Enregistrer.
7. Vous êtes redirigé vers la page default.aspx, et les informations relatives à
votre assurance vie sont affichées.
52 Module 14 : Gestion d'état

Exercice 3
Utilisation des variables d'application
Dans cet exercice, vous ajouterez un compteur de page à la page
retirement.aspx.
Scénario Vous souhaitez offrir à la direction un moyen simple et rapide de déterminer le
nombre d'employés qui se connectent au site Web Benefits. Pour cette raison,
vous avez décidé d'implémenter un compteur de page sur la page default.aspx à
l'aide d'une variable d'application. Vous souhaitez vous assurer que le compteur
comptabilise seulement les visites uniques et non les publications de pages.

! Ajout des composants d'interface utilisateur (UI)


1. Ouvrez la page retirement.aspx.
2. Ajoutez deux étiquettes et une zone de texte en bas du formulaire Web de
sorte qu'il ressemble à l'illustration ci-après.

3. Attribuez à la nouvelle zone de texte le nom txtVisits.


Module 14 : Gestion d'état 53

! Ajout du code
1. Dans la procédure d'événement Page_Load, ajoutez le code qui permet
d'incrémenter de 1 la valeur de la variable d'application Visites.
2. Le code doit verrouiller la variable d'application avant de l'incrémenter, puis
la déverrouiller. Placez le code de telle sorte qu'il s'exécute uniquement
lorsque la page n'est pas republiée.
3. Ajoutez du code pour attribuer à la propriété Text de la zone de texte
txtVisits la valeur stockée dans la variable d'application Visites. Ce code
doit s'exécuter à chaque chargement de la page.
4. Une fois ces modifications apportées, la procédure d'événement Page_Load
doit ressembler à ce qui suit :
Visual Basic .NET If Not Page.IsPostBack Then
Dim dsRetirement As New DataSet()
dsRetirement.ReadXml( _
Server.MapPath("mutual_funds.xml"))
dgRetirement.DataSource = dsRetirement
dgRetirement.DataBind()

Application.Lock()
Application("Visites") = CInt(Application("Visites")) + 1
Application.UnLock()
End If

txtVisits.Text = CStr(Application("Visites"))

Visual C# if (!Page.IsPostBack)
{
DataSet dsRetirement = new DataSet();
dsRetirement.ReadXml(
Server.MapPath["mutual_funds.xml"]);
dgRetirement.DataSource = dsRetirement;
dgRetirement.DataBind();

Application.Lock();
Application["Visites"]
=Convert.ToInt16(Application["Visites"]) + 1;
Application.UnLock();
}

txtVisits.Text = Application["Visites"].ToString();

! Test de la variable d'application


1. Générez et parcourez la page retirement.aspx.
2. Actualisez le navigateur.
3. Le compteur de page augmente à chaque actualisation de la page.
54 Module 14 : Gestion d'état

Exercice 4
Stockage de variables de session dans une base de données
Dans cet exercice, vous stockerez les variables de session qui contiennent le
nom et la date de naissance de l'utilisateur dans une base de données
SQL Server.
Scénario Dans le cadre du déploiement de votre site Web dans une ferme Web, vous
souhaitez stocker les variables de session dans un endroit central. Vous avez
choisi d'utiliser une base de données SQL Server pour cette solution de
stockage à court terme.

! Configuration du fichier Web.config


1. Ouvrez le fichier Web.config de l'application Web Benefits.
2. Recherchez l'élément sessionState.
3. Remplacez le mode sessionState par SQLServer, puis définissez la chaîne
de connexion pour que la connexion à localhost soit effectuée avec une
sécurité intégrée.
Une fois ces modifications apportées, l'élément sessionState doit ressembler
à ce qui suit :
<sessionState
mode="SQLServer"
stateConnectionString="tcpip=127.0.0.1:42424"
sqlConnectionString="data source=127.0.0.1;
Integrated Security=SSPI"
cookieless="false"
timeout="20"
/>

Important Le fichier Web.config étant au format XML (Extensible Markup


Language), il est essentiel de vérifier la casse de tous les noms d'éléments et
d'attributs.

4. Enregistrez le fichier Web.config.

! Installation et configuration des bases de données


Les variables de session sont stockées dans deux bases de données
préconfigurées, appelées ASPState et tempdb. Pour installer et configurer ces
bases de données, procédez comme suit :
1. Cliquez sur Démarrer, pointez sur Tous les programmes, sur Accessoires,
puis cliquez sur Invite de commandes.
Une fenêtre de commande s'ouvre.
2. À l'invite, tapez la ligne de commande suivante (où version représente la
version la plus récente de Microsoft .NET Framework installée sur votre
ordinateur), puis appuyez sur ENTRÉE :
cd\WINDOWS\Microsoft.NET\Framework\version\

L'invite affiche le nouveau répertoire.


Module 14 : Gestion d'état 55

3. À l'invite, tapez la ligne de commande suivante, puis appuyez sur


ENTRÉE :
OSQL –S localhost –E <InstallSqlState.sql

La fenêtre de commande affiche une série de chiffres et de messages, puis


revient à l'invite. Les bases de données ASPState et tempdb ont été
restaurées.
4. Fermez la fenêtre de commande, puis ouvrez l'Explorateur Windows.
5. Naviguez jusqu'au répertoire suivant :
Visual Basic .NET dossier_installation\LabFiles\lab14\VB\Starter
Visual C# dossier_installation\LabFiles\lab14\CS\Starter
6. Double-cliquez sur le fichier Lab14.bat.
Le fichier de commande exécute une requête SQL qui configure la sécurité
des bases de données ASPState et tempdb.
7. Fermez l'Explorateur Windows.

! Test de l'application Web


1. Générez et parcourez la page default.aspx pour tester l'application Web
Benefits.
2. Cliquez sur le lien Médical, entrez les informations nécessaires, puis
cliquez sur Enregistrer.
3. Cliquez sur le lien Assurance vie.
Vérifiez que les variables de session qui contiennent votre nom et votre date
de naissance fonctionnent correctement.
THIS PAGE INTENTIONALLY LEFT BLANK