Exemplarische Vorgehensweise: Verwenden von Ablaufverfolgung in Visual Web Developer zum Suchen von Webseitenfehlern

Artikel
10/22/2014

Aktualisiert: November 2007

Es gibt mehrere Möglichkeiten, Fehler in einer ASP.NET-Webseite zu suchen. Dazu gehört die Verwendung des Debuggers und der Ablaufverfolgung. Mit der Ablaufverfolgung werden Meldungen zu den Aktionen während der Seitenverarbeitung angezeigt. Dazu können von Ihnen zum Anzeigen ausgewählte Informationen gehören. In der Ablaufverfolgung erhalten Sie zudem Informationen zu den Daten, die zwischen Server und Browser ausgetauscht werden. Zum Datenaustausch gehören Steuerelementdetails, Servervariablen, Benutzernamen, Cookies usw. Diese exemplarische Vorgehensweise veranschaulicht die Verwendung der Ablaufverfolgung.

Die Ablaufverfolgung ist dann von Nutzen, wenn es unmöglich oder nicht angebracht ist, den Debugger zu verwenden. Beispielsweise ist der Debugger möglicherweise nicht verfügbar, da sich Ihre Seiten auf einem Remoteserver befinden. Mit der Ablaufverfolgung ist es zudem einfacher, Informationen anzuzeigen (z. B. den HTTP-Header), die im Debugger nicht explizit zur Verfügung stehen. Weitere Informationen über das Debuggen finden Sie unter Exemplarische Vorgehensweise: Debuggen von Webseiten in Visual Web Developer.

In dieser exemplarischen Vorgehensweise verwenden Sie die Ablaufverfolgung. Sie erstellen eine Webseite, auf der der Benutzer einen Namen eingeben soll und auf der der Name anschließend angezeigt wird. Die Seite speichert den Namen darüber hinaus in einem Cookie, sodass der Benutzer den Namen nicht erneut eingeben muss.

Hinweis:
In einer Produktionsanwendung besteht eine bessere Möglichkeit zum Speichern persönlicher Informationen in der Verwendung von ASP.NET-Profileigenschaften. Ausführliche Informationen finden Sie unter Übersicht über ASP.NET-Profileigenschaften. Die Verwendung eines Cookies in dieser exemplarischen Vorgehensweise vereinfacht jedoch den Code. Dadurch können Sie sich auf die Ablaufverfolgung konzentrieren.

In einer Produktionsanwendung besteht eine bessere Möglichkeit zum Speichern persönlicher Informationen in der Verwendung von ASP.NET-Profileigenschaften. Ausführliche Informationen finden Sie unter Übersicht über ASP.NET-Profileigenschaften. Die Verwendung eines Cookies in dieser exemplarischen Vorgehensweise vereinfacht jedoch den Code. Dadurch können Sie sich auf die Ablaufverfolgung konzentrieren.

In dieser exemplarischen Vorgehensweise nehmen Sie absichtlich einige Fehler auf. Daraufhin verwenden Sie die Ablaufverfolgung, um den Status der Seitenverarbeitung anzuzeigen. Dies hilft Ihnen bei der Fehlerdiagnose.

In dieser exemplarischen Vorgehensweise werden u. a. die folgenden Aufgaben veranschaulicht:

Aktivieren der Ablaufverfolgung für eine einzelne Seite.
Lesen der Ablaufverfolgungsausgabe.
Anzeigen von benutzerdefinierten Ablaufverfolgungsinformationen.
Anzeigen von Ablaufverfolgungsinformationen in einem separaten Ablaufverfolgungsfenster.
Erstellen der benutzerdefinierten Ablaufverfolgungsausgabe.

Vorbereitungsmaßnahmen

Für die Durchführung dieser exemplarischen Vorgehensweise benötigen Sie Folgendes:

Microsoft Visual Web Developer-Webentwicklungstool.
.NET Framework

In dieser exemplarischen Vorgehensweise wird davon ausgegangen, dass Sie über allgemeine Kenntnisse in Visual Web Developer verfügen. Eine Einführung in Visual Web Developer finden Sie unter Exemplarische Vorgehensweise: Erstellen einer einfachen Webseite in Visual Web Developer.

Erstellen der Website

Wenn Sie in Exemplarische Vorgehensweise: Erstellen einer einfachen Webseite in Visual Web Developer bereits eine Website in Visual Web Developer erstellt haben, können Sie diese Website verwenden und mit "Hinzufügen von Steuerelementen" in dieser exemplarischen Vorgehensweise fortfahren. Erstellen Sie andernfalls eine neue Website und eine neue Webseite, indem Sie folgende Schritte ausführen.

Hinweis:
In dieser exemplarischen Vorgehensweise wird davon ausgegangen, dass Sie mit einer ASP.NET-Seite arbeiten, die eine Code-Behind-Datei für den Code verwendet.

So erstellen Sie eine Dateisystem-Website

Öffnen Sie Visual Web Developer.
Klicken Sie im Menü Datei nacheinander auf Neu und auf Website.

Das Dialogfeld Neue Website wird angezeigt.
Klicken Sie unter Von Visual Studio installierte Vorlagen auf ASP.NET-Website.
Geben Sie in dem sich am weitesten rechts befindlichen Feld Speicherort den Namen des Ordners ein, in dem Sie die Seiten der Website speichern möchten.

Geben Sie zum Beispiel den Ordnernamen C:\WebSites ein.
Wählen Sie in der Liste Sprache die Programmiersprache aus, in der Sie arbeiten möchten.
Klicken Sie auf OK.

Visual Web Developer erstellt den Ordner und die neue Seite Default.aspx.

Hinzufügen einer Seite

Wenn Sie eine vorhandene Website verwenden, können Sie eine neue Seite erstellen. Wenn Sie bereits über eine Seite verfügen, die Sie für diese exemplarische Vorgehensweise verwenden können, wechseln Sie zum nächsten Abschnitt.

So erstellen Sie eine neue Seite

Klicken Sie im Projektmappen-Explorer auf den Namen der Website, und klicken Sie dann auf Neues Element hinzufügen.
Klicken Sie im Dialogfeld Neues Element hinzufügen <Path> unter Von Visual Studio installierte Vorlagen auf Web Form.
Geben Sie FirstWebPage.aspx im Feld Name ein.
Wählen Sie in der Liste Sprache die Programmiersprache aus, in der Sie arbeiten möchten.
Wenn Sie eine Seite in Visual Basic oder C# erstellen, aktivieren Sie das Kontrollkästchen Code in eigener Datei platzieren.
Klicken Sie auf Hinzufügen.

Hinzufügen von Steuerelementen

Nachdem Sie eine Website erstellt und eine Seite geöffnet haben, besteht der nächste Schritt im Hinzufügen einiger Steuerelemente zur Seite.

So fügen Sie Steuerelemente und Code zum Debuggen hinzu

Wechseln Sie zur Entwurfsansicht. Ziehen Sie dann aus der Gruppe Standard der Toolbox die folgenden Steuerelemente auf die Seite, und legen Sie ihre Eigenschaften entsprechend den Angaben in der Tabelle fest:
Steuerelement
Eigenschaften
TextBox

ID: textName

Text: (leer)

Button

ID: buttonDisplayName

Text: Submit

Label

ID: labelName

Text: (leer)
Hinweis:

Für diese exemplarische Vorgehensweise ist das Layout der Seite nicht wichtig.

Steuerelement	Eigenschaften
TextBox	ID: textName Text: (leer)
Button	ID: buttonDisplayName Text: Submit
Label	ID: labelName Text: (leer)

Hinweis:
Für diese exemplarische Vorgehensweise ist das Layout der Seite nicht wichtig.

Hinzufügen von Code

Der nächste Schritt besteht darin, der Seite Code hinzuzufügen. Wenn die Seite wie vorgesehen ausgeführt wird, kann der Benutzer einen Namen eingeben und dann auf Senden klicken. Daraufhin wird der Name im Label-Steuerelement angezeigt. Wenn der Benutzer den Browser schließt und dann zur Seite zurückkehrt, ist der Benutzername bereits auf der Seite vorhanden, da er in einem Cookie gespeichert ist.

Mit den folgenden Schritten erhalten Sie eine Anweisung zum Hinzufügen des Codes. Weder diese Prozedur zum Hinzufügen des Codes noch der Code an sich sind vollkommen richtig. Dies wurde absichtlich so eingerichtet, damit Sie die Fehler auf der Seite mithilfe der Ablaufverfolgung suchen können.

So fügen Sie Code hinzu

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf FirstWebPage.aspx, und klicken Sie dann auf Code anzeigen.

Hinweis:

Doppelklicken Sie nicht auf die Schaltfläche in der Entwurfsansicht.
Geben Sie in der Klassendefinition den folgenden Code ein.

Hinweis:

Wenn Sie mit einer aus einer Datei bestehenden Seite arbeiten, fügen Sie den Code in den <script>-Block ein.
```
Protected Sub buttonDisplayName_Click(ByVal sender As Object, _
      ByVal e As EventArgs)
   labelName.Text = Server.HtmlEncode(textName.Text)
   Response.Cookies("username").Value = labelName.Text
End Sub
```
```
protected void buttonDisplayName_Click(Object sender, EventArgs e)
{
    labelName.Text = Server.HtmlEncode(textName.Text);
    Response.Cookies["username"].Value = labelName.Text;
}
```
Durch den Code werden die folgenden Aufgaben ausgeführt:
- Der Wert des TextBox-Steuerelements wird gelesen und daraufhin im Label-Steuerelement angezeigt. Als Bestandteil dieser Logik ruft der Code die HtmlEncode-Methode auf, die potenziell ausführbare HTML-Zeichen, z. B. spitze Klammern rechts (<), in ihre Anzeigeentsprechungen umwandelt. Dies stellt eine Sicherheitsmaßnahme zum Verhindern von Skriptangriffen dar. Ausführliche Informationen finden Sie unter Skriptangriffe.
- Es wird das Cookie username erstellt, das den vom Benutzer eingegebenen Wert speichert.

Hinweis:
Doppelklicken Sie nicht auf die Schaltfläche in der Entwurfsansicht.

Hinweis:
Wenn Sie mit einer aus einer Datei bestehenden Seite arbeiten, fügen Sie den Code in den <script>-Block ein.

Fügen Sie die folgende Methode hinzu – entweder oberhalb oder unterhalb des Click-Handlers, den Sie im vorhergehenden Schritt erstellt haben.

Sub Page_Load(ByVal sender As Object, ByVal e As EventArgs) _
        Handles Me.Load
   If Not Request.Cookies("username") Is Nothing Then
      labelName.Text = Request.Cookies("username").Value
   End If
End Sub

void Page_Load(Object sender, EventArgs e)
{
    if(Request.Cookies["username"] != null)
    {
        labelName.Text = Request.Cookies["username"].Value;
    }
}

Testen der Seite

Sie können die Seite jetzt testen. Wenn Sie sich an die absichtlich unvollständigen Schritte aus der Prozedur im vorhergehenden Abschnitt gehalten haben, wird die Seite noch nicht wie vorgesehen ausgeführt.

So testen Sie die Seite

Drücken Sie STRG+F5, um die Seite auszuführen.
Wenn die Seite angezeigt wird, geben Sie Ihren Namen in das Textfeld ein, und klicken Sie dann auf Senden.

Beachten Sie, dass Ihr Name nicht angezeigt wird, obwohl die Seite durch Klicken auf Senden an den Server zurückgesendet wurde.
Schließen Sie den Browser.

Sie können nun die Ablaufverfolgung verwenden, damit die Suche nach Fehlern auf der Seite erleichtert wird.

Verwenden der Ablaufverfolgung zum Suchen nach Fehlern

In diesem Abschnitt aktivieren Sie die Ablaufverfolgung für die Seite. Sie überprüfen die Ablaufverfolgungsausgabe und nehmen anschließend benutzerdefinierte Ablaufverfolgungsmeldungen auf, mit denen Sie die Fehler der Seite genau ermitteln können.

So aktivieren Sie die Ablaufverfolgung für die Seite

Öffnen Sie die Seite FirstWebPage.aspx, und wechseln Sie zur Entwurfsansicht.
Klicken Sie unter Eigenschaften in der Liste auf Dokument.

Daraufhin werden Eigenschaften für die Seite angezeigt.
Legen Sie Ablaufverfolgung auf true fest.

Die Ablaufverfolgungseinstellung ist eigentlich als Teil der @ Page-Direktive vorgesehen. Dies kann angezeigt werden, indem Sie zur Quellansicht wechseln und die erste Zeile auf der Seite überprüfen. Die @ Page-Direktive sieht etwa folgendermaßen aus:
```
<%@ Page language="VB"      Trace="true" %>
```
```
<%@ Page language="C#"      Trace="true" %>
```
Drücken Sie STRG+F5, um die Seite auszuführen.

Die Seite wird im Browser angezeigt. Oben werden der Text und die Steuerelemente angezeigt, die Sie auf der Seite platziert haben. Unterhalb des Texts und der Steuerelemente wird die Ablaufverfolgungsausgabe mit zahlreichen Einzelheiten zur Seitenverarbeitung und mit folgenden Informationen angezeigt:
- Die Abfolge von Seitenereignissen, die eingetreten sind, während die Seite ausgeführt wurde.
- Die Typen, Namen und Größen der Steuerelemente auf der Seite.
- Die Cookies und ihr Inhalt.
- Die Servervariablen, d. h. eine Auflistung aller Informationen, die der Browser an den Server sendet.
Beachten Sie, dass unter Anforderungsdetails (dies ist der erste Block der Ablaufverfolgungsinformationen) der AnforderungstypAbrufen lautet. Dies deutet darauf hin, dass die Seite zum ersten Mal ausgeführt wird, das heißt, es handelt sich nicht um ein Postback.
Geben Sie im Feld einen Namen ein, und klicken Sie auf Senden.

Der Anforderungstyp lautet nun Bereitstellen. Dies deutet darauf hin, dass es sich um ein Postback für die Seite handelt. Durch Klicken auf Senden wird der Name nicht angezeigt.
Schließen Sie den Browser.

Mithilfe der benutzerdefinierten Ablaufverfolgungsausgabe können Sie die Logik der Seite besser nachvollziehen.

So fügen Sie die benutzerdefinierte Ablaufverfolgungsausgabe hinzu

Fügen Sie dem im Abschnitt "Hinzufügen von Code" dieser exemplarischen Vorgehensweise erstellten buttonDisplayName_Click-Handler die folgenden hervorgehobenen Zeilen hinzu:

Protected Sub buttonDisplayName_Click(ByVal sender As Object, _
      ByVal e As EventArgs)
   Trace.Warn("debugging", "Start buttonDisplayName Click handler")
   labelName.Text = Server.HtmlEncode(textName.Text)
   Response.Cookies("username").Value = labelName.Text
   Trace.Warn("debugging", "End buttonDisplayName Click handler")
End Sub

protected void buttonDisplayName_Click(Object sender, EventArgs e)
{
   Trace.Warn("debugging", "Start buttonDisplayName Click handler");
   labelName.Text = Server.HtmlEncode(textName.Text);
   Response.Cookies["username"].Value = labelName.Text;
   Trace.Warn("debugging", "End buttonDisplayName Click handler");
}

Die Warn-Methode fügt der Ablaufverfolgungsausgabe die benutzerdefinierten Meldungen hinzu. Obwohl die TraceContext-Klasse auch eine Write-Methode bereitstellt, ist die Warn-Methode hilfreicher, da die Ausgabe farbig angezeigt wird.

Drücken Sie STRG+F5, um die Seite auszuführen.
Klicken Sie auf Absenden.

Wenn Sie die Ablaufverfolgungsausgabe überprüfen, werden Sie feststellen, dass die Ausgabe keinen roten Text enthält. Sie können daraus schlussfolgern, dass der Click-Handler für Senden nicht aufgerufen wird.

Die häufigste Ursache dafür, dass ein Handler nicht aufgerufen wird, besteht darin, dass das Steuerelement nicht richtig an den Ereignishandler gebunden wurde. Dies ist in diesem Fall zutreffend – trotz Hinzufügens des Ereignisbehandlungscodes haben Sie das Click-Ereignis für Senden nicht an den Handler gebunden. Visual Web Developer bindet das Ereignis normalerweise an das Steuerelement, wenn Sie in der Entwurfsansicht auf das Steuerelement doppelklicken.
Schließen Sie den Browser.
Fügen Sie in der Quellansicht dem <asp:button>-Element das folgende hervorgehobene Attribut hinzu:
```
<asp:button id="buttonDisplayName"  text="Submit"
    onclick="buttonDisplayName_Click" />
```
Drücken Sie STRG+F5, um die Seite auszuführen.
Geben Sie im Feld einen Namen ein, und klicken Sie auf Senden.

Die benutzerdefinierte Ablaufverfolgungsausgabe wird in roter Farbe im Abschnitt Überwachungsinformationen angezeigt, in dem die von der Seite durchlaufenen Verarbeitungsschritte aufgelistet werden.

Die Ausgabe in diesem Abschnitt enthält die Meldungen in der Reihenfolge, in der sie Meldungen während der Seitenverarbeitung angezeigt wurden. Sie haben Ihre Meldungen im Click-Ereignishandler hinzugefügt, der zwischen der Begin Raise PostBackEvent-Zeile und der End Raise PostBackEvent-Zeile verarbeitet wird. Durch Aufnehmen von benutzerdefinierten Meldungen erfahren Sie nicht nur, dass Ihr Handler aufgerufen wurde, sondern auch, an welcher Stelle im Seitenverarbeitungszyklus der Code ausgeführt wird.

Die Kategorie neben Ihren benutzerdefinierten Meldungen lautet debugging. Dies ist die Kategorie, die Sie beim Aufrufen der Warn-Methode angegeben haben. Sie können eine beliebige gewünschte Kategorie angeben, und wenn es von Nutzen ist, können Sie die TraceMode-Eigenschaft für die Seite auf den SortByCategory-Wert festlegen, damit die Suche nach der Kategorie in der Ablaufverfolgungsausgabe erleichtert wird.

Beachten Sie außerdem, dass der von Ihnen eingegebene Name in der Bezeichnung angezeigt wird.

Da nun der Click-Handler für Senden wie vorgesehen funktioniert, können Sie den übrigen Code auf der Seite testen, einschließlich des Cookies.

Schließen Sie den Browser.
Drücken Sie STRG+F5, um die Seite auszuführen.

Sie erwarten, dass der von Ihnen eingegebene Name automatisch in der Bezeichnung angezeigt wird, da der Click-Handler für Senden ein Cookie festlegt und der Page_Load-Handler dieses während des nächsten Postbacks liest. Die Bezeichnung wird jedoch nie vom Cookie aus festgelegt.

Wenn Sie ein Cookie schreiben, dieses jedoch nicht beibehalten wird, besteht der Fehler häufig darin, dass Sie kein explizites Ablaufdatum für das Cookie festlegen. Ein Cookie ohne Ablaufdatum heißt Sitzungscookie. Ein Sitzungscookie bleibt nur solange im Serverspeicher, bis der Browser geschlossen wird. Mit anderen Worten: Das Cookie wird nicht in den Browser geschrieben. Mit den folgenden Schritten korrigieren Sie dieses Problem.
Schließen Sie den Browser.

Fügen Sie in der Quellansicht dem buttonDisplayName_Click-Handler die folgende hervorgehobene Zeile hinzu:

Protected Sub buttonDisplayName_Click(ByVal sender As Object, _
        ByVal e As EventArgs)
    Trace.Warn("debugging", "Start buttonDisplayName Click handler")
    labelName.Text = Server.HtmlEncode(textName.Text)
    Response.Cookies("username").Value = labelName.Text
    Response.Cookies("username").Expires= _       DateTime.Now.AddMinutes(30)
   Trace.Warn("debugging", "End buttonDisplayName Click handler")
End Sub

protected void buttonDisplayName_Click(Object sender, EventArgs e)
{
    Trace.Warn("debugging", 
        "Start buttonDisplayName Click handler");
    labelName.Text = Server.HtmlEncode(textName.Text);
    Response.Cookies["username"].Value = labelName.Text;
    Response.Cookies["username"].Expires=         DateTime.Now.AddMinutes(30);
    Trace.Warn("debugging", "End buttonDisplayName Click handler");
}

Die neue Zeile legt das Cookie explizit so fest, dass es nach 30 Minuten abläuft.

Drücken Sie STRG+F5, um die Seite auszuführen.
Geben Sie im Feld einen Namen ein, und klicken Sie auf Senden.

Der Name wird im Browser angezeigt. In der Ablaufverfolgungsausgabe Auflistung der Antwortcookies können Sie sehen, dass das Cookie festgelegt wird.
Schließen Sie den Browser.
Drücken Sie STRG+F5, um die Seite auszuführen.

Diesmal wird der Name automatisch eingetragen. In der Ablaufverfolgungsausgabe Auflistung der Antwortcookies können Sie nun erkennen, dass der Browser das Cookie an Ihre Seite übergibt.

Anzeigen von Ablaufverfolgungsinformationen in einem Ablaufverfolgungs-Viewerfenster

Das Festlegen der Seite auf das Anzeigen der Ablaufverfolgungsausgabe ist dann von Nutzen, wenn Sie mit nur einer Seite arbeiten. Wenn Sie in der Anwendung jedoch mit mehreren Seiten arbeiten, kann es umständlich sein, die Ablaufverfolgung für jede Seite zu aktivieren und zu deaktivieren. Darüber hinaus wird es möglicherweise als störend empfunden, Ablaufverfolgungs-Ausgabeinformationen auf der Seite anzuzeigen, während die Seite ausgeführt wird. Abgesehen davon ist es nicht wünschenswert, dass auf der Seite die Ablaufverfolgungsausgabe für Benutzer Ihrer Anwendung angezeigt wird.

Sie können die Ablaufverfolgung nicht nur auf Seitenebene konfigurieren, sondern auch auf Anwendungsebene. Das Festlegen der Ablaufverfolgung auf Anwendungsebene hat zwei Vorteile:

Sie können die Ablaufverfolgung für alle Seiten gleichzeitig aktivieren und deaktivieren.
Sie können die Ablaufverfolgungsausgabe in einem separaten Browserfenster – dem Ablaufverfolgungs-Viewer – anzeigen, anstatt sie als Teil der Ausgabe für die Seite anzuzeigen.

Wenn die Ablaufverfolgung auf Anwendungsebene aktiviert ist, behält ASP.NET die Ablaufverfolgungsausgabe aus allen Seiten in einem Cache bei. Sie können Optionen festlegen, mit denen angegeben wird, wie viele Seiten der Ablaufverfolgungsausgabe zwischengespeichert werden sollen und ob die neuesten oder die ältesten Einträge gespeichert werden sollen. Sie können daraufhin den Ablaufverfolgungs-Viewer im Browser aufrufen und die zu überprüfende Ablaufverfolgungsausgabe auswählen.

In diesem Abschnitt der exemplarischen Vorgehensweise aktivieren Sie die Ablaufverfolgung auf Anwendungsebene und überprüfen mithilfe des Ablaufverfolgungs-Viewers die Ablaufverfolgungsausgabe.

So aktivieren Sie die Ablaufverfolgung auf Anwendungsebene

Wechseln Sie zur Quellansicht, und löschen Sie anschließend Trace="true" in der @ Page-Direktive oben auf der Seite.

Hinweis:
Entfernen Sie das Attribut, anstatt es lediglich auf false festzulegen. Andernfalls funktionieren die nachfolgenden Schritte in dieser exemplarischen Vorgehensweise nicht wie vorgesehen.

Klicken Sie im Menü Website auf ASP.NET-Konfiguration.

Das ASP.NET-Websiteverwaltungs-Tool wird angezeigt.
Klicken Sie auf Anwendungskonfiguration.
Klicken Sie unter Debuggen und Ablaufverfolgung auf Debuggen und Ablaufverfolgung konfigurieren, und aktivieren Sie anschließend das Kontrollkästchen Ablaufverfolgungsinformationen sammeln.

Mit dieser Einstellung wird die Ablaufverfolgung auf Anwendungsebene aktiviert.

Für diese exemplarische Vorgehensweise können Sie die übrigen Einstellungen bei ihren Standardwerten belassen. ASP.NET speichert bis zu 10 Einträge der Ablaufverfolgungsausgabe zwischen (10 Postbacks einer einzelnen Seite oder weniger Postbacks jeweils für mehrere Seiten) und führt zudem eine Zwischenspeicherung der letzten Einträge durch.
Schließen Sie das ASP.NET-Websiteverwaltungs-Tool.

Nun können Sie die ursprüngliche Seite ausführen und sie so verwenden, wie sie für den Benutzer angezeigt wird. Gleichzeitig können Sie die Ablaufverfolgungsausgabe jedoch in einem separaten Browserfenster anzeigen, wenn dies erforderlich ist.

So zeigen Sie die Ablaufverfolgungsausgabe in einem separaten Browserfenster an

Drücken Sie STRG+F5, um die Seite auszuführen.

Beachten Sie, dass die Seite die Ablaufverfolgungsausgabe nicht mehr anzeigt. Die Darstellung der Seite entspricht der Anzeige für die Benutzer.
Geben Sie einen Namen in das Feld ein, und klicken Sie dann auf Senden, um sicherzustellen, dass die Seite wie vorgesehen funktioniert.
Öffnen Sie ein neues Browserfenster.
Geben Sie im Browser in das Feld Adresse den URL Ihrer Website ein, und ersetzen Sie trace.axd durch den Namen der Seite, mit der Sie momentan arbeiten.

Angenommen, der URL für die Seite lautet beispielsweise folgendermaßen:
```
https://localhost:8081/WebSite/Default.aspx
```
Geben Sie Folgendes ein:
```
https://localhost:8081/WebSite/trace.axd
```
Hinweis:

Diese Aufgabe kann schnell ausgeführt werden, indem der URL aus der ursprünglichen Seite kopiert und anschließend nur der Seitenname geändert wird.

Der Browser zeigt den aktuellen Cache der Ablaufverfolgungseinträge an.
Klicken Sie zum Anzeigen des letzten (neuesten) Ablaufverfolgungseintrags auf Details anzeigen.

Der Browser zeigt eine Ablaufverfolgungsausgabe an, die mit dem verglichen werden kann, was Sie zuvor in der exemplarischen Vorgehensweise kennen gelernt haben. Nur wird diese Ausgabe nicht an das Ende der Seite angefügt.
Wechseln Sie zu der Browserinstanz, die die ursprüngliche Seite enthält.
Geben Sie im Feld einen neuen Namen ein, und klicken Sie auf Senden.

Diese Aktion generiert einen neuen Ablaufverfolgungs-Protokolleintrag.
Wechseln Sie zu der Browserinstanz, die die Informationen enthält.
Klicken Sie im Browser auf Zurück, um zur Liste der Ablaufverfolgungseinträge zurückzukehren, und klicken Sie dann auf Aktualisieren, um die Liste der Einträge zu aktualisieren.

Es wird ein neuer Eintrag angezeigt, der die Ablaufverfolgungsausgabe darstellt, die Sie in Schritt 7 erstellt haben.
Schließen Sie beide Browserfenster.

Hinweis:
Diese Aufgabe kann schnell ausgeführt werden, indem der URL aus der ursprünglichen Seite kopiert und anschließend nur der Seitenname geändert wird.

Erstellen der benutzerdefinierten Ablaufverfolgungsausgabe

Wie Sie sehen, enthält die Ablaufverfolgungsausgabe zahlreiche Informationen. Dies sind zuweilen mehr Informationen als nötig. Möglicherweise möchten Sie z. B. die Ablaufverfolgungsausgabe auf die von Ihnen selbst erstellte Ablaufverfolgungsausgabe beschränken. Mithilfe der Ablaufverfolgung können Sie den Inhalt des Ablaufverfolgungspuffers lesen und die erforderlichen Informationen selektiv anzeigen.

Wenn Sie eine benutzerdefinierte Ablaufverfolgungsausgabe erstellen möchten, behandeln Sie das TraceFinished-Ereignis für das Trace-Objekt. Im Ereignishandler können Sie den Ablaufverfolgungspuffer lesen.

So erstellen Sie die benutzerdefinierte Ablaufverfolgungsausgabe

Fügen Sie auf der Seite, mit der Sie gearbeitet haben, dem Page_Load-Handler den folgenden hervorgehobenen Code hinzu:

Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) _
        Handles Me.Load
   If Not Request.Cookies("username")  Is Nothing Then
      labelName.Text = Request.Cookies("username").Value
   End If
   AddHandler Trace.TraceFinished, AddressOf Me.TraceFinished   If IsPostBack Then      Trace.Write("debugging", "Page_Load (Postback)")   Else      Trace.Write("debugging", "Page_Load (First Time)")   End If
End Sub

void Page_Load(object sender, EventArgs e)
{
    if(Request.Cookies["username"].Value != null)
    {
        labelName.Text = Request.Cookies["username"].Value;
    }
    Trace.TraceFinished += new         TraceContextEventHandler(this.TraceFinished);    if (Page.IsPostBack)    {        Trace.Write("debugging", "Page load (postback)");    }    else    {        Trace.Write("debugging", "Page load (first time)");    }
}

Im Code werden die folgenden zwei Funktionen ausgeführt:

Er bindet eine Methode auf der Seite an das TraceFinished-Ereignis für das Trace-Objekt, das ausgelöst wird, wenn die Ablaufverfolgungsausgabe für die Seite vollständig vorliegt. Die Methode wird im nächsten Schritt geschrieben.
Der Code schreibt einige Ablaufverfolgungsinformationen.

Erstellen Sie die folgende Methode zum Behandeln des TraceFinished-Ereignisses:

Sub TraceFinished(ByVal sender As Object, _
       ByVal e As TraceContextEventArgs)
   Dim traceRecord As TraceContextRecord
   For Each traceRecord In e.TraceRecords
      If traceRecord.Category = "debugging" Then
         Response.Write("<BR>" & traceRecord.Message)
      End If
   Next
End Sub

void TraceFinished(object sender, TraceContextEventArgs e)
{    
    foreach(TraceContextRecord traceRecord in e.TraceRecords)
    {    
           if(traceRecord.Category == "debugging")    
           {        
               Response.Write("<br>" + traceRecord.Message);
           }    
    }    
}

Dieser Code wird ausgeführt, wenn die Ablaufverfolgungsausgabe beendet ist. Der Ablaufverfolgungspuffer ist als Auflistung in der TraceRecords-Eigenschaft des e-Ereignisarguments verfügbar. Der Code durchläuft die Auflistung und zeigt den Wert jedes Datensatzes in der Ablaufverfolgung an, der zur Kategorie debugging gehört. In dieser exemplarischen Vorgehensweise haben Sie die Kategorie der gesamten benutzerdefinierten Ablaufverfolgungsausgabe auf debugging festgelegt.

An dieser Stelle in der exemplarischen Vorgehensweise wird die Website so konfiguriert, dass die Ablaufverfolgung für alle Seiten aktiviert ist. Die Ablaufverfolgungsausgabe wird jedoch an einen Ablaufverfolgungs-Viewer statt an die Seite weitergeleitet. Wenn die Website anders konfiguriert wird, beispielsweise wenn die Ablaufverfolgungsausgabe auf der Seite angezeigt wird, befolgen Sie die Schritte in der Prozedur "So aktivieren Sie die Ablaufverfolgung auf Anwendungsebene" unter "Anzeigen von Ablaufverfolgungsinformationen in einem Ablaufverfolgungs-Viewerfenster" in der exemplarischen Vorgehensweise.

Sie können nun die benutzerdefinierte Ablaufverfolgungsausgabe testen.

So testen Sie die benutzerdefinierte Ablaufverfolgungsausgabe

Drücken Sie STRG+F5, um die Seite auszuführen.

Beim Anzeigen der Seite im Browser wird die Meldung Laden der Seite (erstmalig) angezeigt, es wird jedoch keine andere Ablaufverfolgungsausgabe angezeigt.
Klicken Sie auf Absenden.

Die Meldungen Seitenauslastung (Postback), buttonDisplayName-Click-Handler starten und buttonDisplayName-Click-Handler beenden werden angezeigt.

Hinweis:
Wenn Sie die Anzahl der zwischengespeicherten Anforderungen überschreiten, die im requestLimit-Attribut von trace-Element (ASP.NET-Einstellungsschema) angegeben ist, wird das TraceFinished-Ereignis nicht ausgelöst, und die Meldungen werden nicht auf der Webseite angezeigt.

Nächste Schritte

In dieser exemplarischen Vorgehensweise wurden die Grundfunktionen der Ablaufverfolgung in ASP.NET veranschaulicht. Neben der Verwendung der Ablaufverfolgung zum Anzeigen von Informationen in der Webanwendung können Sie die ASP.NET-Ablaufverfolgung in eine andere Instrumentierung integrieren. Beispielsweise können Sie folgende Aufgaben ausführen:

Anzeigen von Systemdiagnosemeldungen als Teil der ASP.NET-Ablaufverfolgung.

Weitere Informationen finden Sie unter Exemplarische Vorgehensweise: Integrieren der ASP.NET-Ablaufverfolgung und der System.Diagnostics-Ablaufverfolgung.
Senden von ASP.NET-Ablaufverfolgungsinformationen an den .NET Framework-Ablaufverfolgungsmechanismus, der Klassen im System.Diagnostics-Namespace verwendet.
Weiterleiten von Informationen an registrierte Instrumentierungslistener als Teil der Systemüberwachung für die Website.

Weitere Informationen über das Registrieren von Listenern finden Sie unter <listeners>-Element für <trace>.

Siehe auch

Weitere Ressourcen

Ablaufverfolgung in ASP.NET-Webseiten (Visual Studio)