Asp.Net-Seitenebenenverfolgung, Debugging, Fehlerbehandlung [Beispiel]

Bei jeder Anwendung treten während des Entwicklungsprozesses zwangsläufig Fehler auf. Es ist wichtig, Fehler frühzeitig entdecken zu können.

In Visual Studio ist dies für ASP.Net-Anwendungen möglich. Visual Studio wird zum Debuggen verwendet und verfügt über Fehlerbehandlungstechniken für ASP.Net.

Was ist Debuggen in ASP.NET?

Beim Debuggen werden Haltepunkte zu einer Anwendung hinzugefügt. Diese Haltepunkte werden verwendet, um die Ausführung eines laufenden Programms anzuhalten. Dadurch kann der Entwickler verstehen, was zu einem bestimmten Zeitpunkt in einem Programm passiert.

Nehmen wir ein Beispiel für ein Programm. Das Programm zeigt dem Benutzer die Zeichenfolge „Wir debuggen“ an. Angenommen, wenn wir die Anwendung ausführen, wird die Zeichenfolge aus irgendeinem Grund nicht angezeigt. Um das Problem zu identifizieren, müssen wir einen Haltepunkt hinzufügen. Wir können der Codezeile, die die Zeichenfolge anzeigt, einen Haltepunkt hinzufügen. Dieser Haltepunkt unterbricht die Ausführung des Programms. An diesem Punkt kann der Programmierer sehen, was möglicherweise schief läuft. Der Programmierer korrigiert das Programm entsprechend.

Hier im Beispiel verwenden wir unsere 'DemoApplication', die in früheren Kapiteln erstellt wurde. Im folgenden Beispiel sehen wir

• So veranlassen Sie die Demoanwendung, eine Zeichenfolge anzuzeigen.
• So fügen Sie einer Anwendung Haltepunkte hinzu.
• So debuggen Sie die Anwendung mithilfe dieses Haltepunkts.

So debuggen Sie eine Anwendung in ASP.NET

Im Folgenden finden Sie die Schritte zum Erstellen einer Demoanwendung, zum Hinzufügen von Haltepunkten und zum Debuggen in ASP.Net:

Schritt 1) ​​Öffnen Sie die Anwendung in Visual Studio
Stellen wir zunächst sicher, dass unsere Webanwendung in Visual Studio geöffnet ist. Stellen Sie sicher, dass die DemoApplication in Visual Studio geöffnet ist.

Schritt 2) Öffnen Sie nun die Datei Demo.aspx.cs und fügen Sie die folgende Codezeile hinzu.

• Wir fügen lediglich die Codezeile Response.Write hinzu, um einen String anzuzeigen.
• Wenn die Anwendung ausgeführt wird, sollte sie im Webbrowser die Zeichenfolge „Wir debuggen“ anzeigen.

namespace DemoApplication
{  
  public partial class Demo : System.Web.UI.Page  
		{  
		  protected void Page_Load(object sender, EventArgs e)  
		  {
		    Response.Write("We are debugging"); 
		  }
		}
}

Schritt 3) Fügen Sie der Anwendung einen Haltepunkt hinzu
Ein Haltepunkt ist ein Punkt in Visual Studio, an dem die Ausführung des Programms gestoppt werden soll.

1. Um einen Haltepunkt hinzuzufügen, müssen Sie auf die Spalte klicken, in die der Haltepunkt eingefügt werden soll. In unserem Fall möchten wir also, dass unser Programm bei der Codezeile „Response.Write“ stoppt. Sie müssen keinen Befehl hinzufügen, um einen Haltepunkt hinzuzufügen. Sie müssen nur auf die Zeile klicken, in der Sie einen Haltepunkt hinzufügen möchten.
2. Sobald dies erledigt ist, werden Sie feststellen, dass der Code rot markiert wird. Außerdem erscheint in der Spalte neben der Codezeile eine rote Blase.

Hinweis: - Sie können einer Anwendung mehrere Haltepunkte hinzufügen

Schritt 4) Führen Sie die Anwendung im Debugging-Modus aus
Jetzt müssen Sie Ihre Anwendung im Debugmodus ausführen. Wählen Sie in Visual Studio die Menüoption Debuggen -> Debuggen starten.

Ausgabe:-

Wenn Sie alle Schritte korrekt ausführen, wird die Ausführung des Programms unterbrochen. Visual Studio geht zum Haltepunkt und markiert die Codezeile gelb.

Wenn der Programmierer nun der Meinung ist, dass der Code falsch ist, kann die Ausführung gestoppt werden. Der Code kann dann entsprechend geändert werden. Um mit dem Programm fortzufahren, muss der Programmierer auf die Taste F5 auf der Tastatur klicken.

Was ist Tracing in ASP.NET?

Mit der Anwendungsverfolgung können Sie feststellen, ob eine angeforderte Seite zu einem Fehler führt. Wenn die Ablaufverfolgung aktiviert ist, wird der Anwendung eine zusätzliche Seite namens „trace.axd“ hinzugefügt. (Siehe Bild unten). Diese Seite ist dem Antrag beigefügt. Auf dieser Seite werden alle Anfragen und deren Status angezeigt.

So aktivieren Sie die Ablaufverfolgung für eine Anwendung in ASP.NET

Sehen wir uns an, wie Sie die Ablaufverfolgung für eine aktivieren ASP.Net-Anwendung:

Schritt 1) Lassen Sie uns an unserer „DemoApplication“ arbeiten. Öffnen Sie die Datei web.config im Projektmappen-Explorer.

Schritt 2) Fügen Sie die folgende Codezeile zur Datei Web.config hinzu.

Die Trace-Anweisung wird verwendet, um die Ablaufverfolgung für die Anwendung zu aktivieren.

• Das „requestLimit“ in der Trace-Anweisung wird verwendet. Es gibt die Anzahl der Seitenanfragen an, die verfolgt werden müssen.
• In unserem Beispiel geben wir einen Grenzwert von 40 an. Wir geben einen Grenzwert an, weil ein höherer Wert die Leistung der Anwendung beeinträchtigt.

<?xml version="1.0" encoding="utf-8"?>
<! --
For more information on how to configure your ASP.NET application, please visit http://go.microsoft.com/fwlink/?LinkId=169433 
-->
<configuration>
	<system.web>
		<compilation debug="true" targetFramework="4.0" />
		<httpRuntime targetFramework="4.0” />
		
		 <trace enable="true" pageOutput="false" requestLimit="40" localOnly="false"/>
		
	</system.web>
</configuration>

Führen Sie die „Demoanwendung“ in Visual Studio aus.

Ausgabe:-

Wenn Sie jetzt zur URL navigieren – http://localhost:53003/trace.axd werden Ihnen die Informationen zu jeder Anfrage angezeigt. Hier können Sie sehen, ob bei einer Anwendung Fehler auftreten. Auf der obigen Seite werden die folgenden Arten von Informationen angezeigt

1. Der Zeitpunkt der Anfrage für die Webseite.
2. Der Name der angeforderten Webseite.
3. Der Statuscode der Webanforderung. (Statuscode 200 bedeutet, dass die Anfrage erfolgreich ist).
4. Mit der Option „Details anzeigen“ können Sie weitere Details zur Webanforderung anzeigen. Ein Beispiel hierfür wird unten angezeigt. Eine wichtige Detailinformation ist die Header-Information. Diese Information zeigt, welche Informationen im Header jeder Webanforderung gesendet werden.

Wenn beispielsweise bei Ihrer Webanwendung ein Leistungsproblem auftritt, können diese Informationen bei der Fehlerbehebung hilfreich sein. Diese Informationen werden angezeigt, wenn die Anwendung in Visual Studio ausgeführt wird.

So aktivieren Sie die Ablaufverfolgung auf Seitenebene in ASP.NET

Sehen wir uns an, wie Sie die Ablaufverfolgung auf Seitenebene für eine ASP.Net-Anwendung aktivieren:

Schritt 1) Lassen Sie uns an unserer Demo-Anwendung arbeiten. Öffnen Sie die Datei demo.aspx im Projektmappen-Explorer

Schritt 2) Fügen Sie die folgende Codezeile hinzu, um die Seitenverfolgung zu aktivieren. Fügen Sie in der Seitendeklaration einfach die Zeile Trace=“true“ hinzu. Diese Codezeile ermöglicht die Ablaufverfolgung auf Seitenebene.

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Demo.aspx.cs" Inherits="DemoApplication.Demo" %>

	<!DOCTYPE html>
<html xmlns="http://www.w3.ore/1999/xhtml">
<head runat="server">
	<title></title>
</head>	
	<body>
	  <form id="form1" runat="server”>
	  </form>
</body>
</html>

Führen Sie die Anwendung in Visual Studio aus.

Ausgabe:-

Wenn jetzt die Webseite Demo.aspx angezeigt wird, erhalten Sie eine ganze Reihe von Informationen über die Seite. Auf dieser Seite werden Informationen wie die Zeit für jeden Aspekt des Seitenlebenszyklus angezeigt.

Fehlerbehandlung: Anzeigen einer benutzerdefinierten Fehlerseite

In ASP.Netkönnen Sie den Benutzern benutzerdefinierte Fehlerseiten anzeigen lassen. Wenn eine Anwendung Fehler enthält, wird dem Benutzer dieser Fehler auf einer benutzerdefinierten Seite angezeigt.

In unserem Beispiel fügen wir zunächst eine HTML-Seite hinzu. Auf dieser Seite wird dem Benutzer die Zeichenfolge „Wir untersuchen das Problem“ angezeigt. Anschließend fügen wir unserer demo.aspx-Seite einen Fehlercode hinzu, sodass die Fehlerseite angezeigt wird.

Folgen wir den unten aufgeführten Schritten

Schritt 1) Lassen Sie uns an unserer Demo-Anwendung arbeiten. Fügen wir der Anwendung eine HTML-Seite hinzu

1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf die Demoanwendung
2. Wählen Sie die Menüoption „Hinzufügen“ -> HTML-Seite

Schritt 2) Im nächsten Schritt müssen wir der neuen HTML-Seite einen Namen geben.

1. Geben Sie den Namen „ErrorPage“ an.
2. Klicken Sie auf die Schaltfläche „OK“, um fortzufahren.

Schritt 3) Die Fehlerseite wird automatisch in Visual Studio geöffnet. Wenn Sie zum Solution Explorer gehen, sehen Sie die hinzugefügte Datei.

Fügen Sie der HTML-Seite die Codezeile „Wir untersuchen das Problem“ hinzu. Sie müssen die HTML-Datei nicht schließen, bevor Sie die Änderung an der Datei web.config vornehmen.

<!DOCTYPE html>
<html xmlns="http://www.w3.ore/1999/xhtml">
<head runat="server">
	<title></title>
</head>	
	<body>
	  We are looking into the problem
	</body>
</html>

Schritt 4) Jetzt müssen Sie eine Änderung in der Datei web.config vornehmen. Diese Änderung weist darauf hin, dass bei jedem Fehler in der Anwendung die benutzerdefinierte Fehlerseite angezeigt werden muss.

Mit dem Tag „customErrors“ können Sie eine benutzerdefinierte Fehlerseite definieren. Die Eigenschaft „defaultRedirect“ wird auf den Namen unserer benutzerdefinierten Fehlerseite gesetzt, die im vorherigen Schritt erstellt wurde.

<configuration>
	<system.web>
		<compilation debug="true" targetFramework="4.0" />
		<httpRuntime targetFramework="4.0” />
		
		 <customErrors mode="On" defaultRedirect="ErrorPage.html">
</customErrors>

		
	</system.web>
</configuration>

Schritt 5) Fügen wir nun der Seite demo.aspx.cs fehlerhaften Code hinzu. Öffnen Sie diese Seite, indem Sie im Solution Explorer auf die Datei doppelklicken.

Fügen Sie den folgenden Code zur Datei Demo.aspx.cs hinzu.

• Diese Codezeilen dienen dazu, die Zeilen eines Textes aus einer Datei zu lesen.
• Die Datei sollte sich im Laufwerk D mit dem Namen „Example.txt“ befinden.
• Aber in unserer Situation existiert diese Datei nicht wirklich. Dieser Code führt also zu einem Fehler, wenn die Anwendung ausgeführt wird.

namespace DemoApplication
{  

  public partial class Demo : System.Web.UI.Page  
		{  
		  protected void Page_Load(object sender, EventArgs e)  
		  {
		   String path = @"D:\Example.txt";
		   string[] lines;
		   lines = File.ReadAllLines(path);
		  }
		}
}

Führen Sie nun den Code aus Visual Studio und Sie sollten die folgende Ausgabe erhalten.

Ausgabe:-

Die obige Seite zeigt, dass in der Anwendung ein Fehler ausgelöst wurde. Als Ergebnis wird dem Benutzer die Seite Error.html angezeigt.

Unbehandelte ASP.NET-Ausnahme

Selbst im besten Fall kann es zu Fehlern kommen, die einfach nicht vorhersehbar sind.

Angenommen, ein Benutzer navigiert zur falschen Seite in der Anwendung. Das ist etwas, was man nicht vorhersagen kann. In solchen Fällen kann ASP.Net den Benutzer zur errorpage.html umleiten.

Sehen wir uns dazu ein Beispiel an.

• Wir werden dieselbe „DemoApplication“ verwenden, die die Datei „Errorpage.html“ enthält.
• Und wir werden versuchen, eine Webseite anzuzeigen, die in unserer Anwendung nicht vorhanden ist.
• In diesem Fall sollten wir auf unsere Seite ErrorPage.html weitergeleitet werden. Sehen wir uns die Schritte an, um dies zu erreichen.

Schritt 1) Lassen Sie uns an unserer Demo-Anwendung arbeiten. Öffnen Sie die Datei Global.asax.cs im Projektmappen-Explorer

HINWEIS: Die Datei global.asax.cs wird zum Hinzufügen von Code verwendet, der auf allen Seiten der Anwendung anwendbar ist.

Schritt 2) Fügen Sie die folgende Codezeile zur global.asax.cs hinzu. Diese Zeilen werden verwendet, um nach Fehlern zu suchen und die Seite ErrorPage.html entsprechend anzuzeigen.

namespace DemoApplication
{  

  public partial class Demo : System.Web.UI.Page  
		{  
		  protected void Application_Error(object sender, EventArgs e)  
		  {
		?    HttpException lastErrorWrapper = Server.GetLastError() as HttpException;

			if(lastErrorWrapper.GetHttpCode() == 404)
			Server.T ransfer("~/ErrorPage.html");
		  }
		}
}

Code-Erklärung:-

1. Die erste Zeile ist der Application_Error-Ereignishandler. Dieses Ereignis wird immer dann aufgerufen, wenn in einer Anwendung ein Fehler auftritt. Beachten Sie, dass der Ereignisname „Application_Error“ lauten muss. Und die Parameter sollten wie oben gezeigt sein.
2. Als nächstes definieren wir ein Objekt vom Klassentyp HttpException. Dies ist ein Standardobjekt, das alle Details des Fehlers enthält. Anschließend verwenden wir die Methode Server.GetLastError, um alle Details des letzten in der Anwendung aufgetretenen Fehlers abzurufen.
3. Anschließend prüfen wir, ob der Fehlercode des letzten Fehlers 404 ist. (Der Fehlercode 404 ist der Standardcode, der zurückgegeben wird, wenn ein Benutzer zu einer Seite navigiert, die nicht gefunden wird.) Wir leiten den Benutzer dann zur Seite ErrorPage.html weiter, wenn der Fehlercode übereinstimmt.

Führen Sie nun den Code in Visual Studio aus und Sie sollten die folgende Ausgabe erhalten

Ausgabe:-

Durchsuchen Sie die Seite http://localhost:53003/Demo1.aspx . Denken Sie daran, dass Demo1.aspx in unserer Anwendung nicht vorhanden ist. Sie erhalten dann die folgende Ausgabe.

Die obige Seite zeigt, dass in der Anwendung ein Fehler ausgelöst wurde. Als Ergebnis wird dem Benutzer die Seite Error.html angezeigt.

ASP.NET-Fehlerprotokollierung

Durch das Protokollieren von Anwendungsfehlern kann der Entwickler den Fehler zu einem späteren Zeitpunkt debuggen und beheben. ASP.Net verfügt über die Möglichkeit, Fehler zu protokollieren. Dies geschieht in der Datei Global.asax.cs, wenn der Fehler erfasst wird. Während des Erfassungsprozesses kann die Fehlermeldung in eine Protokolldatei geschrieben werden.

Sehen wir uns dazu ein Beispiel an.

• Wir werden dieselbe DemoApplication verwenden, die die Datei Errorpage.html enthält.
• Und wir werden versuchen, eine Webseite anzuzeigen, die in unserer Anwendung nicht vorhanden ist.
• In diesem Fall sollten wir auf unsere Seite ErrorPage.html weitergeleitet werden.
• Gleichzeitig schreiben wir die Fehlermeldung in eine Protokolldatei. Sehen wir uns die Schritte an, um dies zu erreichen.

Schritt 1) Lassen Sie uns an unserer Demo-Anwendung arbeiten. Öffnen Sie die Datei Global.asax.cs im Projektmappen-Explorer

Schritt 2) Fügen Sie die folgende Codezeile zu global.asax.cs hinzu. Sie sucht nach Fehlern und zeigt die Seite ErrorPage.html entsprechend an. Gleichzeitig protokollieren wir die Fehlerdetails in einer Datei namens „AllErrors.txt“. Für unser Beispiel schreiben wir Code, um diese Datei auf dem Laufwerk D zu erstellen.

namespace DemoApplication
{  

  public partial class Demo : System.Web.UI.Page  
		{  
		  protected void Application_Error(object sender, EventArgs e)  
		  {
		   Exception exc = Server.GetLastError();
		   String str ="";
		   str = exc.Message;
		   
		   String path = @"D:\AllErrors.txt";
		  File.WriteAllTest(path,str);
		  Server.trrasfer("~/ErrorPage.html");
		  }
		}
}

Code-Erklärung:-

1. Die erste Zeile besteht darin, den Fehler selbst mithilfe der Methode „Server.GetLastError“ abzurufen. Dieser wird dann der Variablen „exc“ zugewiesen.
2. Anschließend erstellen wir eine leere String-Variable namens „str“. Die eigentliche Fehlermeldung erhalten wir über die Eigenschaft „exc.Message“. Die Eigenschaft exc.Message enthält die genaue Meldung für jeden Fehler, der beim Ausführen der Anwendung auftritt. Dieser wird dann der String-Variablen zugewiesen.
3. Als nächstes definieren wir die Datei mit dem Namen „AllErrrors.txt“. Hier werden alle Fehlermeldungen gesendet. Wir schreiben den String „str“, der alle Fehlermeldungen enthält, in diese Datei.
4. Abschließend übertragen wir den Benutzer in die Datei ErrorPage.html.

Ausgabe:-

Durchsuchen Sie die Seite http://localhost:53003/Demo1.aspx . Denken Sie daran, dass Demo1.aspx in unserer Anwendung nicht vorhanden ist. Sie erhalten dann die folgende Ausgabe.

Und wenn Sie gleichzeitig die Datei „AllErrors.txt“ öffnen, werden Ihnen die folgenden Informationen angezeigt.

Die Fehlermeldung kann dann zu einem späteren Zeitpunkt zur Fehlerbehebung an den Entwickler weitergegeben werden.

Zusammenfassung

• ASP.Net verfügt über die Möglichkeit, Debugging und Fehlerbehandlung durchzuführen.
• Das Debuggen kann durch das Hinzufügen von Haltepunkten zum Code erreicht werden. Anschließend führt man in Visual Studio die Option „Mit Debuggen beginnen“ aus, um den Code zu debuggen.
• Beim Tracing handelt es sich um die Möglichkeit, beim Ausführen der Anwendung weitere Informationen bereitzustellen. Dies kann auf Anwendungs- oder Seitenebene erfolgen.
• Auf Seitenebene muss der Code Trace=true zur Seitenanweisung hinzugefügt werden.
• Auf Anwendungsebene wird eine zusätzliche Seite namens Trace.axd für die Anwendung erstellt. Dadurch werden alle notwendigen Tracing-Informationen bereitgestellt.