Compartilhar via

Visão Geral de Cookies do ASP.NET

  • Artigo

Um cookie é um pequeno pedaço de texto que acompanha solicitações e páginas quando elas andam entre o servidor Web e o navegador.O cookie contêm informações que o aplicativo Web pode ler sempre que o usuário visitar o site.

Esse tópico contém:

  • Cenários

  • Segundo plano

  • Exemplos de código

  • Referência de Classe

  • Recursos adicionais

  • O que há de novo

Cenários

Os cookies fornecem um meio em aplicativos da Web para armazenar informações específicas do usuário.Por exemplo, quando um usuário visita seu site, você pode usar cookies para armazenar as preferências do usuário ou outras informações.Quando o usuário visita seu site Web outra vez, o aplicativo pode recuperar as informações armazenadas antes.

Voltar ao topo

Segundo plano

Um cookie é um pequeno pedaço de texto que acompanha solicitações e páginas quando elas andam entre o servidor Web e o navegador.O cookie contêm informações que o aplicativo Web pode ler sempre que o usuário visitar o site.

Por exemplo, se um usuário solicita uma página do seu site e seu aplicativo envia não apenas uma página, mas também um cookie contendo a data e a hora, quando o navegador do usuário receber a página, ele também recebe o cookie, que ele armazena em uma pasta no disco rígido do usuário.

Depois, se o usuário solicitar uma página do seu site novamente, quando o usuário inserir a URL, o navegador procura no disco rígido local por um cookie associado com a URL.Se o cookie existe, o navegador envia o cookie ao seu site juntamente com a solicitação da página.Seu aplicativo pode então determinar a data e hora que o usuário visitou pela última vez o site.Você pode usar as informações para exibir uma mensagem para o usuário ou verificar uma data de validade.

Cookies estão associados com um site Web, não com uma página específica, portanto, o navegador e o servidor vão trocar informações de cookie independentemente de qual for a página que o usuário solicite de seu site.Como o usuário visita diferentes sites, cada site pode enviar um cookie para o navegador do usuário igualmente; o navegador armazena todos os cookies separadamente.

Cookies ajudam sites Web a armazenar informações sobre os visitantes.De forma mais geral, cookies são um meio de manter continuidade em um aplicativo Web—isto é, de realizar gerenciamento de estado.Exceto pelo curto tempo enquanto eles estão realmente trocando informação, o navegador e o servidor Web estão desconectados.Cada solicitação que um usuário faz a um servidor Web é tratada independentemente de qualquer outra solicitação.Muitas vezes, entretanto, é útil para o servidor Web identificar usuários quando eles solicitam uma página.Por exemplo, o servidor Web de um site de compras mantém o caminho de compradores individuais, de forma que o site pode gerenciar os carrinhos de compra e outra informação de um usuário específico.Um cookie então atua como um tipo de cartão de chamada, apresentando identificação pertinente que ajuda um aplicativo a saber como proceder.

Cookies são usados para muitos propósitos, todos relativos a ajudar o site Web a lembrar os usuários.Por exemplo, um site realizando uma pesquisa pode usar um cookie simplesmente como um valor Booleano para indicar se um navegador do usuário já participou na votação, a fim de que o usuário não possa votar duas vezes.Um site que pede a um usuário para fazer logon pode usar um cookie para registrar que o usuário já logou nele, de modo que o usuário não tenha que inserir suas credenciais.

A maioria dos navegadores suportam cookies de até 4096 bytes.Devido a esse limite pequeno, de cookies são melhor usados para armazenar pequenas quantidades de dados ou melhor ainda, um identificador, sistema autônomo uma ID de usuário.A ID de usuário, em seguida, pode ser usada para identificar o usuário e ler as informações de usuário de um banco de dados ou Outros armazenamento de dados.(Veja a seção "Cookies e Segurança" abaixo para informação sobre implicações de segurança de armazenamento de informação de usuário.)

Navegadores também impõem limitações em quantos cookies seu site pode armazenar no computador do usuário.A maioria dos navegadores permite somente 20 cookies por site; se você tentar armazenar mais, os cookies mais antigos são descartados.Alguns navegadores também põem um limite absoluto, geralmente 300, no número de cookies que serão aceitos de todos os sites combinados.

Uma limitação de cookie que você pode encontrar é que os usuários podem configurar seu navegador para recusar cookies.Se você definir um política de privacidade P3P e localizá-la na raiz de seu site Web, muitos navegadores irão aceitar cookies de seu site.Entretanto, você pode ter que evitar os cookies completamente e usar um mecanismo diferente para armazenar informações específicas de usuário.Um método comum para armazenar informações de usuário é estado de sessão, mas estado de sessão depende de cookies, como explicado antes na seção "Cookies e Estado de Sessão".

Observação:

Para obter mais informações sobre gerenciamento de estado e opções para salvar informações em um aplicativo Web Web, consulte Visão Geral sobre o Gerenciamento de Estado do ASP.NET e Recomendações sobre Gerenciamento de Estado do ASP.NET.

Apesar de cookies poderem ser muito úteis em seu aplicativo, o aplicativo não deve depender de ser capaz de armazenar cookies.Não use cookies para dar suporte a recursos críticos.Se seu aplicativo deve confiar em cookies, você pode testar para ver se o navegador irá aceitar cookies.Veja a seção posterior a este tópico "Verificando Se um Navegador Aceita Cookies".

Gravando Cookies

O navegador é responsável por gerenciar cookies em um sistema de usuário.Cookies são enviados ao navegador através do objeto HttpResponse que expõe um coleção chamada Cookies.Você pode acessar o objeto HttpResponse como a propriedade Response de sua classe Page.Quaisquer cookies que você desejar enviar ao navegador deve ser adicionado a esta coleção.Quando criar um cookie, você especifica um Name e Value.Cada cookie deve ter um nome exclusivo, de forma que ele possa ser identificado posteriormente quando lido pelo navegador.Devido aos cookies serem armazenados pelo nome, nomear dois cookies de forma igual irá fazer com que um seja sobrescrito.

Você pode também definir uma data e hora de validade do cookie.Cookies expirados são excluídos pelo navegador quando um usuário visita o site que gravou os cookies.A validade de um cookie deve ser definida durante o tempo que seu aplicativo considera que o valor do cookie seja válido.Para um cookie nunca expirar efetivamente, você pode definir a data de validade para ser 50 anos a partir de agora.

Observação:

Os usuários podem limpar os cookies de seu computador a qualquer momento.Mesmo se você armazenar os cookies com longo prazo de validade, um usuário poderá decidir excluir todos os cookies, apagando as configurações que você possa ter armazenado em cookies.

Se você não definir a validade do cookie, o cookie é criado mas ele não é armazenado no disco rígido do usuário.Em vez disso, o cookie é mantido como parte das informações de sessão do usuário.Quando o usuário fecha o navegador, o cookie é descartado.Um cookie não persistente como este é útil para informação que precisa ser armazenada por um curto período de tempo apenas ou que, por razões de segurança, não deve ser gravado no disco do computador cliente.Por exemplo, cookies não persistentes são úteis se o usuário estiver trabalhando em um computador público, onde você não deseja gravar o cookie no disco.

Você pode adicionar cookies à coleção Cookies de diversas maneiras.O exemplo a seguir mostra dois métodos para gravar 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);

O exemplo adiciona dois cookies para a coleção Cookies, um chamado userName e o outro chamado lastVisit.Para o primeiro cookie, os valores da coleção Cookies são definidos diretamente.Você pode adicionar valores para a coleção dessa maneira porque Cookies deriva de uma coleção especializada do tipo NameObjectCollectionBase.

Para o segundo cookie, o código cria uma instância de um objeto do tipo HttpCookie,define suas propriedades e, em seguida, adiciona-o à coleção Cookies via o método Add.Quando você instanciar um objeto HttpCookie, você deve passar o nome do cookie como parte do construtor.

Dois exemplos realizam a mesma tarefa, gravar um cookie para o navegador.Em ambos os métodos, o valor de validade deve ser do tipo DateTime.No entanto, o valor lastVisited também é um valor de data - tempo.Devido a todos os valores de cookie serem armazenados como sequências de caracteres, o valor a data - tempo deve ser convertido em um String.

Cookies com Mais Que Um Valor

Você pode armazenar um valor em um cookie, tal como nome de usuário e última visita.Você também pode armazenar vários pares nome-valor em um cookie único.Os pares nome-valor são denominados subchaves.(Subchaves são enunciados bem como uma sequência de caracteres da consulta em uma URL.) Por exemplo, em vez de criar dois cookies separados chamados userName e lastVisit,você pode criar um único cookie chamado userInfo que tenha as subchaves userName e lastVisit.

Você pode usar subchaves por vários motivos.Primeiro, é conveniente colocar informações relacionadas ou semelhantes em um único cookie.Além disso, devido a todas as informações estarem em um único cookie, atributos de cookie, tais como validade, se aplicam a todas as informações.(Por outro lado, se você desejar atribuir diferentes datas de validade para diferentes tipos de informação, você deve armazenar as informações em cookies separados.)

Um cookie com subchaves também ajuda a limitar o tamanho dos arquivos de cookie.Conforme observado anteriormente na seção " Limitações de cookie ", os cookies são normalmente limitados a 4096 bytes e você não pode armazenar mais que 20 cookies por site.Usando um único cookie com subchaves, você usa menos que esses 20 cookies a que seu site está destinado.Além disso, um único cookie ocupa cerca de 50 caracteres para a sobrecarga (informações de validade e assim por diante) mais o comprimento do valor que você armazena nele, que contam para o limite de 4096 bytes.Se você armazenar cinco subchaves em vez de cinco cookies separados, você salva a sobrecarga dos cookies separados e pode economizar aproximadamente 200 bytes.

Para criar um cookie com subchaves, você pode usar uma variação da sintaxe para gravar um único cookie.O exemplo a seguir mostra duas maneiras para gravar o mesmo cookie, cada um com duas subchaves:

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

Por padrão, todos os cookies para um site são armazenados juntos no cliente, e todos os cookies são enviados para o servidor com qualquer solicitação para esse site.Em outras palavras, cada página em um site recebe todos os cookies para esse site.No entanto, você pode definir o escopo de cookies de duas maneiras:

  • Limite o escopo dos cookies para uma pasta no servidor, o que permite a você limitar cookies para um aplicativo no site.

  • Defina um escopo para um domínio, o que permite a você especificar quais subdomínios em um domínio podem acessar um cookie.

Limitando Cookies para uma Pasta ou um Aplicativo

Para limitar cookies para uma pasta no servidor, defina a propriedade Path do cookie, como no exemplo a seguir:

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);
Observação:

Você também pode escrever cookies, adicionando-os para o Cookies coleção diretamente, sistema autônomo mostrado nos exemplos anteriores.

O caminho pode ser um caminho físico sob a raiz do site ou então uma raiz virtual.O efeito será que o cookie estará disponível somente para páginas na pasta Application1 ou raiz virtual.Por exemplo, se seu site se chamar www.contoso.com, o cookie criado no exemplo anterior estará disponível para páginas com o caminho https://www.contoso.com/Application1/ e para quaisquer páginas abaixo dessa pasta.No entanto, o cookie não estará disponível para páginas em outros aplicativos, tais como https://www.contoso.com/Application2/ ou https://www.contoso.com/ apenas.

Observação:

Em alguns navegadores, o caminho é apresenta diferenciação de maiúsculas e minúsculas.Não é possível controlar como os usuários digitam URLs em seus navegadores, mas se seu aplicativo depende de cookies vinculados a um caminho específico, certifique-se de que as URLs em quaisquer hyperlinks criados coincidir com os de maiúsculas e minúsculas do Path valor da propriedade.

Por padrão, cookies estão associados com um domínio específico.Por exemplo, se seu site for www.contoso.com, os cookies que você gravar são enviados para o servidor quando os usuários solicitarem qualquer página do site.(Isso pode não incluir cookies com um valor de caminho específico.) Se seu site tiver subdomínios — por exemplo, contoso.com, sales.contoso.com e support.contoso.com— então, é possível associar cookies com um subdomínio específico.Para fazer isso, defina a propriedade Domain do cookie, como no exemplo:

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 o domínio é definido dessa maneira, o cookie estará disponível somente para páginas do subdomínio especificado.Você também pode usar a propriedade Domain para criar um cookie que pode ser compartilhado entre diversos subdomínios, conforme mostrado no exemplo o seguir:

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

O cookie, em seguida, estará disponível para o domínio primário bem como para domínios sales.contoso.com e support.contoso.com.

Lendo Cookies

Quando um navegador faz uma solicitação para o servidor, ele envia os cookies para o servidor junto com a solicitação.Em seus aplicativos ASP.NET, você pode ler os cookies usando o objeto HttpRequest, que está disponível como a propriedade Request de sua classe Page.A estrutura do objeto HttpRequest é essencialmente a mesma do objeto HttpResponse, portanto, você pode ler cookies fora do objeto HttpRequest da mesma forma que você gravou cookies para o objeto HttpResponse.O exemplo de código a seguir mostra duas maneiras para obter o valor de um cookie chamado username e exibir seu valor em um controle 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);
}

Antes de tentar obter o valor de um cookie, verifique se que o cookie existe; se o cookie não existir, você receberá uma exceção NullReferenceException.Observe também que o método HtmlEncode foi chamado para codificar o conteúdo de um cookie antes de exibí-lo na página.Isso faria com que um usuário mal-intencionado não adicionasse script executável no cookie.Para obter mais informações sobre segurança de cookie, consulte a seção "Cookies e Segurança ".

Observação:

Como diferentes navegadores armazenam os cookies de maneira diferente, diferentes navegadores no mesmo computador não necessariamente são capazes de ler cada um dos outros cookies.Por exemplo, se você usar Internet Explorer para testar uma página uma vez, mas, em seguida, usar um navegador diferente para testar novamente, o segundo navegador não localiza os cookies salvos pelo Internet Explorer.

Ler o valor de uma subchave em um cookie é semelhante a configurá-lo.O exemplo de código a seguir mostra uma maneira para obter o valor de uma subchave:

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

No exemplo anterior, o código lê o valor da subchave lastVisit,que foi definida anteriormente para a representação de sequência de caracteres de um valor DateTime.Cookies armazenam valores como sequências de caracteres, portanto, se você quiser usar o valor lastVisit como uma data, você precisa convertê-lo para o tipo apropriado, como no exemplo:

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

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

As subchaves em um cookie são digitadas como uma coleção de tipo NameValueCollection.Portanto, outra maneira para obter uma subchave individual é obter a coleção de subchaves e, em seguida, extrair o valor da subchave pelo nome, conforme mostrado no exemplo o seguir:

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

O navegador é responsável por gerenciar os cookies, e a hora e data de validade do cookie ajudam o navegador a gerenciar seu armazenamento de cookies.Portanto, embora você possa ler o nome e o valor de um cookie, você não pode ler a data e hora de validade do cookie.Quando o navegador envia informações de cookie para o servidor, o navegador não inclui as informações de validade.(A propriedade Expires do cookie sempre retorna um valor de data - hora de zero.) Se você estiver preocupado sobre a data de validade de um cookie, você deve redefiní-la, o que é abordado na seção " Modificando e Excluindo Cookies ".

Observação:

Você pode ler a Expires propriedade de um cookie que você definiu HttpResponse objeto, antes do cookie tiver sido enviado para o navegador. No entanto, você não pode obter a validade de volta no objeto HttpRequest.

Ocasionalmente, você pode precisar ler todos os cookies disponíveis para a página.Para ler os nomes e valores de todos os cookies disponíveis para a página, você pode executar um loop através da coleção Cookies usando código como a seguir.

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();
Observação:

Quando você executa esse código, você poderá ver um cookie denominado ASP.NET_SessionId.Isto é um cookie que o ASP.NET usa para armazenar um identificador exclusivo para sua sessão.O cookie de sessão não é mantido no seu disco rígido.Para obter mais informações sobre cookies de sessão, consulte a seção "Cookies e Estado de Sessão " posteriormente neste tópico.

Uma limitação do exemplo anterior é que, se o cookie tiver subchaves, a exibição mostra as subchaves como um único nome/valor de sequência de caracteres.Você pode ler a propriedade HasKeys de um cookie para determinar se o cookie tem subchaves.Nesse caso, você pode ler a coleção de subchave para obter individuais nomes e valores da subchave.Você pode ler os valores da subchave da coleção Values diretamente pelo valor de índice.Os nomes da subchave correspondentes estão disponíveis no membro AllKeys da coleção Values, que retorna uma matriz de sequências de caracteres.Você também pode usar o membro Keys da coleção Values.No entanto, a propriedade AllKeys é armazenada em cache na primeira vez que ela é acessada.Por outro lado, a propriedade Keys cria uma matriz cada vez que ela é acessada.Por esse motivo, a propriedade AllKeys é muito mais rápida em acessos subsequentes dentro do contexto da mesma solicitação de página.

O exemplo a seguir mostra uma modificação do exemplo anterior.Ele usa a propriedade HasKeys para testar subchaves, e, se subchaves forem detectados, o exemplo obtém subchaves da coleção 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();

Como alternativa, você pode extrair as subchaves como um objeto NameValueCollection conforme mostrado no exemplo a seguir:

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

Modificando e Excluindo Cookies

Não é possível modificar diretamente um cookie.Em vez disso, alterar um cookie consiste em criar um novo cookie com novos valores e, em seguida, enviar o cookie para o navegador para substituir a antiga versão no cliente.O exemplo de código a seguir mostra como você pode alterar o valor de um cookie que armazena um contador de visitas de usuário para o 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);

Excluindo Cookies

Excluir um cookie — fisicamente removê-lo do disco rígido do usuário — é uma variação de modificá-lo.Você não pode remover um cookie diretamente, pois o cookie está no computador do usuário.No entanto, você pode conseguir que o navegador exclua o cookie para você.A técnica é criar um novo cookie com o mesmo nome que o cookie a ser excluído, mas definir a validade do cookie como uma data anterior a hoje.Quando o navegador verifica a validade do cookie, o navegador descarta o cookie agora desatualizado.O exemplo de código a seguir mostra uma maneira para excluir todos os cookies disponíveis para o aplicativo:

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

Modificando ou Excluindo Subchaves

Modificar uma subchave individual é semelhante a criá-la, conforme mostrado no exemplo o seguir:

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

Para excluir uma subchave individual, você manipula a coleção Values do cookie, que retém as subchaves.Primeiro, você recria o cookie obtendo-o a partir do objeto Cookies.Em seguida, você pode chamar o método Remove da coleção Values, passando para o método Remove o nome da subchave para excluir.Você então adiciona o cookie à coleção Cookies para que ele seja enviado em sua forma modificada de volta para o navegador.O exemplo de código a seguir mostra como excluir uma subchave.No exemplo, o nome da subchave a remover é especificado em uma variável.

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 e Segurança

As questões de segurança com os cookies são semelhantes as das de obter dados a partir do cliente.Em seu aplicativo, cookies são uma outra forma de entrada do usuário e, portanto, sujeitos a exame e falsificação.Um usuário pode, no mínimo, ver os dados que você armazena em um cookie, uma vez que o cookie está disponível no computador do próprio usuário.O usuário também pode alterar o cookie antes de o navegador enviá-lo para você.

Você nunca deve armazenar dados confidenciais em um cookie, como nomes de usuário, senhas, números de cartão de crédito e assim por diante.Não coloque tudo em um cookie que não deve estar nas mãos de um usuário ou de alguém que possa de alguma forma roubar o cookie.

Da mesma forma, suspeite de informações que você obtiver de um cookie.Não presuma que os dados são os mesmos que quando você gravou-os fora; use as mesmas proteções para trabalhar com valores de cookie que você usaria com os dados que um usuário tiver digitou em um página da Web.Os exemplos neste tópico anteriormente mostraram a codificação HTML do conteúdo de um cookie antes de exibir o valor em uma página, como você faria antes de exibir quaisquer informações que você obtivesse de usuários.

Cookies são enviados entre o navegador e o servidor como texto sem-formatação, e qualquer pessoa que possa interceptar o tráfego da Web pode ler o cookie.Você pode definir uma propriedade de cookie que faz com que o cookie seja transmitido somente se a conexão use o Secure Sockets Layer (SSL).SSL não protege o cookie de ser lido ou manipulado enquanto ele estiver no computador do usuário, mas ela impede que o cookie seja lido enquanto em trânsito, já que o cookie é criptografado.Para obter mais informações, consulte Práticas de segurança básica para aplicativos da Web.

Determinando Se um Navegador Aceita Cookies

Os usuários podem configurar seus navegadores para recusarem cookies.Nenhum erro é gerado se um cookie não puder ser gravado.O navegador também não envia quaisquer informações para o servidor sobre as configurações atuais do seu cookie.

Observação:

O Cookies propriedade não indica se os cookies estejam ativados. Ela indica somente se o navegador atual inerentemente oferece suporte a cookies.

Uma maneira para determinar se os cookies são aceitos é tentar gravar um cookie e, em seguida, tentar lê-lo de volta novamente.Se você não pode ler o cookie que você gravou, você assume que cookies estão desativados no navegador.

O exemplo de código a seguir mostra como você pode testar se os cookies são aceitos.O exemplo consiste de duas páginas.A primeira página grava um cookie e então redireciona o navegador para a segunda página.A segunda página tenta ler o cookie.Ela, por sua vez, redireciona o navegador de volta para a primeira página, adicionando à URL uma variável de sequência de caracteres da consulta com os resultados do teste.

O código para a primeira página parece com esse:

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

The page first tests to see if this is a postback, and if not, the page looks for the query string variable name AcceptsCookies that contains the test results.If there is no query string variable, the test has not been completed, so the code writes out a cookie named TestCookie.Depois de escrever o cookie, o exemplo chama Redirect transferência para a página de teste TestForCookies.aspx. Acrescentados à URL da página de teste é uma consulta de seqüência de caracteres variável chamada redirect com o URL da página corrente; isso permitirá que redirecionar novamente para esta página após a execução do teste.

The test page can consist entirely of code; it does not need to contain controls.The following code example illustrates the test page.

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

After reading the redirect query string variable, the code tries to read the cookie.For housekeeping purposes, if the cookie exists, it is immediately deleted.When the test is finished, the code constructs a new URL from the URL passed to it in the redirect query string variable.The new URL also includes a query string variable containing test results.The final step is to use the new URL to redirect the browser to the original page.

An improvement in the example would be to keep the cookie test results in a persistent store such as a database so that the test does not have to be repeated each time the user views the original page.(Storing the test results in session state by default requires cookies.)

Cookies and Session State

When a user navigates to your site, the server establishes a unique session for that user that lasts for the duration of the user's visit.For each session, ASP.NET maintains session state information where applications can store user-specific information.For more information, see Visão geral sobre Estado de sessão ASP.NET topic.

ASP.NET must track a session ID for each user so that it can map the user to session state information on the server.By default, ASP.NET uses a non-persistent cookie to store the session state.However, if a user has disabled cookies on the browser, session state information cannot be stored in a cookie.

ASP.NET offers an alternative in the form of cookieless sessions.You can configure your application to store session IDs not in a cookie, but in the URLs of pages in your site.If your application relies on session state, you might consider configuring it to use cookieless sessions.However, under some limited circumstances, if the user shares the URL with someone else—perhaps to send the URL to a colleague while the user's session is still active—then both users can end up sharing the same session, with unpredictable results.For more information on configuring your application to use cookieless sessions, see the Visão Geral sobre o Gerenciamento de Estado do ASP.NET topic.

Voltar ao topo

Exemplos de código

QuickStarts

Tópicos Como Fazer e Passo a passo

Como: Personalizar o cookie de autenticação do serviço de autenticação do WCF

Voltar ao topo

Referência de Classe

HttpCookie

Provides a type-safe way to create and manipulate individual HTTP cookies.

Cookies

Gets the response cookie collection.

Cookies

Gets a collection of cookies sent by the client.

Voltar ao topo

Recursos adicionais

Voltar ao topo

O que há de novo

Voltar ao topo

Consulte também

Conceitos

Visão Geral sobre o Gerenciamento de Estado do ASP.NET

Referência

Voltar ao topo