Vue d'ensemble des cookies ASP.NET

Article
10/22/2014

Mise à jour : novembre 2007

Un cookie est un texte court qui accompagne les demandes et les pages entre le serveur Web et le navigateur. Il contient des informations que l'application Web peut lire chaque fois que l'utilisateur visite le site.

Cette rubrique contient les sections suivantes :

Scénarios
Contexte
Exemples de code
Référence de Classe
Ressources supplémentaires
Nouveautés

Scénarios

Les cookies permettent aux applications Web de stocker des informations spécifiques à l'utilisateur. Par exemple, lorsqu'un utilisateur visite votre site, les cookies peuvent vous servir à stocker ses préférences, ou d'autres informations. Lorsque cet utilisateur revient visiter votre site Web, l'application peut récupérer les informations stockées précédemment.

Retour au début

Contexte

Par exemple, lorsqu'un utilisateur demande une page de votre site, si votre application envoie, en plus de la page, un cookie contenant la date et l'heure, le navigateur de l'utilisateur récupérera la page plus le cookie, qu'il stockera dans un dossier du disque dur local.

Ultérieurement, si l'utilisateur demande à nouveau une page de votre site, le navigateur recherchera sur le disque dur local un cookie associé à l'URL saisie. Si le cookie existe, le navigateur l'enverra à votre site en même temps que la demande de page. Votre application pourra alors déterminer la date et l'heure auxquelles l'utilisateur a visité le site pour la dernière fois. Vous pourrez éventuellement utiliser cette information pour afficher un message sur l'écran de l'utilisateur ou vérifier une date d'expiration.

Les cookies sont associés à un site Web, et non à une page spécifique, afin que le navigateur et le serveur échangent des informations de cookie quelle que soit la page demandée par l'utilisateur sur votre site. Au fur et à mesure que l'utilisateur visite d'autres sites, chacun d'entre eux peut aussi envoyer un cookie au navigateur, ce dernier stockant tous les cookies séparément.

Les cookies aident les sites Web à stocker des informations sur leurs visiteurs. Plus généralement, les cookies sont un moyen de maintenir la continuité d'une application Web, autrement dit, d'en gérer l'état. En dehors du court instant où ils échangent réellement des informations, le navigateur et le serveur Web sont déconnectés l'un de l'autre. Chaque demande soumise par un utilisateur à un serveur Web est traitée indépendamment de toutes les autres. Il est cependant souvent utile pour le serveur Web de reconnaître un utilisateur lorsqu'il demande une page. Par exemple, le serveur Web d'un site d'achat conserve individuellement la trace de ses acheteurs afin que le site puisse gérer des paniers d'achat et d'autres informations spécifiques à l'utilisateur. Un cookie agit donc comme un peu comme une carte de téléphone prépayée, qui, en présentant des données d'identification pertinentes, aide une application à savoir ce qu'elle doit faire.

Les cookies peuvent servir à de nombreux usages, tous ayant pour but d'aider le site Web à mémoriser ses utilisateurs. Par exemple, un site qui réalise un sondage peut juste utiliser un cookie comme une valeur booléenne, afin de savoir si le navigateur d'un utilisateur a déjà participé au vote et d'empêcher ce dernier de voter deux fois. Un site qui demande à un utilisateur de se connecter peut utiliser un cookie pour mémoriser que cet utilisateur s'est déjà connecté et pour ne pas l'obliger à saisir continuellement ses informations d'identification.

Limitations des cookies

La plupart des navigateurs prennent en charge des cookies jusqu'à 4 096 octets. Cette limite relativement basse fait que les cookies sont tout indiqués pour stocker de petites quantités de données, ou mieux encore, des identificateurs tels que des ID utilisateurs. L'ID utilisateur peut alors servir à identifier l'utilisateur et à lire des informations sur ce dernier dans une base de données ou tout autre magasin de données. (Voir la section « Cookies et sécurité » ci-dessous pour plus d'informations sur les conséquences du stockage des informations utilisateur en matière de sécurité).

Les navigateurs limitent également le nombre de cookies que votre site peut stocker sur l'ordinateur de l'utilisateur. La plupart des navigateurs n'autorisent que 20 cookies par site. Si vous essayez d'en stocker davantage, les cookies les plus anciens seront supprimés. Certains navigateurs fixent également une limite absolue, en général 300, au nombre de cookies qu'ils acceptent, tous sites confondus.

Une autre limitation aux cookies, que vous vous rencontrerez peut-être, est la possibilité pour les utilisateurs de paramétrer leur navigateur de manière à ce qu'il refuse des cookies. Si vous définissez une politique de confidentialité P3P, que vous placez à la racine de votre site Web, un plus grand nombre de navigateurs accepteront des cookies en provenance de votre site. Vous pouvez néanmoins être contraint d'éviter totalement les cookies et d'utiliser un autre mécanisme pour stocker des informations spécifiques à l'utilisateur. Une méthode répandue pour stocker des informations utilisateur consiste à utiliser l'état de session, mais celui-ci dépend lui-même des cookies, comme il est expliqué plus loin dans la section « Cookies et état de session ».

Remarque :
Pour plus d'informations sur la gestion d'état et les options servant à enregistrer des informations dans une application Web, consultez Vue d'ensemble de la gestion d'état ASP.NET et Recommandations sur la gestion d'état ASP.NET.

Bien que les cookies puissent être très utiles à votre application, celle-ci ne doit pas dépendre de sa capacité à stocker des cookies. N'utilisez pas de cookies pour prendre en charge des fonctionnalités critiques. Si votre application doit s'appuyer sur des cookies, vous pouvez commencer par tester si le navigateur les acceptera. Consultez la section « Vérifier si un navigateur accepte les cookies », plus loin dans cette rubrique.

Écriture de cookies

Le navigateur est chargé de gérer les cookies sur le système d'un utilisateur. Les cookies sont transmis au navigateur via l'objet HttpResponse, qui expose une collection appelée Cookies. Vous pouvez accéder à l'objet HttpResponse comme étant la propriété Response de votre classe Page. Tous les cookies que vous souhaitez envoyer au navigateur doivent être ajoutés à cette collection. Lorsque vous créez un cookie, vous devez spécifier Name et Value. Chaque cookie doit avoir un nom unique pour pouvoir être identifié ultérieurement lorsqu'il sera lu sur le navigateur. Les cookies étant stockés par nom, nommer deux cookies de façon identique aura pour effet d'en remplacer un.

Vous pouvez également définir la date et l'heure d'expiration d'un cookie. Les cookies périmés sont supprimés par le navigateur lorsqu'un utilisateur visite le site qui les a écrits. La date d'expiration d'un cookie doit être paramétrée pour toute la durée pendant laquelle votre application jugera la valeur du cookie valide. Pour qu'un cookie n'expire jamais, vous pouvez paramétrer son expiration pour dans 50 ans.

Remarque :
Un utilisateur peut effacer les cookies sur son ordinateur quand il le souhaite. Même si vous stockez des cookies ayant des temps d'expiration prolongés, un utilisateur peut décider de supprimer tous ses cookies, effaçant ainsi tous les paramètres que vous aurez pu y stocker.

Si vous ne définissez pas de date d'expiration pour le cookie, celui-ci est créé, mais il n'est pas stocké sur le disque dur de l'utilisateur. Au lieu de cela, il est conservé dans les informations de session de l'utilisateur. Lorsque l'utilisateur ferme le navigateur, le cookie est supprimé. Un cookie non persistant comme celui-ci est utile pour des informations qui n'ont besoin d'être stockées que peu de temps ou qui, pour des raisons de sécurité, ne doivent pas être écrites sur le disque de l'ordinateur client. Par exemple, les cookies non persistants sont utiles si l'utilisateur travaille sur un ordinateur public, auquel cas vous ne souhaiterez pas écrire le cookie sur le disque.

Vous pouvez ajouter des cookies à la collection Cookies de plusieurs manières. L'exemple suivant montre deux méthodes servant à écrire des cookies :

Response.Cookies("userName").Value = "patrick"
Response.Cookies("userName").Expires = DateTime.Now.AddDays(1)

Dim aCookie As New HttpCookie("lastVisit")
aCookie.Value = DateTime.Now.ToString()
aCookie.Expires = DateTime.Now.AddDays(1)
Response.Cookies.Add(aCookie)

Response.Cookies["userName"].Value = "patrick";
Response.Cookies["userName"].Expires = DateTime.Now.AddDays(1);

HttpCookie aCookie = new HttpCookie("lastVisit");
aCookie.Value = DateTime.Now.ToString();
aCookie.Expires = DateTime.Now.AddDays(1);
Response.Cookies.Add(aCookie);

L'exemple ajoute deux cookies à la collection Cookies, l'un nommé userName et l'autre nommé lastVisit. Pour le premier cookie, les valeurs de la collection Cookies sont définies directement. Vous pouvez ajouter des valeurs à la collection de cette manière car les Cookies dérivent d'une collection spécialisée de type NameObjectCollectionBase.

Pour le deuxième cookie, le code crée une instance d'un objet de type HttpCookie, définit ses propriétés, puis l'ajoute à la collection Cookies via la méthode Add. Lorsque vous instanciez un objet HttpCookie, vous devez passer le nom de cookie comme faisant partie du constructeur.

Les deux exemples accomplissent la même tâche, écrire un cookie dans le navigateur. Dans les deux méthodes, la valeur d'expiration doit être de type DateTime. Toutefois, la valeur lastVisited est également une valeur de date et d'heure. Toutes les valeurs de cookie étant stockées sous forme de chaînes, la valeur de date et heure doit être convertie en String.

Cookies ayant plusieurs valeurs

Vous pouvez ne stocker qu'une valeur dans un cookie, comme le nom d'utilisateur et la date de la dernière visite. Vous pouvez aussi stocker plusieurs paires nom/valeur dans un seul cookie. Les paires nom/valeur sont connues sous le nom de sous-clés. (Les sous-clés sont exposées de façon très semblable à une chaîne de requête dans une URL). Par exemple, au lieu de créer deux cookies distincts nommés userName et lastVisit, vous pouvez créer un cookie unique nommé userInfo, possédant les sous-clés userName et lastVisit.

Il y a plusieurs raisons d'utiliser les sous-clés. En premier lieu, il est pratique de rassembler des informations connexes ou semblables dans un seul cookie. En outre, si toutes les informations sont réunies dans un seul cookie, les attributs du cookie tels que la date d'expiration s'appliquent à toutes les informations. (Inversement, si vous souhaitez assigner des dates d'expiration différentes à des types différents d'informations, vous devez stocker ces informations dans des cookies distincts).

Un cookie avec des sous-clés vous aide également à limiter la taille des fichiers de cookies. Comme nous l'avons vu précédemment à la section « Limitations des cookies », les cookies sont habituellement limités à 4 096 octets et vous ne pouvez pas en stocker plus de 20 par site. En utilisant un seul cookie avec des sous-clés, vous restez sous la barre des 20 cookies auxquels votre site a droit. De plus, un cookie seul prend approximativement 50 caractères en charge mémoire (informations d'expiration, etc.), plus la longueur de la valeur que vous y stockez, tout cela contribuant à approcher la limite des 4 096 octets. Si vous stockez cinq sous-clés à la place de cinq cookies distincts, vous économisez non seulement la charge mémoire de ces cookies, mais également environ 200 octets.

Pour créer un cookie avec sous-clés, vous pouvez utiliser une variante de la syntaxe servant à écrire un cookie seul. L'exemple suivant montre deux façons d'écrire le même cookie, chacun avec deux sous-clés :

Response.Cookies("userInfo")("userName") = "patrick"
Response.Cookies("userInfo")("lastVisit") = DateTime.Now.ToString()
Response.Cookies("userInfo").Expires = DateTime.Now.AddDays(1)

Dim aCookie As New HttpCookie("userInfo")
aCookie.Values("userName") = "patrick"
aCookie.Values("lastVisit") = DateTime.Now.ToString()
aCookie.Expires = DateTime.Now.AddDays(1)
Response.Cookies.Add(aCookie)

Response.Cookies["userInfo"]["userName"] = "patrick";
Response.Cookies["userInfo"]["lastVisit"] = DateTime.Now.ToString();
Response.Cookies["userInfo"].Expires = DateTime.Now.AddDays(1);

HttpCookie aCookie = new HttpCookie("userInfo");
aCookie.Values["userName"] = "patrick";
aCookie.Values["lastVisit"] = DateTime.Now.ToString();
aCookie.Expires = DateTime.Now.AddDays(1);
Response.Cookies.Add(aCookie);

Par défaut, tous les cookies d'un site sont stockés ensemble sur le client et sont tous transmis au serveur en même temps que les demandes soumises à ce site. En d'autres termes, chaque page d'un site reçoit tous les cookies de ce site. Vous pouvez cependant définir la portée des cookies de deux manières :

Limiter la portée des cookies à un dossier sur le serveur, ce qui vous permet de limiter les cookies à une application sur le site.
Affecter la portée à un domaine, ce qui vous permet de spécifier quels sous-domaines d'un domaine peuvent accéder aux cookies.

Limitation des cookies à un dossier ou une application

Pour limiter des cookies à un dossier sur le serveur, définissez la propriété Path du cookie, comme dans l'exemple suivant :

Dim appCookie As New HttpCookie("AppCookie")
appCookie.Value = "written " & DateTime.Now.ToString()
appCookie.Expires = DateTime.Now.AddDays(1)
appCookie.Path = "/Application1"
Response.Cookies.Add(appCookie)

HttpCookie appCookie = new HttpCookie("AppCookie");
appCookie.Value = "written " + DateTime.Now.ToString();
appCookie.Expires = DateTime.Now.AddDays(1);
appCookie.Path = "/Application1";
Response.Cookies.Add(appCookie);

Remarque :
Vous pouvez également écrire des cookies en les ajoutant directement à la collection Cookies, comme nous l'avons vu dans des exemples précédents.

Le chemin d'accès peut être soit un chemin d'accès physique sous la racine du site, soit une racine virtuelle. La conséquence sera que le cookie ne sera disponible que pour les pages du dossier Application1 ou de la racine virtuelle. Par exemple, si votre site s'appelle www.contoso.com, le cookie créé dans l'exemple précédent sera disponible pour les pages ayant le chemin d'accès https://www.contoso.com/Application1/ et pour toutes les pages situées sous ce dossier. En revanche, il ne sera pas disponible pour les pages d'autres applications, telles que https://www.contoso.com/Application2/ ou simplement https://www.contoso.com/.

Remarque :
Dans certains navigateurs, le chemin d'accès respecte la casse. Vous ne pouvez pas contrôler la façon dont les utilisateurs entrent les URL dans leurs navigateurs, mais si votre application dépend de cookies liés à un chemin d'accès spécifique, assurez-vous que la casse des URL de tous les liens hypertexte que vous créez correspond à celle de la valeur de la propriété Path.

Par défaut, les cookies sont associés à un domaine spécifique. Par exemple, si votre site est www.contoso.com, les cookies que vous écrivez sont envoyés au serveur lorsque les utilisateurs demandent une des pages de ce site. (Cela peut ne pas concerner les cookies ayant une valeur de chemin d'accès spécifique). Si votre site possède des sous-domaines (par exemple, contoso.com, sales.contoso.com et support.contoso.com), vous pouvez associer des cookies à un sous-domaine spécifique. Pour cela, définissez la propriété Domain du cookie, comme dans cet exemple :

Response.Cookies("domain").Value = DateTime.Now.ToString()
Response.Cookies("domain").Expires = DateTime.Now.AddDays(1)
Response.Cookies("domain").Domain = "support.contoso.com"

Response.Cookies["domain"].Value = DateTime.Now.ToString();
Response.Cookies["domain"].Expires = DateTime.Now.AddDays(1);
Response.Cookies["domain"].Domain = "support.contoso.com";

Lorsque le domaine est défini de cette manière, le cookie ne sera disponible que pour les pages du sous-domaine spécifié. Vous pouvez également utiliser la propriété Domain pour créer un cookie partagé par plusieurs sous-domaines, comme dans l'exemple suivant :

Response.Cookies("domain").Value = DateTime.Now.ToString()
Response.Cookies("domain").Expires = DateTime.Now.AddDays(1)
Response.Cookies("domain").Domain = "contoso.com"

Response.Cookies["domain"].Value = DateTime.Now.ToString();
Response.Cookies["domain"].Expires = DateTime.Now.AddDays(1);
Response.Cookies["domain"].Domain = "contoso.com";

Le cookie sera ensuite disponible pour le domaine principal et pour les domaines sales.contoso.com et support.contoso.com.

Lecture des cookies

Lorsqu'un navigateur soumet une demande au serveur, il envoie les cookies de ce serveur en même temps que la demande. Dans vos applications ASP.NET, vous pouvez lire les cookies à l'aide de l'objet HttpRequest, disponible en tant que propriété Request de votre classe Page. La structure de l'objet HttpRequest est essentiellement la même que celle de l'objet HttpResponse. Vous pouvez donc lire les cookies de l'objet HttpRequest pratiquement de la même manière que vous avez écrit les cookies dans l'objet HttpResponse. L'exemple de code suivant montre deux façons d'obtenir la valeur d'un cookie nommé username et d'afficher sa valeur dans un contrôle Label:

If Not Request.Cookies("userName") Is Nothing Then
    Label1.Text = Server.HtmlEncode(Request.Cookies("userName").Value)
End If

If Not Request.Cookies("userName") Is Nothing Then
    Dim aCookie As HttpCookie = Request.Cookies("userName")
    Label1.Text = Server.HtmlEncode(aCookie.Value)
End If

if(Request.Cookies["userName"] != null)
    Label1.Text = Server.HtmlEncode(Request.Cookies["userName"].Value);

if(Request.Cookies["userName"] != null)
{
    HttpCookie aCookie = Request.Cookies["userName"];
    Label1.Text = Server.HtmlEncode(aCookie.Value);
}

Avant d'essayer d'obtenir la valeur d'un cookie, vous devez vous assurer que ce cookie existe ; s'il n'existe pas, vous obtiendrez une exception NullReferenceException. Remarquez également que la méthode HtmlEncode a été appelée pour coder le contenu d'un cookie avant de l'afficher dans la page. Cela sert à s'assurer qu'un utilisateur malveillant n'a pas ajouté de script exécutable dans le cookie. Pour plus d'informations sur la sécurité des cookies, consultez la section « Cookies et sécurité ».

Remarque :
Des navigateurs différents stockant les cookies de façon différente, différents navigateurs sur le même ordinateur ne seront pas nécessairement capables de lire les cookies les uns des autres. Par exemple, si vous utilisez Internet Explorer pour tester une page une première fois, puis un navigateur différent pour renouveler le test, le second navigateur ne trouvera pas les cookies enregistrés par Internet Explorer.

Des navigateurs différents stockant les cookies de façon différente, différents navigateurs sur le même ordinateur ne seront pas nécessairement capables de lire les cookies les uns des autres. Par exemple, si vous utilisez Internet Explorer pour tester une page une première fois, puis un navigateur différent pour renouveler le test, le second navigateur ne trouvera pas les cookies enregistrés par Internet Explorer.

De même, lire la valeur d'une sous-clé dans un cookie est semblable à l'action consistant à le définir. L'exemple de code suivant montre une façon d'obtenir la valeur d'une sous-clé :

If Not Request.Cookies("userInfo") Is Nothing Then
    Label1.Text = _
        Server.HtmlEncode(Request.Cookies("userInfo")("userName"))
    Label2.Text = _
        Server.HtmlEncode(Request.Cookies("userInfo")("lastVisit"))
End If

if(Request.Cookies["userInfo"] != null)
{
    Label1.Text = 
        Server.HtmlEncode(Request.Cookies["userInfo"]["userName"]);

    Label2.Text =
        Server.HtmlEncode(Request.Cookies["userInfo"]["lastVisit"]);
}

Dans l'exemple précédent, le code lit la valeur de la sous-clé lastVisit, indexée précédemment sur la représentation sous forme de chaîne d'une valeur DateTime. Les cookies stockent les valeurs sous forme de chaînes. Si vous souhaitez utiliser la valeur lastVisit comme étant une date, vous devez donc la convertir dans le type approprié, comme dans l'exemple suivant :

Dim dt As DateTime
dt = DateTime.Parse(Request.Cookies("userInfo")("lastVisit"))

DateTime dt;
dt = DateTime.Parse(Request.Cookies["userInfo"]["lastVisit"]);

Les sous-clés d'un cookie sont typées comme une collection de type NameValueCollection. Par conséquent, une autre façon d'obtenir une sous-clé est d'obtenir la collection de sous-clés, puis d'extraire la valeur de la sous-clé par nom, comme dans l'exemple suivant :

If Not Request.Cookies("userInfo") Is Nothing Then
    Dim UserInfoCookieCollection As _
        System.Collections.Specialized.NameValueCollection
    UserInfoCookieCollection = Request.Cookies("userInfo").Values
    Label1.Text = _
        Server.HtmlEncode(UserInfoCookieCollection("userName"))
    Label2.Text = _
        Server.HtmlEncode(UserInfoCookieCollection("lastVisit"))
End If

if(Request.Cookies["userInfo"] != null)
{
    System.Collections.Specialized.NameValueCollection
        UserInfoCookieCollection;
       
    UserInfoCookieCollection = Request.Cookies["userInfo"].Values;
    Label1.Text = 
        Server.HtmlEncode(UserInfoCookieCollection["userName"]);
    Label2.Text =
        Server.HtmlEncode(UserInfoCookieCollection["lastVisit"]);
}

Le navigateur est chargé de gérer les cookies. L'heure et la date d'expiration du cookie l'aident à gérer son magasin de cookies. Bien que vous puissiez lire le nom et la valeur d'un cookie, vous ne pouvez donc pas lire sa date et son heure d'expiration. Lorsque le navigateur envoie les informations de cookie au serveur, il n'y inclut pas les informations d'expiration. (La propriété Expires du cookie retourne toujours une valeur de date et heure fixée sur zéro.) Si vous avez des inquiétudes sur la date d'expiration d'un cookie, vous devez la réinitialiser. Cette opération est traitée dans la section « Modifier et supprimer des cookies ».

Remarque :
Vous pouvez lire la propriété Expires d'un cookie que vous avez défini dans l'objet HttpResponse, avant que le cookie n'ait été envoyé au navigateur. Vous ne pouvez cependant pas récupérer l'expiration dans l'objet HttpRequest.

Lecture des collections de cookies

Vous devrez parfois lire l'intégralité des cookies disponibles pour la page. Pour lire le nom et la valeur de tous les cookies disponibles pour la page, vous pouvez parcourir la collection Cookies à l'aide d'un code tel que le suivant.

Dim i As Integer
Dim output As System.Text.StringBuilder = New System.Text.StringBuilder
Dim aCookie As HttpCookie
For i = 0 to Request.Cookies.Count - 1
    aCookie = Request.Cookies(i)
    output.Append("Cookie name = " & Server.HtmlEncode(aCookie.Name) _
        & "<br />")
    output.Append("Cookie value = " & _
        Server.HtmlEncode(aCookie.Value) & "<br /><br />")
Next
Label1.Text = output.ToString()

System.Text.StringBuilder output = new System.Text.StringBuilder();
HttpCookie aCookie;
for(int i=0; i<Request.Cookies.Count; i++)
{
    aCookie = Request.Cookies[i];
    output.Append("Cookie name = " + Server.HtmlEncode(aCookie.Name) 
        + "<br />");
    output.Append("Cookie value = " + Server.HtmlEncode(aCookie.Value)
        + "<br /><br />");
}
Label1.Text = output.ToString();

Remarque :
Lorsque vous exécutez ce code, vous pouvez voir un cookie nommé ASP.NET_SessionId. Il s'agit d'un cookie utilisé par ASP.NET pour stocker un identificateur unique pour votre session. Le cookie de session n'est pas rendu persistant sur votre disque dur. Pour plus d'informations sur les cookies de session, consultez « Cookies et état de session » plus loin dans cette rubrique.

Une limitation de l'exemple précédent est que si le cookie possède des sous-clés, la vue les montrera sous forme de chaîne nom/valeur unique. Vous pouvez lire la propriété HasKeys d'un cookie pour déterminer si le cookie possède des sous-clés. Si tel est le cas, vous pouvez lire la collection de sous-clés pour obtenir les noms et les valeurs des sous-clés. Vous pouvez directement lire les valeurs des sous-clés dans la collection Values, par valeur d'index. Les noms de sous-clés correspondants sont disponibles dans le membre AllKeys de la collection Values, qui retourne un tableau de chaînes. Vous pouvez également utiliser le membre Keys de la collection Values. Toutefois, la propriété AllKeys est mise en cache la première fois que l'on y accède. En revanche, la propriété Keys génère un tableau chaque fois que l'on y accède. C'est pour cette raison que la propriété AllKeys est beaucoup plus rapide lors des accès suivants s'agissant de la même demande de page.

L'exemple suivant est une modification de l'exemple précédent. Il utilise la propriété HasKeys pour tester la présence de sous-clés. Si des sous-clés sont détectées, l'exemple obtient celles de la collection Values :

Dim i As Integer
Dim j As Integer
Dim output As System.Text.StringBuilder = New StringBuilder()
Dim aCookie As HttpCookie
Dim subkeyName As String
Dim subkeyValue As String
For i = 0 To Request.Cookies.Count - 1
    aCookie = Request.Cookies(i)
    output.Append("Name = " & aCookie.Name & "<br />")
    If aCookie.HasKeys Then
        For j = 0 To aCookie.Values.Count - 1
            subkeyName = Server.HtmlEncode(aCookie.Values.AllKeys(j))
            subkeyValue = Server.HtmlEncode(aCookie.Values(j))
            output.Append("Subkey name = " & subkeyName & "<br />")
            output.Append("Subkey value = " & subkeyValue & _
                "<br /><br />")
        Next
    Else
        output.Append("Value = " & Server.HtmlEncode(aCookie.Value) & _
            "<br /><br />")
    End If
Next
Label1.Text = output.ToString()

for(int i=0; i<Request.Cookies.Count; i++)
{
    aCookie = Request.Cookies[i];
    output.Append("Name = " + aCookie.Name + "<br />");
    if(aCookie.HasKeys)
    {
        for(int j=0; j<aCookie.Values.Count; j++)
        {
            subkeyName = Server.HtmlEncode(aCookie.Values.AllKeys[j]);
            subkeyValue = Server.HtmlEncode(aCookie.Values[j]);
            output.Append("Subkey name = " + subkeyName + "<br />");
            output.Append("Subkey value = " + subkeyValue + 
                "<br /><br />");
        }
    }
    else
    {
        output.Append("Value = " + Server.HtmlEncode(aCookie.Value) +
            "<br /><br />");
    }
}
Label1.Text = output.ToString();

Vous pouvez aussi extraire les sous-clés sous forme d'objet NameValueCollection, comme dans l'exemple suivant :

Dim i As Integer
Dim j As Integer
Dim output As System.Text.StringBuilder = New StringBuilder()
Dim aCookie As HttpCookie
Dim subkeyName As String
Dim subkeyValue As String
For i = 0 To Request.Cookies.Count - 1
    aCookie = Request.Cookies(i)
    output.Append("Name = " & aCookie.Name & "<br />")
    If aCookie.HasKeys Then
        Dim CookieValues As _
            System.Collections.Specialized.NameValueCollection = _
                aCookie.Values
        Dim CookieValueNames() As String = CookieValues.AllKeys
        For j = 0 To CookieValues.Count - 1
            subkeyName = Server.HtmlEncode(CookieValueNames(j))
            subkeyValue = Server.HtmlEncode(CookieValues(j))
            output.Append("Subkey name = " & subkeyName & "<br />")
            output.Append("Subkey value = " & subkeyValue & _
                "<br /><br />")
        Next
    Else
        output.Append("Value = " & Server.HtmlEncode(aCookie.Value) & _
            "<br /><br />")
    End If
Next
Label1.Text = output.ToString

System.Text.StringBuilder output = new System.Text.StringBuilder();
HttpCookie aCookie;
string subkeyName;
string subkeyValue;

for (int i = 0; i < Request.Cookies.Count; i++)
{
    aCookie = Request.Cookies[i];
    output.Append("Name = " + aCookie.Name + "<br />");
    if (aCookie.HasKeys)
    {
        System.Collections.Specialized.NameValueCollection CookieValues = 
            aCookie.Values;
        string[] CookieValueNames = CookieValues.AllKeys;
        for (int j = 0; j < CookieValues.Count; j++)
        {
            subkeyName = Server.HtmlEncode(CookieValueNames[j]);
            subkeyValue = Server.HtmlEncode(CookieValues[j]);
            output.Append("Subkey name = " + subkeyName + "<br />");
            output.Append("Subkey value = " + subkeyValue + 
                "<br /><br />");
        }
    }
    else
    {
        output.Append("Value = " + Server.HtmlEncode(aCookie.Value) +
            "<br /><br />");
    }
}
Label1.Text = output.ToString();

Modification et suppression des cookies

Vous ne pouvez pas modifier directement un cookie. Modifier un cookie se fait en créant un nouveau cookie avec de nouvelles valeurs et en le transmettant au navigateur pour remplacer l'ancienne version sur le client. L'exemple de code suivant montre comment modifier la valeur d'un cookie qui stocke le compte des visites de l'utilisateur sur le site :

Dim counter As Integer
If Request.Cookies("counter") Is Nothing Then
    counter = 0
Else
    counter = Int32.Parse(Request.Cookies("counter").Value)
End If
counter += 1
Response.Cookies("counter").Value = counter.ToString
Response.Cookies("counter").Expires = DateTime.Now.AddDays(1)

int counter;
if (Request.Cookies["counter"] == null)
    counter = 0;
else
{
    counter = int.Parse(Request.Cookies["counter"].Value);
}
counter++;

Response.Cookies["counter"].Value = counter.ToString();
Response.Cookies["counter"].Expires = DateTime.Now.AddDays(1);

Suppression des cookies

Supprimer un cookie (le supprimer physiquement du disque dur de l'utilisateur) est une variante de l'opération qui consiste à le modifier. Vous ne pouvez pas supprimer directement un cookie puisqu'il se trouve sur l'ordinateur de l'utilisateur. Toutefois, vous pouvez le faire éliminer par le navigateur lui-même. La technique consiste à créer un nouveau cookie portant le même nom que le cookie à supprimer, mais en lui affectant une date d'expiration antérieure à aujourd'hui. Lorsque le navigateur vérifiera les données d'expiration du cookie, il supprimera le cookie désormais obsolète. L'exemple de code suivant montre une des façons de supprimer tous les cookies disponibles pour l'application :

Dim aCookie As HttpCookie
Dim i As Integer
Dim cookieName As String
Dim limit As Integer = Request.Cookies.Count - 1
For i = 0 To limit
    cookieName = Request.Cookies(i).Name
    aCookie = New HttpCookie(cookieName)
    aCookie.Expires = DateTime.Now.AddDays(-1)
    Response.Cookies.Add(aCookie)
Next

HttpCookie aCookie;
string cookieName;
int limit = Request.Cookies.Count;
for (int i=0; i<limit; i++)
{
    cookieName = Request.Cookies[i].Name;
    aCookie = new HttpCookie(cookieName);
    aCookie.Expires = DateTime.Now.AddDays(-1);
    Response.Cookies.Add(aCookie);
}

Modification ou suppression des sous-clés

La modification d'une sous-clé obéit au même principe que celui de sa création, comme le montre l'exemple suivant :

Response.Cookies("userInfo")("lastVisit") = DateTime.Now.ToString()
Response.Cookies("userInfo").Expires = DateTime.Now.AddDays(1)

Response.Cookies["userInfo"]["lastVisit"] = DateTime.Now.ToString();
Response.Cookies["userInfo"].Expires = DateTime.Now.AddDays(1);

Pour supprimer une sous-clé, vous devez manipuler la collection Values du cookie, qui détient les sous-clés. Commencez par recréer le cookie en le récupérant depuis l'objet Cookies. Vous pouvez ensuite appeler la méthode Remove de la collection Values, en passant à la méthode Remove le nom de la sous-clé à supprimer. Ajoutez alors le cookie à la collection Cookies, afin qu'il soit renvoyé au navigateur sous sa nouvelle forme. L'exemple de code suivant montre comment supprimer une sous-clé. Dans l'exemple, le nom de la sous-clé à supprimer est spécifié dans une variable.

Dim subkeyName As String
subkeyName = "userName"
Dim aCookie As HttpCookie = Request.Cookies("userInfo")
aCookie.Values.Remove(subkeyName)
aCookie.Expires = DateTime.Now.AddDays(1)
Response.Cookies.Add(aCookie)

string subkeyName;
subkeyName = "userName";
HttpCookie aCookie = Request.Cookies["userInfo"];
aCookie.Values.Remove(subkeyName);
aCookie.Expires = DateTime.Now.AddDays(1);
Response.Cookies.Add(aCookie);

Cookies et sécurité

Les problèmes de sécurité liés aux cookies sont semblables à ceux qui sont liés à l'obtention de données du client. Dans votre application, les cookies sont une autre forme d'entrée d'utilisateur et sont par conséquent susceptibles d'être consultés ou usurpés. Un utilisateur peut au moins consulter les données que vous stockez dans un cookie, puisque ce dernier est disponible sur l'ordinateur de l'utilisateur lui-même. L'utilisateur peut également modifier le cookie avant que le navigateur ne vous l'envoie.

Vous ne devez jamais stocker de données sensibles dans un cookie, tels que des noms d'utilisateurs, des mots de passe, des numéros de carte de crédit, etc. Ne placez rien dans un cookie qui ne soit pas censé se trouver entre les mains d'un utilisateur ou de quiconque susceptible de voler le cookie d'une façon ou d'une autre.

De la même façon, soyez vigilant à l'égard des informations que vous obtenez d'un cookie. Ne présupposez pas que les données sont les mêmes que lorsque vous l'avez écrit ; utilisez pour travailler avec des valeurs de cookie les mêmes mesures de protection que celles que vous utiliseriez pour des données saisies par un utilisateur dans une page Web. Les exemples précédents de cette rubrique ont montré comment coder le contenu d'un cookie en langage HTML avant d'afficher la valeur dans une page, comme vous le feriez avant d'afficher des informations provenant d'utilisateurs.

Les cookies sont transmis entre le navigateur et le serveur sous forme de texte brut, et quiconque capable d'intercepter votre trafic Web peut les lire. Vous pouvez définir une propriété de cookie qui n'autorise la transmission du cookie que si la connexion utilise le protocole Secure Sockets Layer (SSL). SSL n'empêche pas le cookie d'être lu ou manipulé une fois transféré sur l'ordinateur de l'utilisateur, mais il évite qu'il soit lu pendant le transit, le cookie étant alors chiffré. Pour plus d'informations, consultez Méthodes de sécurité de base pour les applications Web.

Détermination de l'acceptation des cookies par un navigateur

Les utilisateurs peuvent paramétrer leur navigateur de manière à ce qu'il refuse les cookies. Aucune erreur n'est déclenchée si un cookie ne peut pas être écrit. De même, le navigateur n'envoie aucune information au serveur sur ses paramètres de cookie actuels.

Remarque :
La propriété Cookies n'indique pas si les cookies sont activés. Elle indique seulement si le navigateur actuel prend en charge les cookies de façon inhérente.

Une façon de déterminer si les cookies sont acceptés consiste à essayer d'écrire un cookie, puis de tenter de le relire. Si vous ne pouvez pas lire le cookie que vous avez écrit, vous pouvez supposer que les cookies sont désactivés dans le navigateur.

L'exemple de code suivant montre comment tester si les cookies sont acceptés. Cet exemple est composé de deux pages. La première page écrit un cookie, puis redirige le navigateur vers la deuxième page. La deuxième page essaie de lire le cookie. Elle redirige ensuite à nouveau le navigateur vers la première page, en ajoutant à l'URL une variable chaîne de requête avec les résultats des tests.

Le code de la première page se présente de la manière suivante :

Protected Sub Page_Load(ByVal sender As Object, _
        ByVal e As EventArgs) Handles Me.Load
    If Not Page.IsPostBack Then
        If Request.QueryString("AcceptsCookies") Is Nothing Then
            Response.Cookies("TestCookie").Value = "ok"
            Response.Cookies("TestCookie").Expires = _
                DateTime.Now.AddMinutes(1)
            Response.Redirect("TestForCookies.aspx?redirect=" & _
                Server.UrlEncode(Request.Url.ToString))
        Else
            Label1.Text = "Accept cookies = " & _
                Server.UrlEncode(Request.QueryString("AcceptsCookies"))
        End If
    End If
End Sub

protected void Page_Load(object sender, EventArgs e)
{
    if (!Page.IsPostBack)
    {
        if (Request.QueryString["AcceptsCookies"] == null)
        {
            Response.Cookies["TestCookie"].Value = "ok";
            Response.Cookies["TestCookie"].Expires =
                DateTime.Now.AddMinutes(1);
            Response.Redirect("TestForCookies.aspx?redirect=" +
                Server.UrlEncode(Request.Url.ToString()));
        }
        else
        {
            Label1.Text = "Accept cookies = " +
                Server.UrlEncode(
                Request.QueryString["AcceptsCookies"]);
        }
    }
}

La page commence par effectuer un test pour voir s'il s'agit d'une publication. Si tel n'est pas le cas, elle recherche le nom de la variable chaîne de requête AcceptsCookies qui contient les résultats des tests. S'il n'existe aucune variable chaîne de requête, le test n'a pas été terminé. Le code écrit alors un cookie nommé TestCookie. Après avoir écrit le cookie, l'exemple appelle Redirect pour le transfert à la page de test TestForCookies.aspx. Ajoutée à l'URL de la page de test se trouve une variable chaîne de requête nommée redirect, qui contient l'URL de la page actuelle ; cela vous permettra de rediriger vers cette page après avoir exécuté le test.

La page de test peut être entièrement composée de code ; il n'est pas nécessaire qu'elle contienne des contrôles. L'exemple de code suivant illustre la page de test.

Sub Page_Load()
    Dim redirect As String = Request.QueryString("redirect")
    Dim acceptsCookies As String
    If Request.Cookies("TestCookie") Is Nothing Then
        acceptsCookies = "no"
    Else
        acceptsCookies = "yes"
        ' Delete test cookie.
        Response.Cookies("TestCookie").Expires = _
            DateTime.Now.AddDays(-1)
    End If
    Response.Redirect(redirect & "?AcceptsCookies=" & acceptsCookies, _
       True)
End Sub

protected void Page_Load(object sender, EventArgs e)
{
    string redirect = Request.QueryString["redirect"];
    string acceptsCookies;
    if(Request.Cookies["TestCookie"] ==null)
        acceptsCookies = "no";
    else
    {
        acceptsCookies = "yes";
        // Delete test cookie.
        Response.Cookies["TestCookie"].Expires = 
            DateTime.Now.AddDays(-1);
    }
    Response.Redirect(redirect + "?AcceptsCookies=" + acceptsCookies,
    true);
}

Après avoir lu la variable chaîne de requête de redirection, le code essaie de lire le cookie. Si le cookie existe, il est immédiatement supprimé à des fins de nettoyage. Lorsque le test est terminé, le code construit une nouvelle URL à partir de l'URL qui lui a été passée dans la variable chaîne de requête redirect. La nouvelle URL comprend également une variable chaîne de requête qui contient les résultats des tests. L'étape finale consiste à utiliser la nouvelle URL pour rediriger le navigateur vers la page d'origine.

Pour améliorer l'exemple, une solution pourrait être de conserver les résultats des tests du cookie dans un magasin persistant, tel qu'une base de données, afin de ne pas avoir à répéter le test chaque fois que l'utilisateur consulte la page d'origine. (Stocker par défaut les résultats des tests dans l'état de session nécessite des cookies).

Cookies et état de session

Lorsqu'un utilisateur navigue jusqu'à votre site, le serveur établit pour lui une session unique, qui dure le temps de la visite de cet utilisateur. Pour chaque session, ASP.NET conserve des informations d'état de session dans lesquelles les applications peuvent stocker des informations spécifiques à l'utilisateur. Pour plus d'informations, consultez la rubrique Vue d'ensemble de l'état de session ASP.NET.

ASP.NET doit garder trace de l'ID de session de chaque utilisateur afin de pouvoir mapper l'utilisateur aux informations d'état de session sur le serveur. Par défaut, ASP.NET utilise un cookie non persistant pour stocker l'état de session. Toutefois, si un utilisateur a désactivé les cookies sur son navigateur, les informations d'état de session ne peuvent pas être stockées dans un cookie.

ASP.NET offre une alternative sous la forme de sessions sans cookies. Vous pouvez configurer votre application pour qu'elle stocke les ID de session non pas dans un cookie, mais dans les URL des pages de votre site. Si votre application s'appuie sur l'état de session, vous pouvez envisager de la configurer pour qu'elle utilise des sessions sans cookies. Toutefois, dans certaines circonstances très particulières, si un utilisateur partage l'URL avec un autre (peut-être pour envoyer l'URL à un collègue pendant que sa session est encore active), les deux utilisateurs peuvent finir par partager la même session, rendant ainsi les résultats imprévisibles. Pour plus d'informations sur la façon de configurer votre application afin qu'elle utilise des sessions sans cookies, consultez la rubrique Vue d'ensemble de la gestion d'état ASP.NET.

Retour au début

Exemples de code

Démarrages rapides

Gestion de l'état de l'application (en anglais)

Rubriques "Comment" et "Procédure pas à pas"

Comment : personnaliser le cookie d'authentification du service d'authentification WCF

Retour au début

Référence de Classe

HttpCookie	Fournit une manière sécurisée de créer et de manipuler des cookies HTTP.
Cookies	Obtient la collection de cookies constituant la réponse.
Cookies	Obtient une collection de cookies envoyée par le client.

Retour au début

Ressources supplémentaires

Retour au début

Nouveautés

Retour au début

Voir aussi

Concepts

Vue d'ensemble de la gestion d'état ASP.NET

Référence

Retour au début

Partager via

Vue d'ensemble des cookies ASP.NET

Scénarios

Contexte

Limitations des cookies

Écriture de cookies

Cookies ayant plusieurs valeurs

Contrôle de la portée du cookie

Limitation des cookies à un dossier ou une application

Limitation de la portée de domaine du cookie

Lecture des cookies

Modification de la date d'expiration d'un cookie

Lecture des collections de cookies

Modification et suppression des cookies

Suppression des cookies

Modification ou suppression des sous-clés

Cookies et sécurité

Détermination de l'acceptation des cookies par un navigateur

Cookies et état de session

Exemples de code

Démarrages rapides

Rubriques "Comment" et "Procédure pas à pas"

Référence de Classe

Ressources supplémentaires

Nouveautés

Voir aussi

Concepts

Référence

Ressources supplémentaires