Übersicht über ASP.NET-Cookies

  • Artikel

Aktualisiert: November 2007

Ein Cookie ist ein kurzer Text, der Anforderungen und Seiten beim Austausch zwischen Webserver und Browser begleitet. Das Cookie enthält Informationen, die von der Webanwendung immer dann gelesen werden können, wenn der Benutzer die Site besucht.

Dieses Thema enthält folgende Abschnitte:

  • Szenarien

  • Background

  • Codebeispiele

  • Klassenreferenz

  • Zusätzliche Ressourcen

  • Neues

Szenarien

Mit Cookies können Sie in Webanwendungen benutzerspezifische Informationen speichern. Sie können Cookies dazu verwenden, die Benutzereinstellungen eines Seitenbesuchers oder andere Informationen zu speichern. Wenn der Benutzer die Website ein weiteres Mal besucht, kann die Anwendung die zuvor gespeicherten Informationen abrufen.

Zurück nach oben

Background

Ein Cookie ist ein kurzer Text, der Anforderungen und Seiten beim Austausch zwischen Webserver und Browser begleitet. Das Cookie enthält Informationen, die von der Webanwendung immer dann gelesen werden können, wenn der Benutzer die Site besucht.

Wenn z. B. ein Benutzer eine Seite von einer Website anfordert und die Anwendung zusätzlich zur Seite ein Cookie mit Datum und Uhrzeit versendet, dann empfängt der Browser des Benutzers das Cookie zusammen mit der Seite und speichert es in einem Ordner auf der Festplatte.

Wenn der Benutzer zu einem späteren Zeitpunkt erneut eine Seite von dieser Website anfordert, dann sucht der Browser beim Eingeben der URL auf der Festplatte nach dem Cookie, das der URL zugeordnet ist. Wenn das Cookie vorhanden ist, sendet der Browser das Cookie zusammen mit der Seitenanforderung an die Site. Die Anwendung kann dann bestimmen, an welchem Tag und zu welcher Zeit der Benutzer die Site zuletzt besucht hat. Sie können diese Informationen verwenden, um dem Benutzer eine Nachricht anzuzeigen oder um ein Ablaufdatum zu prüfen.

Cookies sind einer kompletten Website und nicht einer einzelnen Seite zugeordnet. Für den Austausch von Cookieinformationen zwischen Browser und Server spielt es also keine Rolle, welche Seite einer Site der Benutzer anfordert. Wenn der Benutzer andere Sites besucht, können auch diese Sites ein Cookie an den Browser des Benutzers senden. Alle Cookies werden vom Browser voneinander getrennt gespeichert.

Cookies unterstützen Websites beim Speichern von Benutzerinformationen. Cookies sind ein Mittel, um die Kontinuität innerhalb einer Webanwendung aufrechtzuerhalten, d. h. ein Mittel zur Zustandsverwaltung. Bis auf die kurze Zeit des Informationsaustauschs sind Browser und Webserver voneinander getrennt. Jede Anforderung an einen Webserver durch den Benutzer wird unabhängig von anderen Anforderungen behandelt. Oft ist es für den Webserver jedoch nützlich zu wissen, welcher Benutzer die Seite gerade anfordert. Der Webserver einer Einkaufssite behält so z. B. die Übersicht über die einzelnen Einkaufenden, und die Site kann die Einkaufswagen und andere benutzerspezifische Informationen verwalten. Das Cookie funktioniert als eine Art Visitenkarte, über deren einschlägige Identifizierungsmerkmale die Anwendung weiß, wie sie fortzufahren hat.

Cookies werden für viele verschiedene Zwecke der Benutzeridentifikation auf Websites verwendet. Wenn auf einer Site z. B. eine Umfrage erhoben wird, dann kann eine Site über ein Cookie mit booleschem Wert bestimmen, ob der Browser des Benutzers bereits an der Umfrage teilgenommen hat und deswegen nicht erneut an der Abstimmung teilnehmen darf. Ein Cookie kann auf einer anmeldungspflichtigen Site verwendet werden, um festzustellen, ob ein Benutzer bereits angemeldet ist und er dementsprechend seine Anmeldeinformationen nicht erneut eingeben muss.

Cookieeinschränkungen

Die meisten Browser unterstützen Cookies mit einer Größe von bis zu 4096 Bytes. Aufgrund ihrer eingeschränkten Größe eignen sich Cookies am besten zum Speichern von kleinen Datenmengen oder sogar nur eines Bezeichners wie einer Benutzer-ID. Die Benutzer-ID kann dann zur Identifikation des Benutzers verwendet werden, um Benutzerinformationen aus einer Datenbank oder von einem anderen Datenspeicher abzufragen. (Informationen zu Sicherheitsaspekten beim Speichern von Benutzerinformationen finden Sie im Abschnitt "Cookies und Sicherheit".)

Über den Browser wird festgelegt, wie viele Cookies eine Site auf dem Computer des Benutzers speichern darf. Die meisten Browser lassen maximal 20 Cookies pro Site zu. Bei dem Versuch, weitere Cookies zu speichern, werden die ältesten Cookies verworfen. Einige Browser legen zusätzlich eine absolute Grenze für die Gesamtanzahl von Cookies für alle Sites zusammen fest, die in der Regel bei 300 liegt.

Ein Problem von Cookies ist, dass Benutzer ihre Browser so einstellen können, dass Cookies abgelehnt werden. Wenn Sie eine P3P-Datenschutzrichtlinie definieren und diese im Stammverzeichnis der Website ablegen, erhöht das die Wahrscheinlichkeit, dass Cookies von Browsern angenommen werden. Unter Umständen müssen Sie ganz auf Cookies verzichten und einen anderen Weg finden, um benutzerspezifische Informationen zu speichern. Eine häufige Methode zum Speichern von Benutzerinformationen ist der Sitzungszustand, der allerdings auf Cookies angewiesen ist. Weitere Informationen hierzu finden Sie im Abschnitt "Cookies und Sitzungszustand".

Hinweis:

Weitere Informationen zur Zustandsverwaltung und über die Möglichkeiten zum Speichern von Informationen in einer Webanwendung finden Sie unter Übersicht über die ASP.NET-Zustandsverwaltung und Empfehlungen zur ASP.NET-Zustandsverwaltung.

Obwohl Cookies in einer Anwendung sehr nützlich sein können, sollte die Anwendung nicht auf die Möglichkeit zum Speichern von Cookies angewiesen sein. Verwenden Sie Cookies nicht als Unterstützung für zentrale Features. Wenn die Anwendung auf Cookies angewiesen ist, können Sie testen, ob der Browser die Cookies annimmt. Siehe dazu den Abschnitt "Prüfen, ob ein Browser Cookies annimmt" weiter unten in diesem Thema.

Schreiben von Cookies

Für die Verwaltung von Cookies auf dem Benutzersystem ist der Browser zuständig. Zum Senden von Cookies an den Browser wird das HttpResponse-Objekt verwendet, das eine Auflistung mit dem Namen Cookies verfügbar macht. Sie können auf das HttpResponse-Objekt über die Response-Eigenschaft der Page-Klasse zugreifen. Alle Cookies, die an den Browser gesendet werden sollen, müssen dieser Auflistung hinzugefügt werden. Beim Erstellen eines Cookies müssen Sie Name und Value angeben. Jedes Cookie muss einen eindeutigen Namen haben, damit es später beim Auslesen durch den Browser identifiziert werden kann. Da Cookies anhand ihres Namens gespeichert werden, wird bei zwei gleichen Cookienamen eines der beiden Cookies überschrieben.

Sie können auch Datum und Uhrzeit für das Ablaufen eines Cookies festlegen. Abgelaufene Cookies werden vom Browser gelöscht, wenn der Benutzer die Site mit dem Cookie besucht. Die Gültigkeitsdauer eines Cookies sollte auf einen Wert festgelegt werden, der der voraussichtlichen Gültigkeit des Cookiewerts im Rahmen der Anwendung entspricht. Damit ein Cookie faktisch nie abläuft, können Sie die Gültigkeitsdauer auf 50 Jahre festlegen.

Hinweis:

Benutzer können Cookies jederzeit von ihrem Computer löschen. Selbst wenn Sie Cookies mit langer Gültigkeitsdauer speichern, kann ein Benutzer sich immer noch dazu entschließen, alle Cookies zu löschen und damit alle in den Cookies gespeicherten Einstellungen zu vernichten.

Wenn Sie für ein Cookie keine Gültigkeitsdauer festlegen, wird das Cookie zwar erstellt, jedoch nicht auf der Festplatte des Benutzers gespeichert. Stattdessen wird das Cookie als Teil der Sitzungsinformationen des Benutzers gespeichert. Wenn der Benutzer den Browser schließt, wird das Cookie verworfen. Ein solches nicht dauerhaftes Cookie bietet sich für Informationen an, die nur kurzzeitig gespeichert werden müssen oder die aus Sicherheitsgründen nicht auf die Festplatte des Clientcomputers geschrieben werden sollen. Nicht dauerhafte Cookies sind z. B. nützlich, wenn der Benutzer an einem öffentlichen Computer arbeitet und Sie das Cookie nicht auf die Festplatte schreiben möchten.

Sie können der Cookies-Auflistung auf verschiedene Arten Cookies hinzufügen. Das folgende Beispiel zeigt zwei Methoden für das Schreiben von 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);

In diesem Beispiel werden der Cookies-Auflistung zwei Cookies hinzugefügt: userName und lastVisit. Für das erste Cookie werden die Werte der Cookies-Auflistung direkt festgelegt. Sie können der Auflistung Werte auf diese Weise hinzufügen, da Cookies von einer spezialisierten Auflistung des Typs NameObjectCollectionBase abgeleitet ist.

Für das zweite Cookie wird im Code eine Instanz eines Objekts vom Typ HttpCookie erstellt, dann werden die Eigenschaften dieser Instanz festgelegt, und schließlich wird das Cookie mit der Add-Methode der Cookies-Auflistung hinzugefügt. Wenn Sie ein HttpCookie-Objekt instanziieren, müssen Sie den Cookienamen als Teil des Konstruktors übergeben.

Beide Beispiele führen zum gleichen Ergebnis, nämlich dass ein Cookie für den Browser geschrieben wird. Bei beiden Methoden muss der Ablaufwert vom Typ DateTime sein. Der lastVisited-Wert ist jedoch auch ein Datum-Uhrzeit-Wert. Da alle Cookiewerte als Zeichenfolgen gespeichert werden, muss der Datum-Uhrzeit-Wert in String konvertiert werden.

Cookies mit mehr als einem Wert

Sie können nur einen Wert in einem Cookie speichern, z. B den Benutzernamen und den Zeitpunkt des letzten Besuchs. Sie können aber auch mehrere Name-Wert-Paare in einem einzelnen Cookie speichern. Die Name-Wert-Paare werden als Unterschlüssel bezeichnet. (Unterschlüssel sind ähnlich wie eine Abfragezeichenfolge in einer URL aufgebaut.) Anstatt zwei getrennte Cookies, userName und lastVisit, zu erstellen, können Sie ein einzelnes Cookie mit dem Namen userInfo erstellen, das über die beiden Unterschlüssel userName und lastVisit verfügt.

Unterschlüssel sind in vielerlei Hinsicht nützlich. Zuallererst ist es bequem, verwandte oder ähnliche Informationen in nur einem Cookie zu speichern. Da sich alle Informationen in einem einzigen Cookie befinden, werden Cookieattribute wie die Gültigkeitsdauer auf alle Informationen angewendet. (Umgekehrt sollten Sie Informationen in getrennten Cookies speichern, wenn Sie den verschiedenen Informationstypen jeweils unterschiedliche Gültigkeitsdauern zuweisen möchten.)

Cookies mit Unterschlüsseln verringern außerdem die Größe von Cookiedateien. Wie bereits zuvor im Abschnitt "Cookieeinschränkungen" erwähnt, sind Cookies in der Regel auf 4096 Bytes beschränkt, und es können maximal 20 Cookies pro Site gespeichert werden. Indem Sie ein Cookie mit Unterschlüsseln verwenden, schonen Sie das Kontingent von 20 Cookies für Ihre Site. Ein einzelnes Cookie benötigt bis zu 50 Zeichen für den Overhead (Gültigkeitsdauer usw.) plus die Länge des gespeicherten Werts. Dabei wird beides auf die Grenze von 4096 Bytes angerechnet. Wenn Sie 5 Unterschlüssel statt 5 getrennter Cookies speichern, ist dafür nur ein Overhead nötig, und so sparen Sie ungefähr 200 Bytes.

Um ein Cookie mit Unterschlüsseln zu erstellen, können Sie eine Variante der Syntax zum Schreiben eines einzelnen Cookies verwenden. Das folgende Beispiel zeigt zwei Möglichkeiten zum Schreiben des gleichen Cookies mit jeweils zwei Unterschlüsseln:

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

Kontrollieren des Gültigkeitsbereichs von Cookies

Standardmäßig werden alle Cookies einer Site zusammen auf dem Clientcomputer gespeichert, und mit jeder Anforderung an die Site werden alle Cookies an den Server gesendet. Mit anderen Worten: Jeder Seite der Site stehen alle Cookies zur Verfügung. Sie können den Gültigkeitsbereich von Cookies jedoch auf zwei Arten festlegen:

  • Beschränken Sie den Gültigkeitsbereich der Cookies auf einen Ordner auf dem Server. Damit können Sie die Cookies auf eine Anwendung auf der Site beschränken.

  • Legen Sie den Gültigkeitsbereich auf eine Domäne fest. Auf diese Weise können Sie angeben, welche untergeordneten Domänen einer Domäne auf ein Cookie zugreifen können.

Beschränken von Cookies auf einen Ordner oder eine Anwendung

Um Cookies auf einen Ordner auf dem Server zu beschränken, legen Sie die Path-Eigenschaft des Cookies wie im folgenden Beispiel fest:

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

Sie können auch Cookies schreiben, indem Sie sie direkt der Cookies-Auflistung hinzufügen, wie in den vorherigen Beispielen gezeigt.

Der Pfad kann entweder ein physikalischer Pfad unter dem Sitestamm oder ein virtueller Stamm sein. Das hat zur Folge, dass das Cookie nur den Seiten im Ordner Application1 oder im virtuellen Stamm zur Verfügung steht. Wenn die Seite den Namen www.contoso.com trägt, dann steht das Cookie aus dem vorherigen Beispiel allen Seiten zur Verfügung, die unter dem Pfad https://www.contoso.com/Application1/ oder in einem darunter liegenden Verzeichnis liegen. Dagegen steht das Cookie Seiten aus anderen Anwendungen wie https://www.contoso.com/Application2/ oder https://www.contoso.com/ nicht zur Verfügung.

Hinweis:

In einigen Browsern wird bei Pfaden zwischen Groß- und Kleinschreibung unterschieden. Sie können nicht kontrollieren, wie ein Benutzer URLs in den Browser eingibt. Wenn die Anwendung auf Cookies angewiesen ist, die an einen bestimmten Pfad gebunden sind, müssen Sie sicherstellen, dass die URLs in den erstellten Links von der Groß- und Kleinschreibung her mit dem Wert der Path-Eigenschaft übereinstimmen.

Beschränken des Cookiedomänenbereichs

Standardmäßig werden Cookies einer bestimmten Domäne zugeordnet. Angenommen, die Site heißt www.contoso.com. Wenn nun ein Benutzer eine Seite dieser Site anfordert, werden automatisch die von Ihnen geschriebenen Cookies mit an den Server gesendet. (Cookies mit einem spezifischen Pfadwert können davon ausgeschlossen sein.) Wenn die Site über untergeordnete Domänen verfügt – z. B. contoso.com, sales.contoso.com und support.contoso.com – dann können Sie einer bestimmten untergeordneten Domäne Cookies zuordnen. Legen Sie dazu die Domain-Eigenschaft des Cookies wie in diesem Beispiel fest:

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

Wenn die Domäne auf diese Art festgelegt wird, steht das Cookie nur Seiten in der angegebenen untergeordneten Domäne zur Verfügung. Sie können auch die Domain-Eigenschaft verwenden, um ein Cookie zu erstellen, das von mehreren untergeordneten Domänen gemeinsam genutzt werden kann. Siehe dazu folgendes Beispiel:

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

Das Cookie steht dann der primären Domäne sowie den Domänen sales.contoso.com und support.contoso.com zur Verfügung.

Lesen von Cookies

Wenn ein Browser eine Anforderung an den Server richtet, werden zusammen mit dieser Anforderung auch die Cookies für den Server gesendet. In einer ASP.NET-Anwendung können Sie die Cookies über das HttpRequest-Objekt lesen, das als Request-Eigenschaft der Page-Klasse zur Verfügung steht. Das HttpRequest-Objekt hat praktisch die gleiche Struktur wie das HttpResponse-Objekt. Das Lesen von Cookies aus dem HttpRequest-Objekt funktioniert nicht wesentlich anders als das Schreiben von Cookies in das HttpResponse-Objekt. Das folgende Codebeispiel zeigt zwei Wege zum Abrufen des Werts eines Cookies mit dem Namen username und zum Anzeigen seiner Werte in einem Label-Steuerelement:

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

Vor dem Abrufen eines Cookiewerts sollten Sie sicher sein, dass das Cookie auch vorhanden ist. Sollte dies nicht der Fall sein, wird eine NullReferenceException ausgelöst. Beachten Sie außerdem, dass die HtmlEncode-Methode aufgerufen wurde, um den Inhalt des Cookies vor dem Anzeigen auf der Seite nach HTML zu codieren. Auf diese Weise wird sichergestellt, dass ein böswilliger Benutzer dem Cookie kein ausführbares Skript hinzugefügt hat. Mehr über Cookiesicherheit finden Sie im Abschnitt "Cookies und Sicherheit".

Hinweis:

Da verschiedene Browser Cookies unterschiedlich speichern, kann bei verschiedenen Browsern auf einem Computer der eine Browser nicht unbedingt die Cookies des anderen Browsers lesen. Wenn Sie z. B. zum Testen einer Seite Internet Explorer verwenden und zu einem späteren Zeitpunkt die gleiche Seite mit einem anderen Browser erneut testen, kann der zweite Browser die von Internet Explorer gespeicherten Cookies nicht finden.

Lesen und Festlegen eines Unterschlüsselwerts in einem Cookie funktionieren nahezu gleich. Das folgende Codebeispiel zeigt eine Möglichkeit, den Wert eines Unterschlüssels abzurufen:

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

Im vorherigen Beispiel wird im Code der Wert des Unterschlüssels lastVisit ausgelesen. Der Unterschlüssel wurde zuvor auf die Zeichenfolgendarstellung eines DateTime-Werts festgelegt. Cookiewerte werden als Zeichenfolgen gespeichert. Wenn Sie z. B. den lastVisit-Wert als Datum verwenden möchten, müssen Sie ihn wie im folgenden Beispiel in den entsprechenden Typ konvertieren:

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

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

Die Unterschlüssel in einem Cookie liegen als eine Auflistung vom Typ NameValueCollection vor. Eine andere Möglichkeit zum Abrufen eines einzelnen Unterschlüssels besteht deshalb darin, erst die Unterschüsselauflistung abzurufen, um anschließend den Unterschlüsselwert anhand des Namens zu extrahieren. Siehe dazu folgendes Beispiel:

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

Ändern des Ablaufdatums eines Cookies

Der Browser ist für die Verwaltung der Cookies zuständig. Anhand von Ablaufzeit und Ablaufdatum der Cookies kann der Browser die gespeicherten Cookies besser verwalten. Aus diesem Grund ist es zwar möglich, den Namen und den Wert eines Cookies auszulesen, jedoch nicht die Ablaufzeit und das Ablaufdatum des Cookies. Wenn der Browser Cookieinformationen an den Server sendet, schließt der Browser die Ablaufzeitinformationen nicht mit ein. (Die Expires-Eigenschaft des Cookies gibt immer einen Datum-Uhrzeit-Wert von 0 zurück.) Wenn Sie sich wegen des Ablaufdatums eines Cookies Sorgen machen, müssen Sie das Cookie zurücksetzen. Dazu mehr im Abschnitt "Ändern und Löschen von Cookies".

Hinweis:

Sie können die im HttpResponse-Objekt festgelegte Expires-Eigenschaft eines Cookies vor dem Senden des Cookies an den Browser lesen. Sie können die Ablaufzeit jedoch nicht wieder in das HttpRequest-Objekt schreiben.

Lesen von Cookieauflistungen

Unter gewissen Umständen müssen Sie alle Cookies lesen, die einer Seite zur Verfügung stehen. Um die Namen und Werte aller Cookies zu lesen, können Sie mit folgendem Code die Cookies-Auflistung durchgehen:

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

Wenn Sie den Code ausführen, stoßen Sie möglicherweise auf ein Cookie mit dem Namen ASP.NET_SessionId. In diesem Cookie speichert ASP.NET einen eindeutigen Bezeichner für die Sitzung. Das Sitzungscookie wird nicht dauerhaft auf der Festplatte gespeichert. Weitere Informationen über Sitzungscookies finden Sie unter "Cookies und Sitzungszustand" weiter unten in diesem Thema.

Eine Einschränkung zum vorherigen Beispiel gilt es allerdings zu beachten: Wenn das Cookie über Unterschlüssel verfügt, werden die Unterschlüssel als eine einzelne Name-Wert-Zeichenfolge angezeigt. Sie können die HasKeys-Eigenschaft eines Cookies lesen, um zu bestimmen, ob das Cookie Unterschlüssel hat. Sollte dies der Fall sein, können Sie die Unterschlüsselauflistung lesen, um einzelne Unterschlüsselnamen und -werte abzurufen. Sie können Unterschlüsselwerte über einen Indexwert aus der Values-Auflistung direkt auslesen. Die entsprechenden Unterschlüsselnamen sind im AllKeys-Member der Values-Auflistung verfügbar. Der Member gibt ein Zeichenfolgenarray zurück. Sie können auch den Keys-Member der Values-Auflistung verwenden. Allerdings wird die AllKeys-Eigenschaft beim ersten Zugriff zwischengespeichert. Im Gegensatz dazu erstellt die Keys-Eigenschaft bei jedem Zugriff ein Array. Aus diesem Grund ist der folgende Zugriff auf die AllKeys-Eigenschaft im Kontext der gleichen Seitenanforderung wesentlich schneller.

Das folgende Beispiel zeigt eine Änderung am vorherigen Beispiel. Zum Untersuchen eines Cookies auf Unterschlüssel wird die HasKeys-Eigenschaft verwendet. Die gefundenen Unterschlüssel werden aus der Values-Auflistung abgerufen.

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

Als Alternative können Sie die Unterschlüssel als NameValueCollection-Objekt extrahieren. Siehe dazu folgendes Beispiel:

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

Ändern und Löschen von Cookies

Sie können ein Cookie nicht direkt ändern. Stattdessen müssen Sie ein neues Cookie mit neuen Werten erstellen und anschließend das Cookie an den Browser senden, um die alte Version auf dem Client zu überschreiben. Das folgende Beispiel zeigt, wie Sie den Wert eines Cookies ändern können, das die Anzahl der Besuche eines Benutzers speichert:

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öschen von Cookies

Ein Cookie zu löschen – es also physikalisch von der Festplatte des Benutzers zu entfernen – unterscheidet sich kaum vom Ändern eines Cookies. Sie können ein Cookie nicht direkt entfernen, da sich das Cookie auf dem Computer des Benutzers befindet. Jedoch kann der Browser das Cookie für Sie löschen. Dazu müssen Sie ein neues Cookie mit dem Namen des zu löschenden Cookies erstellen und das Ablaufdatum des Cookies auf ein Datum vor dem heutigen Tag festlegen. Wenn der Browser die Ablaufzeit des Cookies überprüft, wird er das jetzt abgelaufene Cookie verwerfen. Das folgende Codebeispiel zeigt, wie Sie alle Cookies löschen können, die der Anwendung zur Verfügung stehen:

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

Ändern oder Löschen von Unterschlüsseln

Ändern und Erstellen eines einzelnen Unterschlüssels funktionieren genau gleich. Siehe dazu folgendes Beispiel:

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

Um einen einzelnen Unterschlüssel zu löschen, müssen Sie die Values-Auflistung des Cookies bearbeiten. Sie enthält die Unterschlüssel. Sie müssen zuerst das Cookie neu erstellen, indem Sie es über das Cookies-Objekt abrufen. Rufen Sie anschließend die Remove-Methode der Values-Auflistung auf, und übergeben Sie der Remove-Methode den Namen des zu löschenden Unterschlüssels. Fügen Sie anschließend der Cookies-Auflistung das Cookie hinzu, damit es mitsamt der Änderungen zurück an den Browser gesendet wird. Das folgende Beispiel zeigt, wie Sie einen Unterschlüssel löschen: Im Beispiel ist der Name des zu löschenden Unterschlüssels in einer Variablen angegeben.

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 und Sicherheit

Der Umgang mit Cookies bringt ähnliche Sicherheitsaspekte mit sich wie das Abrufen von Daten von einem Client. Die Cookies einer Anwendung stellen prinzipiell eine Form der Benutzereingabe dar und können daher von unerwünschtem Lesen sowie von Spoofing betroffen sein. Da das Cookie auf dem Computer des Benutzers vorliegt, hat der Benutzer auf jeden Fall Einblick in die im Cookie gespeicherten Daten. Der Benutzer kann außerdem das Cookie ändern, bevor es vom Browser an die Anwendung gesendet wird.

Sie sollten nie vertrauliche Daten wie Benutzernamen, Kennwörter, Kreditkartennummern usw. in einem Cookie speichern. Speichern Sie keine Informationen in einem Cookie, die nicht für den Benutzer oder für Personen bestimmt sind, die sich unrechtmäßigen Zugriff auf ein Cookie verschaffen könnten.

Seien Sie außerdem vorsichtig, was die Informationen anbetrifft, die Sie einem Cookie entnehmen. Gehen Sie nicht davon aus, dass die von Ihnen geschriebenen Daten unverändert bleiben. Treffen Sie beim Umgang mit Cookiewerten die gleichen Sicherheitsvorkehrungen wie beim Umgang mit Benutzereingaben auf einer Webseite. Die vorherigen Beispiele in diesem Thema haben gezeigt, wie Cookieinhalte HTML-codiert werden, bevor der Wert auf der Seite angezeigt wird. Genauso würden Sie auch mit Benutzereingaben verfahren.

Cookies werden zwischen Browser und Server im Nur-Text-Format hin- und hergesendet. Wenn der Webverkehr abgefangen wird, können damit auch die Cookies gelesen werden. Durch Festlegen einer bestimmten Cookieeigenschaft wird das Cookie nur übertragen, wenn die Verbindung Secure Sockets Layer (SSL) verwendet. SSL schützt ein Cookie nicht davor, auf dem Computer des Benutzers gelesen oder manipuliert zu werden. Durch die Verschlüsselung wird jedoch sichergestellt, dass das Cookie unterwegs nicht gelesen werden kann. Weitere Informationen finden Sie unter Grundlegende Sicherheitshinweise für Webanwendungen.

Prüfen, ob ein Browser Cookies annimmt

Browser können so eingestellt werden, dass sie keine Cookies annehmen. Dabei wird kein Fehler ausgelöst, wenn ein Cookie nicht geschrieben werden kann. Der Browser sendet keine Informationen über die aktuellen Cookieeinstellungen an den Server.

Hinweis:

Die Cookies-Eigenschaft zeigt nicht an, ob Cookies aktiviert sind. Sie gibt nur an, ob der aktuelle Browser Cookies grundsätzlich unterstützt.

Um herauszufinden, ob Cookies angenommen werden oder nicht, schreiben Sie ein Cookie, und lesen Sie es anschließend. Wenn Sie das Cookie nicht lesen können, müssen Sie davon ausgehen, dass der Browser Cookies nicht zulässt.

Das folgende Codebeispiel zeigt, wie Sie testen könnten, ob Cookies angenommen werden. Das Beispiel enthält zwei Seiten. Die erste Seite schreibt ein Cookie und leitet anschließend den Browser auf die zweite Seite um. Die zweite Seite versucht, das Cookie zu lesen. Sie leitet den Browser dann wieder auf die erste Seite um und hängt dabei der URL eine Abfragezeichenfolgenvariable mit dem Ergebnis des Tests an.

Der Code der ersten Seite sieht folgendermaßen aus:

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

Die Seite prüft zuerst, ob es sich um ein Postback handelt. Wenn dies nicht der Fall ist, sucht die Seite nach der Abfragezeichenfolgenvariable AcceptsCookies, die das Testergebnis enthält. Wenn keine Abfragezeichenfolgenvariable vorhanden ist, wurde der Test noch nicht abgeschlossen, und der Code schreibt ein Cookie mit dem Namen TestCookie. Nach dem Schreiben des Cookies wird im Beispiel Redirect aufgerufen, um auf die Testseite TestForCookies.aspx zu wechseln. An die URL der Testseite wird eine Abfragezeichenfolgenvariable mit dem Namen redirect angehängt, die die URL der aktuellen Seite enthält. Damit können Sie nach dem Test wieder auf diese Seite umleiten.

Die Testseite kann komplett aus Code bestehen und muss keine Steuerelemente enthalten. Das folgende Codebeispiel zeigt die Testseite.

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

Nach dem Lesen der Umleitungs-Abfragezeichenfolgenvariable versucht der Code, das Cookie zu lesen. Aus Gründen der Übersichtlichkeit wird das Cookie (wenn vorhanden) sofort gelöscht. Wenn der Test abgeschlossen ist, erstellt der Code aus der übergebenen URL der redirect-Abfragezeichenfolgenvariable eine neue URL. Die neue URL enthält ebenfalls eine Abfragezeichenfolgenvariable mit Testergebnissen. Im abschließenden Schritt erfolgt anhand der neuen URL eine Umleitung des Browsers auf die Ausgangsseite.

Das Beispiel ließe sich durch dauerhaftes Speichern der Cookietestergebnisse, z. B. in einer Datenbank, weiter verbessern. Dann müsste der Test nicht jedes Mal wiederholt werden, wenn der Benutzer die Ausgangsseite aufruft. (Standardmäßig sind für das Speichern der Testergebnisse im Sitzungszustand Cookies erforderlich.)

Cookies und Sitzungszustand

Wenn ein Benutzer die Site aufruft, richtet der Server eine eindeutige Sitzung für den Benutzer ein, die für die Dauer des Besuchs bestehen bleibt. Für jede Sitzung verwaltet ASP.NET Sitzungszustandsinformationen, die den Anwendungen zum Speichern von benutzerspezifischen Informationen dienen. Weitere Informationen finden Sie unter Übersicht über den ASP.NET-Sitzungszustand.

ASP.NET muss für jeden Benutzer eine Sitzungs-ID überwachen, damit der Benutzer den Sitzungszustandsinformationen auf dem Server zugeordnet werden kann. Standardmäßig verwendet ASP.NET ein nicht dauerhaftes Cookie, um den Sitzungszustand zu speichern. Wenn jedoch Cookies im Browser eines Benutzers deaktiviert sind, können die Sitzungszustandsinformationen nicht in einem Cookie gespeichert werden.

Als Alternative bietet ASP.NET Sitzungen ohne Cookies. Sie können Ihre Anwendung so konfigurieren, dass Sitzungs-IDs nicht in einem Cookie, sondern in den Seiten-URLs der Site gespeichert werden. Wenn die Anwendung auf den Sitzungszustand angewiesen ist, können Sie die Anwendung eventuell für Sitzungen ohne Cookies konfigurieren. In relativ seltenen Fällen – z. B. wenn ein Benutzer bei aktiver Sitzung die URL an einen Kollegen weitergibt – kann es dabei jedoch vorkommen, dass zwei Benutzer dieselbe Sitzung gemeinsam verwenden. Die Ergebnisse sind dann unvorhersehbar. Weitere Informationen zum Konfigurieren einer Anwendung für Sitzungen ohne Cookies finden Sie unter Übersicht über die ASP.NET-Zustandsverwaltung.

Zurück nach oben

Codebeispiele

Schnellstarts

Verwalten des Anwendungszustands

Themen mit Anweisungen und exemplarischen Vorgehensweisen

Gewusst wie: Anpassen des Authentifizierungscookies über den WCF-Authentifizierungsdienst

Zurück nach oben

Klassenreferenz

HttpCookie

Stellt ein typsicheres Verfahren zum Erstellen und Bearbeiten einzelner HTTP-Cookies bereit.

Cookies

Ruft die Cookieauflistung der Antwort ab.

Cookies

Ruft eine Auflistung der vom Client gesendeten Cookies ab.

Zurück nach oben

Zusätzliche Ressourcen

Zurück nach oben

Neues

Zurück nach oben

Siehe auch

Konzepte

Übersicht über die ASP.NET-Zustandsverwaltung

Referenz

Zurück nach oben