Cenni preliminari sui cookie ASP.NET

Articolo
10/22/2014

Aggiornamento: novembre 2007

Un cookie è un testo di piccole dimensioni che accompagna le richieste e le pagine durante la trasmissione di dati tra server Web e browser. Il cookie contiene informazioni che l'applicazione Web è in grado di leggere ogni volta che l'utente visita il sito.

Vengono illustrati i seguenti argomenti:

Scenari
Informazioni di supporto
Esempi di codice
Riferimento alle classi
Risorse supplementari
Novità

Scenari

Nelle applicazioni Web, i cookie consentono di memorizzare le informazioni specifiche dell'utente. Ad esempio, quando un utente visita un sito, i cookie consentono di memorizzare le preferenze dell'utente o altre informazioni. Alla successiva visita del sito Web da parte dello stesso utente, l'applicazione potrà recuperare le informazioni memorizzate in precedenza.

Torna all'inizio

Informazioni di supporto

Ad esempio, se un utente richiede una pagina di un sito e l'applicazione non invia solo la pagina ma anche un cookie contenente data e ora, al momento della visualizzazione della pagina anche il browser riceve il cookie e lo memorizza in una cartella sul disco rigido dell'utente.

Se in un secondo momento l'utente richiede nuovamente una pagina dello stesso sito, al momento dell'inserimento dell'URL il browser cercherà nel disco rigido locale il cookie associato all'URL. Se il cookie esiste, il browser lo invia al sito con la richiesta della pagina. L'applicazione può quindi determinare la data e l'ora dell'ultima visita dell'utente. È possibile utilizzare queste informazioni per visualizzare un messaggio per l'utente o per controllare una data di scadenza.

I cookie vengono associati a un sito Web e non a una pagina specifica; pertanto, il browser e il server scambiano le informazioni relative ai cookie indipendentemente dalla pagina del sito richiesta dall'utente. Ogni volta che un utente visita un sito diverso, questo può inviare un cookie al browser dell'utente, che memorizza tutti i cookie separatamente.

I cookie consentono ai siti Web di memorizzare le informazioni relative ai visitatori. Più in generale, i cookie rappresentano un modo per mantenere la continuità in un'applicazione Web, ovvero per eseguire la gestione dello stato. Ad eccezione di un breve periodo di tempo durante il quale ha luogo effettivamente uno scambio di informazioni, il browser e il server Web non sono connessi. Ogni richiesta di un utente a un server Web viene trattata in modo indipendente dalle altre richieste. Tuttavia, spesso per un server Web è utile essere in grado di riconoscere gli utenti quando questi richiedono una pagina. Ad esempio, il server Web di un sito sul quale vengono acquistati dei prodotti tiene traccia dei singoli acquirenti e ciò rende possibile la gestione del carrello acquisti e di altre informazioni specifiche dell'utente. Pertanto, un cookie è paragonabile a una scheda telefonica prepagata che consente l'esecuzione dell'operazione appropriata mediante l'inserimento di un ID pertinente.

I cookie vengono utilizzati per diversi scopi che consentono ai siti Web di ricordare gli utenti. Ad esempio, un cookie può essere utilizzato semplicemente come valore booleano in un sito sul quale viene condotto un sondaggio, per indicare se il browser di un utente ha già partecipato e non consentire, quindi, all'utente di votare due volte. È possibile che un sito che richiede all'utente di eseguire l'accesso utilizzi un cookie per registrare l'accesso dell'utente in modo da non dover richiedere sempre l'inserimento delle credenziali.

La maggior parte dei browser supporta cookie fino a un massimo di 4096 byte. A causa di questo limite ridotto, i cookie risultano particolarmente adatti per memorizzare piccole quantità di dati o identificatori, ad esempio un ID utente. L'ID utente può essere quindi utilizzato per identificare l'utente e per leggere le informazioni relative all'utente memorizzate in un database o in un altro archivio di dati. Vedere più avanti la sezione "Cookie e sicurezza" per informazioni sulle implicazioni in termini di sicurezza relative all'archiviazione delle informazioni sull'utente.

Inoltre, i browser impongono limitazioni sul numero di cookie che il sito può memorizzare nel computer dell'utente. La maggior parte dei browser consente solo 20 cookie per sito; se si cerca di archiviarne altri, i cookie meno recenti vengono eliminati. Alcuni browser, inoltre, impongono un limite assoluto, di solito 300, sul numero di cookie provenienti da tutti i siti.

Una limitazione che può verificarsi è quella degli utenti che impostano i browser in modo da non accettare i cookie. Se un'informativa sulla privacy conforme agli standard P3P viene implementata e salvata nella directory principale del sito Web, più browser accetteranno i cookie dai siti. Tuttavia, può essere necessario evitare del tutto i cookie e utilizzare un altro meccanismo per la memorizzazione delle informazioni specifiche dell'utente. Un metodo comune per memorizzare le informazioni utente è lo stato sessione, che però dipende dai cookie, come spiegato più avanti nella sezione "Cookie e stato sessione".

Nota:
Per ulteriori informazioni sulla gestione dello stato e sulle opzioni per il salvataggio delle informazioni in un'applicazione Web, vedere Cenni preliminari sulla gestione dello stato ASP.NET e Suggerimenti per la gestione dello stato di ASP.NET.

Sebbene i cookie possano essere estremamente utili per l'applicazione, quest'ultima non deve dipendere dalla possibilità di memorizzarli. Non utilizzare i cookie per supportare funzionalità critiche. Se l'applicazione deve poter utilizzare i cookie, è opportuno verificare che il browser li accetti. Vedere la sezione "Verifica dell'accettazione dei cookie da parte di un browser" più avanti in questo argomento.

I cookie del sistema di un utente vengono gestiti dal browser. I cookie vengono inviati al browser tramite l'oggetto HttpResponse che espone un insieme chiamato Cookies. È possibile accedere all'oggetto HttpResponse come proprietà Response della classe Page. È necessario aggiungere a questo insieme tutti i cookie che devono essere inviati al browser. Quando viene creato un cookie, è necessario specificare Name e Value. Ogni cookie deve avere un nome univoco in modo che possa essere identificato dal browser al momento della lettura. Poiché i cookie vengono memorizzati per nome, se due cookie hanno lo stesso nome, uno dei due viene sovrascritto.

È anche possibile impostare la data e l'ora di scadenza di un cookie. I cookie scaduti vengono eliminati dal browser quando un utente visita i siti che li hanno scritti. La scadenza di un cookie deve essere impostata in base alla validità del valore del cookie assegnata dall'applicazione. Se è necessario che un cookie non scada, è possibile impostarne la data di scadenza a 50 anni.

Nota:
Gli utenti possono cancellare i cookie dal proprio computer in qualsiasi momento. Anche se vengono impostate date di scadenza distanti, un utente può decidere di eliminare tutti i cookie e annullare quindi le impostazioni in essi memorizzate.

Se non viene impostata una scadenza, il cookie viene creato ma non viene memorizzato sul disco rigido dell'utente. Il cookie viene invece mantenuto come parte delle informazioni della sessione dell'utente. Quando l'utente chiude il browser, il cookie viene eliminato. Questi cookie non permanenti sono utili per le informazioni che devono essere memorizzate soltanto per un breve periodo di tempo o che, per motivi di sicurezza, non devono essere scritte sul computer client. Ad esempio, i cookie non permanenti sono utili se un utente utilizza un computer pubblico e non desidera quindi che il cookie venga scritto sul disco.

È possibile aggiungere cookie all'insieme Cookies in diversi modi. Nell'esempio riportato di seguito sono illustrati due metodi di scrittura dei cookie.

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);

In questo esempio vengono aggiunti all'insieme Cookies due cookie, denominati rispettivamente userName e lastVisit. Per il primo cookie, i valori dell'insieme Cookies vengono impostati direttamente. È possibile aggiungere valori all'insieme in questo modo poiché Cookies deriva da un insieme specifico di tipo NameObjectCollectionBase.

Per il secondo cookie, il codice crea un'istanza di un oggetto di tipo HttpCookie, ne imposta le proprietà e lo aggiunge all'insieme Cookies utilizzando il metodo Add. Quando viene creata un'istanza di un oggetto HttpCookie, è necessario passare il nome del cookie come parte del costruttore.

In entrambi gli esempi viene eseguita la stessa attività, ossia la scrittura di un cookie sul browser. In entrambi i casi, il valore della scadenza deve essere di tipo DateTime. Tuttavia, anche il valore lastVisited è un valore data/ora. Poiché tutti i valori dei cookie vengono memorizzati come stringhe, il valore data/ora deve essere convertito in String .

È possibile memorizzare un valore in un cookie: ad esempio, nome utente e ultima visita. È anche possibile memorizzare più coppie nome/valore in un unico cookie. Le coppie nome/valore vengono definite sottochiavi. Le sottochiavi vengono disposte in modo molto simile alle stringhe di query in un URL. Ad esempio, invece di creare due cookie distinti denominati userName e lastVisit, è possibile creare un unico cookie denominato userInfo che contiene le sottochiavi userName e lastVisit.

È possibile utilizzare le sottochiavi per diversi motivi. In primo luogo, consentono di memorizzare informazioni simili o correlate in un unico cookie. Inoltre, poiché tutti i dati sono contenuti in un unico cookie, gli attributi del cookie quali, ad esempio, la scadenza, verranno applicati a tutte le informazioni. Se invece si desidera assegnare diverse date di scadenza a diversi tipi di informazione, è necessario utilizzare cookie distinti per la memorizzazione.

Un cookie contenente sottochiavi aiuta anche a limitare le dimensioni dei file cookie. Come indicato precedentemente nella sezione "Limitazioni dei cookie", non è possibile memorizzare più di 20 cookie per sito e la dimensione massima consentita è di 4096 byte. Quando viene utilizzato un singolo cookie con sottochiavi, vengono usati meno cookie di quelli consentiti per sito (20). Inoltre, un solo cookie richiede un massimo di 50 caratteri per l'overhead (informazioni sulla scadenza e così via), a cui va aggiunta la lunghezza del valore in esso memorizzato; tutto ciò contribuisce al raggiungimento del limite di 4096 byte. Se invece di cinque cookie distinti vengono memorizzate cinque sottochiavi , viene risparmiato lo spazio occupato dall'overhead dei cookie distinti, circa 200 byte.

Per creare un cookie con sottochiavi, è possibile utilizzare una variante della sintassi di scrittura di un cookie singolo. Nell'esempio riportato di seguito vengono illustrate due modalità di scrittura dello stesso cookie, ognuna con due sottochiavi:

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);

Per impostazione predefinita, tutti i cookie di un sito vengono memorizzati insieme sul client e vengono inviati al server insieme alle richieste effettuate al sito. In altre parole, ogni pagina di un sito contiene tutti i cookie del sito in questione. È tuttavia possibile impostare l'ambito dei cookie in due modi:

Limitare l'ambito dei cookie a una cartella sul server, il che consente di limitare i cookie a un'applicazione sul sito.
Impostare l'ambito di un dominio in modo da poter specificare i sottodomini in grado di accedere a un cookie.

Per limitare i cookie a una cartella sul server, è necessario impostare la proprietà Path del cookie, come illustrato nell'esempio seguente:

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);

Nota:
È anche possibile scrivere i cookie aggiungendoli direttamente all'insieme Cookies, come mostrato negli esempi precedenti.

Il percorso può essere sia un percorso fisico della radice del sito sia una radice virtuale. Ne consegue che il cookie sarà disponibile solo per le pagine della cartella Applicazione1 o della radice virtuale. Ad esempio, se il sito è www.contoso.com, il cookie creato nell'esempio precedente sarà disponibile per le pagine del percorso https://www.contoso.com/Applicazione1/ e per le relative pagine secondarie. Tuttavia, il cookie non sarà disponibile per le pagine di altre applicazioni quali https://www.contoso.com/Applicazione2/ o semplicemente per le pagine di https://www.contoso.com/.

Nota:
In alcuni browser, per il percorso viene rilevata la distinzione tra maiuscole e minuscole. Non è possibile controllare il modo in cui gli utenti digitano gli URL nei browser, ma se l'applicazione dipende da cookie collegati a un percorso specifico, occorre assicurarsi che i caratteri degli URL nei collegamenti ipertestuali creati corrispondano al valore della proprietà Path.

Per impostazione predefinita, i cookie vengono associati a un dominio specifico. Ad esempio, se il sito è www.contoso.com, i cookie scritti vengono inviati al server quando l'utente richiede una pagina del sito in questione. È possibile che ciò non si applichi ai cookie con un valore di percorso specifico. Se un sito dispone di sottodomini, ad esempio contoso.com, sales.contoso.com e support.contoso.com, è possibile associare i cookie a un sottodominio specifico. A tale scopo, impostare la proprietà Domain del cookie, come illustrato nell'esempio riportato di seguito.

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";

Quando il dominio viene impostato in questo modo, il cookie sarà disponibile solo per le pagine del sottodominio specificato. È inoltre possibile utilizzare la proprietà Domain per creare un cookie che possa essere condiviso da più sottodomini, come illustrato nell'esempio riportato di seguito.

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";

Il cookie sarà quindi disponibile sia per i domini principali sia per i domini sales.contoso.com e support.contoso.com.

Quando un browser effettua una richiesta al server, invia i cookie insieme alla richiesta. Nelle applicazioni ASP.NET, è possibile leggere i cookie utilizzando l'oggetto HttpRequest, che è disponibile come proprietà Request della classe Page. La struttura dell'oggetto HttpRequest è sostanzialmente uguale alla struttura dell'oggetto HttpResponse: è quindi possibile leggere i cookie dell'oggetto HttpRequest nello stesso modo in cui vengono scritti i cookie dell'oggetto HttpResponse. Nell'esempio di codice riportato di seguito vengono illustrati due metodi per ottenere il valore di un cookie denominato username e visualizzarne il valore in un controllo 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);
}

Prima di provare a ottenere il valore di un cookie, è opportuno accertarsi che il cookie esista. Se il cookie non esiste verrà restituita un'eccezione NullReferenceException. Si noti inoltre che il metodo HtmlEncode viene chiamato per codificare i contenuti di un cookie prima della sua visualizzazione nella pagina. In questo modo ci si assicura che un utente malintenzionato non abbia inserito uno script eseguibile nel cookie. Per ulteriori informazioni sulla sicurezza dei cookie, vedere la sezione "Cookie e sicurezza".

Nota:
Poiché i vari browser memorizzano i cookie in modo diverso, diversi browser sullo stesso computer non saranno necessariamente in grado di leggere i cookie degli altri browser. Ad esempio, se la prima volta che viene eseguito il test di una pagina viene utilizzato Internet Explorer e per il secondo test viene utilizzato un browser diverso, quest'ultimo non sarà in grado di trovare i cookie salvati da Internet Explorer.

Poiché i vari browser memorizzano i cookie in modo diverso, diversi browser sullo stesso computer non saranno necessariamente in grado di leggere i cookie degli altri browser. Ad esempio, se la prima volta che viene eseguito il test di una pagina viene utilizzato Internet Explorer e per il secondo test viene utilizzato un browser diverso, quest'ultimo non sarà in grado di trovare i cookie salvati da Internet Explorer.

Il processo di lettura del valore di una sottochiave di un cookie è simile al processo di impostazione. Nell'esempio di codice riportato di seguito viene illustrato un metodo da utilizzare per ottenere il valore di una sottochiave.

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"]);
}

Nell'esempio precedente, il codice legge il valore della sottochiave lastVisit, impostato precedentemente nella rappresentazione in forma di stringa di un valore DateTime. I cookie memorizzano i valori come stringhe, pertanto se si desidera utilizzare il valore lastVisit come data, è necessario convertirlo in un tipo di valore appropriato, come mostrato nell'esempio riportato di seguito.

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

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

Le sottochiavi di un cookie vengono inserite come un insieme di tipo NameValueCollection. Pertanto, un altro modo per ottenere singole sottochiavi consiste nell'ottenere l'insieme delle sottochiavi ed estrarre il valore per nome, come mostrato nell'esempio riportato di seguito.

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"]);
}

I cookie vengono gestiti dal browser e la data e l'ora di scadenza dei cookie aiutano il browser a gestirne la memorizzazione. Pertanto, sebbene sia possibile leggere il nome e il valore di un cookie, non è possibile leggerne la data e l'ora di scadenza. Quando il browser invia le informazioni relative ai cookie al server, non include le informazioni sulla scadenza. La proprietà Expires del cookie restituisce sempre un valore data/ora uguale a zero. Per evitare problemi legati alla data di scadenza di un cookie, è necessario reimpostarlo seguendo le indicazioni riportate nella sezione "Modifica ed eliminazione dei cookie".

Nota:
È possibile leggere la proprietà Expires di un cookie impostata nell'oggetto HttpResponse, prima dell'invio del cookie al browser. Non è tuttavia possibile inserire nuovamente la scadenza nell'oggetto HttpRequest.

A volte sarà necessario leggere tutti i cookie disponibili per la pagina. Per leggere i nomi e i valori di tutti i cookie disponibili per la pagina, è possibile eseguire un ciclo nell'insieme Cookies utilizzando un codice simile al seguente:

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();

Nota:
È possibile che durante l'esecuzione di questo codice venga visualizzato un cookie chiamato ASP.NET_SessionId. Si tratta di un cookie utilizzato da ASP.NET per memorizzare un identificatore univoco per la sessione. Il cookie della sessione non viene mantenuto nel disco rigido. Per ulteriori informazioni sui cookie della sessione, vedere "Cookie e stato sessione" più avanti in questo argomento.

Nel caso di un cookie con sottochiavi, un limite dell'esempio precedente consiste nella visualizzazione delle sottochiavi come un'unica stringa di nome/valore. È possibile leggere la proprietà HasKeys di un cookie per determinare se questo dispone di sottochiavi. In caso affermativo, è possibile leggere l'insieme di sottochiavi per ottenere i singoli nomi e valori delle stesse. È possibile leggere i valori delle sottochiavi direttamente nell'insieme Values per valore di indice. I nomi delle sottochiavi corrispondenti sono disponibili nel membro AllKeys dell'insieme Values, che restituisce una matrice di stringhe. È anche possibile utilizzare il membro Keys dell'insieme Values. Tuttavia, la prima volta che si accede alla proprietà AllKeys, questa verrà memorizzata nella cache. Al cotnrario, ogni volta che si accede alla proprietà Keys, questa genera una matrice. Per questo motivo, per gli accessi successivi nel contesto della richiesta della stessa pagina, la proprietà AllKeys sarà più rapida.

Nell'esempio riportato di seguito viene apportata una modifica all'esempio precedente: viene infatti utilizzata la proprietà HasKeys per verificare l'esistenza e l'eventuale rilevamento di sottochiavi. In caso affermativo, le sottochiavi vengono recuperate dall'insieme 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();

In alternativa, è possibile estrarre le sottochiavi come oggetto NameValueCollection, come mostrato nell'esempio riportato di seguito.

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();

Non è possibile modificare direttamente un cookie. La modifica di un cookie consiste infatti nel creare un nuovo cookie con nuovi valori e nell'inviarlo quindi al browser per sovrascrivere la versione precedente presente nel client. Nel seguente esempio di codice vengono illustrate le modalità di modifica del valore di un cookie che memorizza il numero di volte in cui un utente visita un sito.

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);

L'eliminazione di un cookie, ossia la rimozione fisica del cookie dal disco rigido dell'utente, è una variazione della modifica. Non è possibile rimuovere direttamente un cookie poiché questo si trova sul computer dell'utente. Tuttavia, è possibile fare in modo che sia il browser stesso a eliminarlo. La tecnica consiste nel creare un nuovo cookie con lo stesso nome del cookie da eliminare e impostare la scadenza su una data antecedente alla data corrente. Quando il browser verifica la scadenza del cookie, elimina il cookie che risulta essere scaduto. Nel seguente esempio di codice vengono illustrate le modalità di eliminazione di tutti i cookie disponibili per un'applicazione.

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);
}

Modifica o eliminazione delle sottochiavi

Il processo di modifica di una singola sottochiave è uguale al processo di creazione della stessa, come illustrato nell'esempio riportato di seguito.

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);

Per eliminare una singola sottochiave, è necessario modificare l'insieme Values del cookie, che contiene le sottochiavi. In primo luogo, è necessario creare nuovamente il cookie caricandolo dall'oggetto Cookies. È quindi possibile richiamare il metodo Remove dell'insieme Values e passare il nome della sottochiave da eliminare al metodo Remove. Infine, il cookie viene aggiunto all'insieme Cookies e rinviato nella nuova forma modificata al browser. Nell'esempio di codice riportato di seguito vengono illustrate le modalità di eliminazione di una sottochiave. In questo esempio, il nome della sottochiave da rimuovere viene specificato in una variabile.

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);

I problemi di sicurezza relativi ai cookie sono simili a quelli che si possono verificare quando si ottengono dati dal client. Nell'applicazione, i cookie rappresentano un'altra forma di input dell'utente e, pertanto, possono essere visualizzati e utilizzati per lo spoofing. Un utente può visualizzare almeno i dati memorizzati nel cookie, poiché questo è disponibile sul computer dell'utente. Inoltre, l'utente può modificare il cookie prima che venga restituito dal browser.

Nel cookie non devono mai essere memorizzati dati riservati, ad esempio nomi di utenti, password, numeri di carte di credito e così via. Si consiglia di non inserire nei cookie informazioni che non devono capitare tra le mani di un utente o di un malintenzionato che potrebbe impossessarsi in qualche modo del cookie.

Analogamente, è bene diffidare dalle informazioni che si ricavano da un cookie. È possibile che i dati siano diversi da quelli scritti originariamente; quando si lavora con i valori dei cookie si consiglia di ricorrere alle stesse misure di sicurezza utilizzate per i dati immessi in una pagina Web. Negli esempi riportati in precedenza, la codifica HTML viene applicata ai contenuti dei cookie prima della visualizzazione del valore in una pagina, analogamente a quanto accade prima di visualizzare le informazioni ottenute dagli utenti.

I cookie vengono passati tra browser e server come testo semplice: pertanto, chiunque intercetti il traffico Web sarà in grado di leggere il cookie. È possibile impostare una proprietà del cookie in modo che questo venga trasmesso solo se la connessione utilizza SSL (Secure Sockets Layer). SSL non impedisce che il cookie venga letto o modificato quando si trova sul computer dell'utente, ma evita che venga letto durante la trasmissione poiché il testo è crittografato. Per ulteriori informazioni, vedere Suggerimenti di base sulla protezione delle applicazioni Web.

Gli utenti possono impostare il browser in modo che i cookie non vengano accettati. Se non risulta possibile scrivere un cookie, non viene generato alcun errore. Analogamente il browser non invia alcuna informazione al server sulle impostazioni correnti relative ai cookie.

Nota:
La proprietà Cookies non fornisce alcuna informazione sull'attivazione dei cookie, limitandosi a indicare se il browser corrente supporta i cookie.

Un modo per determinare se i cookie vengono accettati è quello di scrivere un cookie e cercare di rileggerlo. Se non è possibile leggere il cookie scritto, è presumibile che i cookie siano stati disattivati nel browser.

Nell'esempio di codice riportato di seguito vengono illustrate le modalità di verifica dell'accettazione dei cookie. L'esempio è composto da due pagine: nella prima pagina viene scritto un cookie e il browser viene reindirizzato alla seconda pagina, che cerca di leggere il cookie. Inoltre, nella seconda pagina il browser viene reindirizzato alla prima pagina con i risultati del test e con l'aggiunta di una variabile di stringa di query all'URL.

Il codice della prima pagina è simile al seguente:

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 pagina prima verifica che non si tratti di un postback, quindi cerca il nome della variabile di stringa di query AcceptsCookies contenente i risultati del test. Se non viene trovata alcuna variabile di stringa di query, il testo non è stato completato e il codice scrive un cookie denominato TestCookie. Dopo aver scritto il cookie, l'esempio chiama Redirect per passare alla pagina di test TestForCookies.aspx. All'URL della pagina di test viene aggiunta una variabile di stringa di query denominata redirect e contenente l'URL della pagina corrente: ciò consente di effettuare il reindirizzamento su questa pagina dopo l'esecuzione del test.

La pagina di test può essere costituita solo da codice, non è necessario che contenga dei controlli. Nell'esempio di codice seguente viene illustrata la pagina di 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);
}

Dopo aver letto la variabile di stringa di query redirect, il codice cerca di leggere il cookie. Per motivi di gestione, se il cookie esiste, viene eliminato immediatamente. Una volta terminato il test, il codice genera un nuovo URL dall'URL trasmesso dalla variabile di stringa di query redirect. Il nuovo URL comprende una variabile di stringa di query contenente i risultati del test. Nel passaggio finale, il nuovo URL viene utilizzato per reindirizzare il browser alla pagina originale.

Un miglioramento consisterebbe nel memorizzare in modo permanente i risultati del test del cookie, ad esempio in un database, in modo da non doverlo ripetere ogni volta che l'utente visualizza la pagina originale. La memorizzazione dei risultati del test in stato sessione per impostazione predefinita richiede l'utilizzo di cookie.

Quando un utente visita un sito, il server stabilisce una sessione univoca con l'utente per tutta la durata della visita. Per ogni sessione, ASP.NET mantiene le informazioni sullo stato sessione in cui le applicazioni possono memorizzare le informazioni specifiche dell'utente. Per ulteriori informazioni, vedere l'argomento Cenni preliminare sullo stato della sessione ASP.NET.

ASP.NET deve tenere traccia dell'ID sessione di ogni utente, in modo da abbinare l'utente alle informazioni relative allo stato sessione sul server. Per impostazione predefinita, ASP.NET utilizza un cookie non permanente per memorizzare lo stato della sessione. Tuttavia, se un utente ha disattivato i cookie nel browser, non sarà possibile memorizzare le informazioni sullo stato sessione in un cookie.

ASP.NET propone, come alternativa, una sessione senza cookie. È possibile configurare l'applicazione in modo da memorizzare gli ID sessione non in un cookie, bensì negli URL delle pagine del sito. Se l'applicazione si basa sullo stato sessione, è possibile configurarla in modo da utilizzare sessioni senza cookie. Tuttavia, in determinate circostanze, se l'utente condivide l'URL con un altro utente, ad esempio se invia un URL a un collega mentre la sessione è ancora attiva, entrambi gli utenti condividono la stessa sessione, il che potrebbe comportare conseguenze impreviste. Per ulteriori informazioni sulla configurazione dell'applicazione per l'utilizzo di sessioni senza cookie, vedere l'argomento Cenni preliminari sulla gestione dello stato ASP.NET.

Torna all'inizio

Esempi di codice

Guide rapide

Managing Application State (informazioni in lingua inglese)

Argomenti relativi alle procedure e alle procedure dettagliate

Procedura: personalizzare il cookie di autenticazione dal servizio di autenticazione WCF

Torna all'inizio

Riferimento alle classi

HttpCookie	Fornisce una modalità indipendente dai tipi per creare e modificare singoli cookie HTTP.
Cookies	Ottiene l'insieme dei cookie di risposta.
Cookies	Ottiene un insieme di cookie inviati dal client.

Torna all'inizio

Risorse supplementari

Torna all'inizio

Novità

Torna all'inizio

Vedere anche

Concetti

Cenni preliminari sulla gestione dello stato ASP.NET

Riferimenti

Torna all'inizio

Condividi tramite

Scenari

Informazioni di supporto

Modifica o eliminazione delle sottochiavi

Esempi di codice

Guide rapide

Argomenti relativi alle procedure e alle procedure dettagliate

Riferimento alle classi

Risorse supplementari

Novità

Vedere anche

Concetti

Riferimenti

Risorse aggiuntive

Condividi tramite

Cenni preliminari sui cookie ASP.NET

Scenari

Informazioni di supporto

Limitazioni dei cookie

Scrittura di cookie

Cookie con più di un valore

Controllo dell'ambito del cookie

Limitazione dei cookie a una cartella o a un'applicazione

Limitazione dell'ambito del dominio del cookie

Lettura di cookie

Modifica della data di scadenza di un cookie

Lettura degli insiemi di cookie

Modifica ed eliminazione di cookie

Eliminazione di cookie

Modifica o eliminazione delle sottochiavi

Cookie e sicurezza

Verifica dell'accettazione dei cookie da parte di un browser

Cookie e stato sessione

Esempi di codice

Guide rapide

Argomenti relativi alle procedure e alle procedure dettagliate

Riferimento alle classi

Risorse supplementari

Novità

Vedere anche

Concetti

Riferimenti

Risorse aggiuntive