Información general sobre las cookies en ASP.NET
Actualización: noviembre 2007
Una cookie es un pequeño fragmento de texto que acompaña a las solicitudes y a las páginas mientras éstas se transmiten del servidor Web al explorador y viceversa. La cookie contiene información que la aplicación Web puede leer cada vez que el usuario visita el sitio.
Este tema contiene:
Escenarios
Background
Ejemplos de código
Referencia de clase
Recursos adicionales
Lo nuevo
Escenarios
Las cookies proporcionan un medio para almacenar información específica del usuario en las aplicaciones Web. Por ejemplo, cuando un usuario visita un sitio, las cookies pueden emplearse para almacenar las preferencias del usuario u otra información. Cuando el usuario visite el sitio Web de nuevo, la aplicación podrá recuperar la información que almacenó previamente.
Volver al principio
Background
Una cookie es un pequeño fragmento de texto que acompaña a las solicitudes y a las páginas mientras éstas se transmiten del servidor Web al explorador y viceversa. La cookie contiene información que la aplicación Web puede leer cada vez que el usuario visita el sitio.
Por ejemplo, si un usuario solicita una página de un sitio y la aplicación no solo envía una página, sino también una cookie que contiene la fecha y la hora, cuando el explorador del usuario obtenga la página, también obtendrá la cookie, que se almacenará en una carpeta en el disco duro del usuario.
Más adelante, si el usuario solicita de nuevo una página del mismo sitio, cuando introduzca la dirección URL, el explorador buscará en el disco duro local una cookie asociada a dicha dirección. Si la cookie existe, el explorador la enviará al sitio junto con la solicitud de la página. A continuación, la aplicación podrá determinar la fecha y hora en que el usuario visitó el sitio por última vez. Podría utilizar dicha información para mostrar un mensaje al usuario o comprobar una fecha de expiración.
Las cookies están asociadas a un sitio Web, no a una página específica, por lo que el explorador y el servidor intercambiarán información de cookies independientemente de la página que el usuario solicite en su sitio. Todos los sitios que visita el usuario pueden enviar una cookie al explorador del usuario; éste las almacenará independientemente.
Las cookies permiten a los sitios Web almacenar información sobre los visitantes. De forma más general, las cookies son una manera de mantener la continuidad en una aplicación Web, es decir, de realizar la administración de estados. Excepto durante los breves momentos en los que están realmente intercambiando información, el explorador y el servidor Web están desconectados. Las solicitudes que realiza un usuario a un servidor Web se tratan por separado unas de las otras. Sin embargo, muchas veces, es útil para el servidor Web reconocer a los usuarios cuando solicitan una página. Por ejemplo, el servidor Web de un sitio de compras efectúa el seguimiento de cada uno de los compradores para poder administrar los carros de la compra y la información específica del usuario. Por consiguiente, una cookie actúa como una especie de tarjeta de llamada, que presenta la identificación necesaria para que la aplicación sepa cómo continuar.
Las cookies se utilizan para muchos propósitos, todos ellos destinados a facilitar al sitio Web el reconocimiento de los usuarios. Por ejemplo, un sitio que lleva a cabo un sondeo podría utilizar una cookie simplemente como un valor booleano para indicar si el explorador del usuario ya ha participado en la votación, a fin de evitar que el usuario vote dos veces. Un sitio que solicita a un usuario que inicie una sesión podría utilizar una cookie para registrar dicho inicio de sesión a fin de que el usuario no tenga que seguir proporcionando sus credenciales.
Limitaciones de las cookies
La mayoría de los exploradores admiten cookies de un tamaño máximo de 4096 bytes. Debido a este límite, es recomendable utilizar las cookies para almacenar pequeñas cantidades de datos, o mejor aún, un identificador como un id. de usuario. Este id. se puede utilizar para identificar al usuario y leer información relativa a éste de una base de datos u otro almacén de datos. (Vea la sección "Las cookies y la seguridad" más adelante para obtener información sobre las implicaciones de seguridad del almacenamiento de información sobre el usuario.)
Los exploradores también imponen limitaciones respecto al número de cookies que cada sitio puede almacenar en el equipo del usuario. La mayoría de los exploradores sólo permiten 20 cookies por sitio; si se intenta almacenar más, las cookies más antiguas se descartan. Algunos exploradores también definen un límite absoluto, normalmente 300, en cuanto al número de cookies que aceptan desde todos los sitios en conjunto.
Una limitación de las cookies con la que podría encontrarse es que los usuarios pueden configurar sus exploradores para rechazarlas. Si define una directiva de privacidad P3P y la coloca en la raíz de su sitio Web, habrá más exploradores que acepten cookies de su sitio. Sin embargo, podría ser necesario evitar por completo las cookies y utilizar otro mecanismo para almacenar información específica del usuario. Un método común para almacenar información sobre el usuario es el estado de sesión, pero éste depende de las cookies, tal y como se explica más adelante en la sección "Las cookies y el estado de sesión".
.gif "Nota") Nota: |
|---|
Para obtener más información sobre la administración de estado y las opciones para guardar información en una aplicación Web, vea Información general sobre la administración de estados de ASP.NET y Recomendaciones de administración de estado de ASP.NET. |
Aunque las cookies pueden ser muy útiles en su aplicación, ésta no debería depender exclusivamente de ellas. No las utilice para implementar características importantes. Si su aplicación debe depender de las cookies, puede comprobar si el explorador las aceptará. Vea la sección "Comprobar si un explorador acepta cookies" más adelante en este tema.
Escribir cookies
En un sistema de usuario, el explorador es el responsable de la administración de las cookies. Éstas se envían al explorador a través del objeto HttpResponse, que expone una colección denominada Cookies. Puede tener acceso al objeto HttpResponse como la propiedad Response de la clase Page. Las cookies que desee enviar al explorador se deben agregar a esta colección. Al crear una cookie, debe especificar las propiedades Name y Value. Cada una de las cookies debe tener un nombre único a fin de que después se las pueda identificar al leerlas desde el explorador. Dado que las cookies se almacenan por nombre, asignar el mismo nombre a dos cookies ocasionará que una de ellas se sobrescriba.
También se puede establecer la fecha y hora de expiración de una cookie. El explorador elimina las cookies expiradas cuando un usuario visita el sitio que las escribió. La expiración de una cookie debería establecerse en función del tiempo que su aplicación considere que el valor de la misma seguirá siendo válido. Para que una cookie no expire nunca, puede establecer la fecha de expiración en 50 años a partir de ahora.
| Nota: |
|---|
Los usuarios pueden borrar las cookies de su equipo en cualquier momento. Aunque almacene cookies con períodos de expiración largos, un usuario puede decidir eliminarlas y así destruir toda la información que se haya almacenado en ellas. |
Si no establece la expiración de la cookie, ésta se crea pero no se almacena en el disco duro del usuario. En su lugar, la cookie se mantiene como parte de la información de sesión del usuario. Cuando el usuario cierra el explorador, la cookie se descarta. Una cookie no persistente de este tipo resulta útil para la información que se debe almacenar durante períodos cortos de tiempo o que, por motivos de seguridad, no se debería escribir en el disco del equipo cliente. Por ejemplo, las cookies no persistentes son útiles si el usuario está trabajando en un equipo público en cuyo disco no desea que se escriba la cookie.
Puede agregar cookies a la colección Cookies de varias maneras. El ejemplo siguiente muestra dos métodos para escribir 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);
El ejemplo agrega dos cookies a la colección Cookies, una denominada userName y la otra denominada lastVisit. Para la primera cookie, los valores de la colección Cookies se establecen directamente. Puede agregar valores a la colección de esta forma porque Cookies se deriva de una colección especializada de tipo NameObjectCollectionBase.
Para la segunda cookie, el código crea una instancia de un objeto de tipo HttpCookie, establece sus propiedades y, a continuación, lo agrega a la colección Cookies a través del método Add. Cuando se crea una instancia de un objeto HttpCookie, se debe pasar el nombre de la cookie como parte del constructor.
Ambos ejemplos llevan a cabo la misma tarea: escriben una cookie en el explorador. En ambos métodos, el valor de expiración debe ser de tipo DateTime. Sin embargo, el valor lastVisited también es un valor de fecha y hora. Dado que todos los valores de las cookies se almacenan como cadenas, el valor de fecha y hora se tiene que convertir en un objeto String.
Cookies con varios valores
Puede almacenar un valor en una cookie, como el nombre de usuario y la última visita. También puede almacenar varios pares de nombre y valor en una sola cookie. Estos pares de nombre y valor se denominan subclaves. (Las subclaves se disponen de forma similar a una cadena de consulta en una dirección URL.) Por ejemplo, en lugar de crear dos cookies independientes denominadas userName y lastVisit, puede crear una sola cookie denominada userInfo que tenga las subclaves userName y lastVisit.
Son varias las razones que hacen aconsejable el uso de subclaves. En primer lugar, es conveniente colocar la información relacionada o similar en una sola cookie. Además, dado que toda la información está en una sola cookie, los atributos de ésta, como la expiración, se aplican a toda la información. (A la inversa, si desea asignar distintas fechas de expiración a distintos tipos de información, debería almacenar ésta en cookies independientes.)
Además, una cookie con subclaves también le ayudará a limitar el tamaño de los archivos de cookies. Tal y como se ha indicado en la sección "Limitaciones de las cookies", las cookies generalmente están limitadas a 4096 bytes y no se pueden almacenar más de 20 cookies por sitio. Si utiliza una sola cookie con subclaves, empleará menos de las 20 cookies asignadas a su sitio. Además, una sola cookie ocupa unos 50 caracteres para la sobrecarga (información de expiración, etc.), más la longitud del valor que almacene en ella, cantidades que hay que restar del límite de 4096 bytes. Si almacena cinco subclaves en lugar de cinco cookies independientes, evita la sobrecarga de las cookies independientes y puede ahorrar alrededor de 200 bytes.
Para crear una cookie con subclaves, puede utilizar una variación de la sintaxis que se emplea para escribir una sola cookie. En el ejemplo siguiente se muestran dos maneras de escribir la misma cookie, cada una con dos subclaves:
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);
Controlar el ámbito de las cookies
De forma predeterminada, todas las cookies de un sitio se almacenan juntas en el cliente y todas ellas se envían al servidor con cualquier solicitud para ese sitio. Es decir, cada página de un sitio obtiene todas las cookies para ese sitio. Sin embargo, puede establecer el ámbito de las cookies de dos maneras:
Limite el ámbito de las cookies a una carpeta del servidor, lo que le permitirá limitar las cookies a una aplicación del sitio.
Establezca el ámbito en un dominio, lo que le permitirá especificar los subdominios de un dominio que pueden tener acceso a una cookie.
Limitar las cookies a una carpeta o aplicación
Para limitar las cookies a una carpeta del servidor, establezca la propiedad Path de la cookie, como en el ejemplo siguiente:
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: |
|---|
También puede escribir cookies agregándolas directamente a la colección Cookies, como se ha mostrado en ejemplos anteriores. |
La ruta de acceso puede ser una ruta de acceso física situada bajo la raíz del sitio o una raíz virtual. El efecto conseguido será que la cookie sólo estará disponible para las páginas de la carpeta Application1 o para la raíz virtual. Por ejemplo, si su sitio se denomina www.contoso.com, la cookie creada en el ejemplo anterior estará disponible para las páginas cuya ruta de acceso sea https://www.contoso.com/Application1/ y para las páginas situadas bajo dicha carpeta. Sin embargo, la cookie no estará disponible para las páginas de otras aplicaciones, como https://www.contoso.com/Application2/ o https://www.contoso.com/.
| Nota: |
|---|
En algunos exploradores, la ruta de acceso distingue entre mayúsculas y minúsculas. No es posible controlar la forma en la que los usuarios escriben las direcciones URL en sus exploradores, pero si su aplicación depende de cookies vinculadas a una ruta de acceso determinada, asegúrese de que el formato de mayúsculas y minúsculas de las direcciones URL de los hipervínculos que cree coincide con el del valor de la propiedad Path. |
Limitar el ámbito de dominio de las cookies
De forma predeterminada, las cookies se asocian a un dominio específico. Por ejemplo, si su sitio es www.contoso.com, las cookies que escriba se envían al servidor cuando los usuarios solicitan una página de ese sitio. (Esto podría no incluir las cookies que tengan un valor de ruta de acceso determinado.) Si su sitio tiene subdominios, por ejemplo, contoso.com, sales.contoso.com y support.contoso.com, puede asociar las cookies a un subdominio concreto. Para ello, establezca la propiedad Domain de la cookie, como en este ejemplo:
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";
Cuando el dominio se establece de esta manera, la cookie sólo estará disponible para las páginas del subdominio especificado. También puede utilizar la propiedad Domain para crear una cookie que se pueda compartir entre varios subdominios, como se muestra en el ejemplo siguiente:
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";
De esta manera, la cookie estará disponible para el dominio principal, así como para los dominios sales.contoso.com y support.contoso.com.
Leer las cookies
Cuando un explorador realiza una solicitud al servidor, envía las cookies para ese servidor junto con la solicitud. En sus aplicaciones ASP.NET, puede leer las cookies mediante el objeto HttpRequest, que está disponible como propiedad Request de la clase Page. La estructura del objeto HttpRequest es esencialmente la misma que la del objeto HttpResponse, por lo que la lectura de las cookies del objeto HttpRequest se realiza de manera similar a la escritura de las cookies en el objeto HttpResponse. En el ejemplo de código siguiente se muestran dos maneras de obtener el valor de una cookie denominada username y mostrar su valor en un control 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 intentar obtener el valor de una cookie, debería asegurarse de que dicha cookie existe; si no es así, se iniciará una excepción NullReferenceException. Tenga en cuenta también que se ha llamado al método HtmlEncode para codificar el contenido de una cookie antes de mostrarlo en la página. Esto garantiza que un usuario malintencionado no ha agregado un script ejecutable a la cookie. Para obtener más información sobre la seguridad de las cookies, vea la sección "Las cookies y la seguridad".
| Nota: |
|---|
Dado que cada explorador almacena las cookies de forma diferente, es posible que un explorador no sea capaz de leer las cookies de los demás exploradores instalados en el mismo equipo. Por ejemplo, si utiliza Internet Explorer para probar una página una vez, pero más adelante utiliza otro explorador para realizar una nueva prueba, el segundo explorador no encontrará las cookies guardadas por Internet Explorer. |
Del mismo modo, la lectura del valor de una subclave de una cookie es similar a su establecimiento. En el ejemplo de código siguiente se muestra una manera de obtener el valor de una subclave:
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"]);
}
En el ejemplo anterior, el código lee el valor de la subclave lastVisit, que se estableció previamente en la representación de cadena de un valor DateTime. Las cookies almacenan valores en forma de cadenas, por lo que si desea utilizar el valor lastVisit como fecha, debe convertirlo al tipo apropiado, como en este ejemplo:
Dim dt As DateTime
dt = DateTime.Parse(Request.Cookies("userInfo")("lastVisit"))
DateTime dt;
dt = DateTime.Parse(Request.Cookies["userInfo"]["lastVisit"]);
Las subclaves de una cookie son una colección de tipo NameValueCollection. Por consiguiente, otra manera de obtener una subclave determinada es obtener la colección de subclaves y, a continuación, extraer el valor de la subclave por su nombre, como se muestra en el ejemplo siguiente:
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"]);
}
Cambiar la fecha de expiración de una cookie
El explorador es responsable de administrar las cookies, y la fecha y hora de expiración de éstas le ayudan a administrar su almacén de cookies. Por consiguiente, aunque un usuario puede leer el nombre y el valor de una cookie, no puede leer su fecha y hora de expiración. Cuando el explorador envía la información de las cookies al servidor, no incluye la información de expiración. (La propiedad Expires de las cookies siempre devuelve un valor de fecha y hora de cero.) Si le preocupa la fecha de expiración de una cookie, deberá restablecerla; esta operación se describe en la sección "Modificar y eliminar las cookies".
| Nota: |
|---|
Puede leer la propiedad Expires de una cookie que haya establecido en el objeto HttpResponse antes de que la cookie se enviara al explorador. Sin embargo, no puede volver a obtener la expiración en el objeto HttpRequest. |
Leer colecciones de cookies
Es posible que en algún momento necesite leer todas las cookies disponibles para la página. Para leer los nombres y los valores de todas las cookies disponibles para la página, puede recorrer la colección Cookies mediante código como el siguiente.
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: |
|---|
Cuando ejecute este código, es posible que aparezca una cookie denominada ASP.NET_SessionId. ASP.NET la utiliza para almacenar un identificador único para la sesión. La cookie de sesión no se conserva en su disco duro. Para obtener más información sobre las cookies de sesión, vea la sección "Las cookies y el estado de sesión" más adelante en este tema. |
Una limitación del ejemplo anterior es que si la cookie tiene subclaves, la presentación las muestra como una sola cadena de nombre y valor. Puede leer la propiedad HasKeys de una cookie para determinar si ésta tiene subclaves. En ese caso, puede leer la colección de subclaves para obtener nombres y valores de subclaves individuales. Puede leer directamente valores de subclaves de la colección Values por valor de índice. Los nombres de las subclaves correspondientes están disponibles en el miembro AllKeys de la colección Values, que devuelve una matriz de cadenas. También puede utilizar el miembro Keys de la colección Values. Sin embargo, la propiedad AllKeys se almacena en la caché la primera vez que se tiene acceso a ella. Por el contrario, cada vez que se tiene acceso a la propiedad Keys, ésta crea una matriz. Por este motivo, la propiedad AllKeys es mucho más rápida en accesos posteriores dentro del contexto de la misma solicitud de página.
En el ejemplo siguiente se muestra una modificación del ejemplo anterior. Se utiliza la propiedad HasKeys para comprobar la existencia de subclaves y si éstas se detectan, el ejemplo las obtiene de la colección 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();
Opcionalmente, puede extraer las subclaves como un objeto NameValueCollection, tal como se muestra en el ejemplo siguiente:
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();
Modificar y eliminar las cookies
No es posible modificar directamente una cookie. En su lugar, el proceso que se debe seguir consiste en crear una nueva cookie con nuevos valores y, a continuación, enviarla al explorador para que sobrescriba la versión antigua en el cliente. En el ejemplo de código siguiente se muestra cómo modificar el valor de una cookie que almacena un recuento de las visitas del usuario al sitio:
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);
Eliminar las cookies
La eliminación de una cookie, es decir, quitarla físcamente del disco duro del usuario, es una variación del proceso de modificación. No es posible quitar directamente una cookie, ya que se encuentra en el equipo del usuario. Sin embargo, puede conseguir que el explorador la elimine. La técnica consiste en crear una nueva cookie con el mismo nombre que la cookie que se desea eliminar, pero estableciendo su expiración en una fecha anterior a la actual. Cuando el explorador compruebe la expiración de la cookie, la descartará porque está anticuada. En el ejemplo de código siguiente se muestra una manera de eliminar todas las cookies disponibles para la aplicación:
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);
}
Modificar o eliminar las subclaves
El proceso de modificación de una subclave determinada es igual que el de creación, como se muestra en el ejemplo siguiente:
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 eliminar una subclave determinada, manipule la colección Values de la cookie, que contiene las subclaves. En primer lugar, obtenga la cookie del objeto Cookies y vuelva a crearla. A continuación, llame al método Remove de la colección Values y pase al método Remove el nombre de la subclave que desea eliminar. Por último, agregue la cookie a la colección Cookies para que se envíe otra vez, ya modificada, al explorador. En el ejemplo de código siguiente se muestra cómo eliminar una subclave. En el ejemplo, el nombre de la subclave que se desea quitar se especifica en una 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);
Las cookies y la seguridad
Los problemas de seguridad relacionados con las cookies son similares a los producidos por recibir datos del cliente. En una aplicación, las cookies son otro tipo de datos proporcionados por el usuario y, por consiguiente, están expuestos al examen y a la suplantación. Como mínimo, el usuario puede ver los datos almacenados en una cookie, ya que ésta se encuentra disponible en el propio equipo del usuario. También puede cambiar la cookie antes de que el explorador la envíe a su aplicación.
Nunca debería almacenar datos confidenciales en una cookie, por ejemplo nombres de usuario, contraseñas, números de tarjeta de crédito, etc. Jamás almacene en una cookie nada que no debiera estar en las manos de un usuario o de alguien que pudiera robar la cookie.
De manera similar, sospeche de la información que obtenga de una cookie. No dé por sentado que los datos son los mismos que escribió; al trabajar con valores de cookies utilice los mismos elementos de seguridad que con los datos proporcionados por un usuario en una página Web. En los ejemplos anteriores de este tema se mostraba la codificación HTML del contenido de una cookie antes de mostrar el valor en una página, tal y como se haría antes de mostrar cualquier información obtenida de los usuarios.
Las cookies se envían entre el explorador y el servidor como texto sin formato y cualquiera que pueda interceptar el tráfico Web puede leer la cookie. Si lo desea, puede establecer una propiedad de cookie que hace que ésta sólo se transmita si la conexión utiliza Secure Sockets Layer (SSL). SSL no impide la lectura ni la manipulación de la cookie mientras se encuentra en el equipo del usuario, pero impide su lectura mientras se encuentra en tránsito, dado que la cookie está cifrada. Para obtener más información, vea Procedimientos de seguridad básicos para aplicaciones Web.
Determinar si un explorador acepta cookies
Los usuarios pueden configurar su explorador para que rechace las cookies. No se produce ningún error si no se puede escribir una cookie. De igual modo, el explorador no envía ninguna información al servidor sobre su configuración de cookies actual.
| Nota: |
|---|
La propiedad Cookies no indica si las cookies están habilitadas. Sólo indica si el explorador actual admite cookies de forma inherente. |
Una manera de determinar si se aceptan las cookies consiste en intentar escribir una cookie y, a continuación, intentar leerla. Si no puede leer la cookie que ha escrito, debería dar por supuesto que las cookies están desactivadas en el explorador.
En el ejemplo de código siguiente se muestra cómo podría comprobar si se aceptan las cookies. El ejemplo consta de dos páginas. La primera página escribe una cookie y, a continuación, redirige el explorador a la segunda página. La segunda página intenta leer la cookie. A su vez, redirige el explorador otra vez a la primera página y agrega a la dirección URL una variable de cadena de consulta con los resultados de la prueba.
El código de la primera página tiene esta apariencia:
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"]);
}
}
}
En primer lugar, la página comprueba si se trata de una devolución de datos; si no es así, busca el nombre de la variable de cadena de consulta AcceptsCookies que contiene los resultados de la prueba. Si no hay ninguna variable de cadena de consulta, no se ha finalizado la comprobación, por lo que el código escribe una cookie denominada TestCookie. Después de escribir la cookie, el ejemplo llama a Redirect para transferir TestForCookies.aspx a la página de prueba. Se anexa a la dirección URL de la página de prueba una variable de cadena de consulta denominada redirect que contiene la dirección URL de la página actual; esto permite redirigir el explorador de nuevo a esta página después de realizar la prueba.
La página de prueba puede contener únicamente código; no es necesario que contenga controles. El ejemplo de código siguiente muestra la página de prueba.
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);
}
Después de leer la variable de cadena de consulta de redirección, el código intenta leer la cookie. Por razones de mantenimiento, si la cookie existe, se elimina inmediatamente. Cuando finaliza la prueba, el código construye una nueva dirección URL a partir de la dirección URL pasada en la variable de cadena de consulta redirect. La nueva dirección URL también incluye una variable de cadena de consulta que contiene los resultados de la prueba. El último paso consiste en utilizar la nueva dirección URL para redirigir el explorador a la página original.
Una mejora que se podría realizar en el ejemplo sería conservar los resultados de la prueba de la cookie en un almacén persistente, como una base de datos, para que la prueba no se tenga que repetir cada vez que el usuario visite la página original. (De forma predeterminada, el almacenamiento de los resultados de la prueba en el estado de sesión requiere cookies.)
Las cookies y el estado de sesión
Cuando un usuario navega en su sitio, el servidor establece para dicho usuario una sesión única que termina cuando finalice la visita. En cada sesión, ASP.NET mantiene información de estado de sesión donde las aplicaciones pueden almacenar información específica del usuario. Para obtener más información, vea el tema Información general sobre el estado de sesión de ASP.NET.
ASP.NET debe realizar el seguimiento de un id. de sesión para cada usuario con objeto de poder asignar el usuario a la información de estado de sesión en el servidor. De forma predeterminada, ASP.NET utiliza una cookie no persistente para almacenar el estado de sesión. Sin embargo, si un usuario ha deshabilitado las cookies en el explorador, la información de estado de sesión no se puede almacenar en una cookie.
ASP.NET proporciona una alternativa en forma de sesiones sin cookies. Puede configurar su aplicación para que almacene los identificadores de sesión en las direcciones URL de las páginas de su sitio, en lugar de almacenarlos en las cookies. Si su aplicación se basa en el estado de sesión, debería tener en cuenta configurarla para que utilice sesiones sin cookies. Sin embargo, en unos cuantos casos, si el usuario comparte la dirección URL con otra persona (por ejemplo, para enviar dicha dirección a un colega mientras esté activa la sesión del usuario), es posible que ambos usuarios terminen compartiendo la misma sesión y los resultados serían impredecibles. Para obtener más información sobre cómo configurar su aplicación para que utilice sesiones sin cookies, vea el tema Información general sobre la administración de estados de ASP.NET.
Volver al principio
Ejemplos de código
Tutoriales rápidos
Administración del estado de la aplicación
Temas "Cómo..." y tutoriales
Cómo: Personalizar la cookie de autenticación desde el servicio de autenticación de WCF
Volver al principio
Referencia de clase
Proporciona un método con seguridad de tipos para crear y manipular cookies HTTP individuales. |
|
Obtiene la colección de cookies de respuesta. |
|
Obtiene una colección de cookies enviada por el cliente. |
Volver al principio
Recursos adicionales
Volver al principio
Lo nuevo
Volver al principio
Vea también
Conceptos
Información general sobre la administración de estados de ASP.NET
Referencia
Volver al principio