Asp.Net Traceren op paginaniveau, debuggen, foutafhandeling [voorbeeld]

In elke toepassing kunnen fouten optreden tijdens het ontwikkelingsproces. Het is belangrijk om fouten in een vroeg stadium te kunnen ontdekken.

In Visual Studio is het mogelijk om dit te doen voor ASP.Net-applicaties. Visual Studio wordt gebruikt voor Debugging en heeft foutbehandelingstechnieken voor ASP.Net.

Wat is foutopsporing in ASP.NET?

Foutopsporing is het proces waarbij breekpunten aan een toepassing worden toegevoegd. Deze breekpunten worden gebruikt om de uitvoering van een lopend programma te pauzeren. Hierdoor kan de ontwikkelaar begrijpen wat er op een bepaald moment in een programma gebeurt.

Laten we een voorbeeld van een programma nemen. Het programma toont de string "We are debugging" aan de gebruiker. Stel dat wanneer we de applicatie uitvoeren, om een ​​of andere reden de string niet wordt weergegeven. Om het probleem te identificeren, moeten we een breekpunt toevoegen. We kunnen een breekpunt toevoegen aan de coderegel die de string weergeeft. Dit breekpunt zal de uitvoering van het programma pauzeren. Op dit punt kan de programmeur zien wat er mogelijk misgaat. De programmeur corrigeert het programma dienovereenkomstig.

Hier in het voorbeeld gebruiken we onze 'DemoApplication' die in eerdere hoofdstukken is gemaakt. In het volgende voorbeeld zien we

• Hoe u ervoor kunt zorgen dat de demo-applicatie een string weergeeft.
• Hoe u breekpunten aan een toepassing kunt toevoegen.
• Hoe u fouten in de toepassing kunt opsporen met behulp van dit breekpunt.

Hoe een applicatie in ASP.NET te debuggen

Hieronder staan ​​de stappen om een ​​demo-applicatie te maken, breekpunten toe te voegen en fouten te debuggen in ASP.Net:

Stap 1) Open de applicatie in Visual Studio
Laten we eerst controleren of onze webapplicatie open is in Visual Studio. Controleer of de DemoApplication open is in Visual Studio.

Stap 2) Open nu het bestand Demo.aspx.cs en voeg de onderstaande coderegel toe.

• We voegen alleen de coderegel Response.Write toe om een ​​string weer te geven.
• Dus wanneer de applicatie wordt uitgevoerd, zou deze de string “We are debugging” in de webbrowser moeten weergeven.

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

Stap 3) Voeg een breekpunt toe aan de applicatie
Een breekpunt is een punt in Visual Studio waarop u wilt dat de uitvoering van het programma stopt.

1. Om een ​​breekpunt toe te voegen, moet u op de kolom klikken waar u het breekpunt wilt invoegen. Dus in ons geval willen we dat ons programma stopt bij de coderegel "Response.Write". U hoeft geen opdracht toe te voegen om een ​​breekpunt toe te voegen. U hoeft alleen maar op de lijn te klikken waaraan u een breekpunt wilt toevoegen.
2. Zodra dit is gebeurd, zult u merken dat de code rood wordt gemarkeerd. Er verschijnt ook een rode bel in de kolom naast de coderegel.

Notitie: - U kunt meerdere breekpunten toevoegen aan een toepassing

Stap 4) Voer de applicatie uit in de foutopsporingsmodus
Nu moet u uw applicatie uitvoeren met behulp van de Debugging Mode. Kies in Visual Studio de menuoptie Debug->Start Debugging.

Uitgang: -

Wanneer u alle stappen correct uitvoert, zal de uitvoering van het programma worden afgebroken. Visual Studio gaat naar het breekpunt en markeert de regel code in het geel.

Als de programmeur nu van mening is dat de code onjuist is, kan de uitvoering worden gestopt. De code kan vervolgens dienovereenkomstig worden aangepast. Om door te gaan met het programma, moet de programmeur op de F5-knop op het toetsenbord klikken.

Wat is tracering in ASP.NET?

Met applicatietracering kunt u zien of opgevraagde pagina's een fout opleveren. Wanneer tracering is ingeschakeld, wordt een extra pagina met de naam trace.axd aan de toepassing toegevoegd. (Zie afbeelding hieronder). Deze pagina is bij de aanvraag gevoegd. Op deze pagina worden alle verzoeken en hun status weergegeven.

Tracering inschakelen voor een toepassing in ASP.NET

Laten we eens kijken hoe u tracering voor een ASP.Net-applicatie:

Stap 1) Laten we werken aan onze 'DemoApplicatie'. Open het web.config-bestand vanuit de Solution Explorer.

Stap 2) Voeg de onderstaande coderegel toe aan het Web.config-bestand.

De trace-instructie wordt gebruikt om tracering voor de toepassing mogelijk te maken.

• De 'requestLimit' in de traceringsinstructie wordt gebruikt. Het specificeert het aantal paginaverzoeken dat moet worden getraceerd.
• In ons voorbeeld geven we een limiet van 40. We geven een limiet omdat een hogere waarde de prestaties van de applicatie zal verslechteren.

<?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>

Voer de “demoapplicatie” uit in Visual Studio.

Uitgang: -

Als u nu naar de URL bladert – http://localhost:53003/trace.axd , ziet u de informatie voor elk verzoek. Hier kunt u zien of er fouten optreden in een toepassing. De volgende soorten informatie worden weergegeven op de bovenstaande pagina

1. Het tijdstip van de aanvraag voor de webpagina.
2. De naam van de webpagina die wordt opgevraagd.
3. De statuscode van het webverzoek. (statuscode 200 betekent dat de aanvraag succesvol is).
4. De View details waarmee u meer details over de webaanvraag kunt bekijken. Hieronder ziet u een voorbeeld. Een belangrijke gedetailleerde informatie die wordt verstrekt, is de headerinformatie. Deze informatie toont welke informatie in de header van elke webaanvraag wordt verzonden.

Als uw webapplicatie bijvoorbeeld een prestatieprobleem heeft, kan deze informatie helpen bij het debuggen van het probleem. Deze informatie wordt weergegeven wanneer de applicatie in Visual Studio wordt uitgevoerd.

Hoe u tracering op paginaniveau in ASP.NET kunt inschakelen

Laten we eens kijken hoe u tracering op paginaniveau kunt inschakelen voor een ASP.Net-toepassing:

Stap 1) Laten we aan onze demo-applicatie werken. Open het demo.aspx-bestand vanuit de Solution Explorer

Stap 2) Voeg de onderstaande coderegel toe om paginatracering in te schakelen. Voeg in de paginadeclaratie gewoon de regel Trace=”true” toe. Deze coderegel maakt tracering op paginaniveau mogelijk.

<%@ 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>

Voer de toepassing uit in Visual Studio.

Uitgang: -

Wanneer de webpagina Demo.aspx nu wordt weergegeven, krijgt u een heleboel informatie over de pagina. Informatie zoals de tijd voor elk aspect van de levenscyclus van de pagina wordt op deze pagina weergegeven.

Foutafhandeling: een aangepaste foutpagina weergeven

In ASP.Net, kunt u aangepaste foutpagina's laten weergeven aan de gebruikers. Als een applicatie een fout bevat, zal een aangepaste pagina deze fout aan de gebruiker weergeven.

In ons voorbeeld gaan we eerst een HTML-pagina toevoegen. Op deze pagina wordt een tekenreeks voor de gebruiker weergegeven: 'We onderzoeken het probleem'. We zullen dan een foutcode toevoegen aan onze demo.aspx-pagina, zodat de foutpagina wordt weergegeven.

Laten we de onderstaande stappen volgen

Stap 1) Laten we aan onze demo-applicatie werken. Laten we een HTML-pagina aan de applicatie toevoegen

1. Klik met de rechtermuisknop op de demotoepassing in Solution Explorer
2. Kies de menuoptie 'Toevoegen' -> HTML-pagina

Stap 2) In de volgende stap moeten we een naam opgeven voor de nieuwe HTML-pagina.

1. Geef als naam 'ErrorPage' op.
2. Klik op de knop 'OK' om door te gaan.

Stap 3) De Errorpage wordt automatisch geopend in Visual Studio. Als u naar de Solution Explorer gaat, ziet u dat het bestand is toegevoegd.

Voeg de coderegel 'We onderzoeken het probleem' toe aan de HTML-pagina. U hoeft het HTML-bestand niet te sluiten voordat u de wijziging in het web.config-bestand aanbrengt.

<!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>

Stap 4) Nu moet u een wijziging aanbrengen in het web.config-bestand. Deze wijziging zal melden dat wanneer er een fout optreedt in de applicatie, de aangepaste foutpagina moet worden weergegeven.

Met de tag 'customErrors' kunt u een aangepaste foutpagina definiëren. De eigenschap defaultRedirect wordt ingesteld op de naam van de aangepaste foutpagina die in de vorige stap is gemaakt.

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

		
	</system.web>
</configuration>

Stap 5) Laten we nu wat foutieve code toevoegen aan de demo.aspx.cs pagina. Open deze pagina door dubbel te klikken op het bestand in Solution Explorer

Voeg de onderstaande code toe aan het bestand Demo.aspx.cs.

• Deze coderegels zijn ontworpen om de regels van een tekst uit een bestand te lezen.
• Het bestand zou zich op de D-schijf moeten bevinden met de naam 'Example.txt'.
• Maar in onze situatie bestaat dit bestand niet echt. Deze code resulteert dus in een fout wanneer de applicatie wordt uitgevoerd.

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

Voer nu de code uit Visual Studio en je zou de onderstaande uitvoer moeten krijgen.

Uitgang: -

De bovenstaande pagina toont dat er een fout is geactiveerd in de applicatie. Als gevolg hiervan wordt de pagina Error.html aan de gebruiker getoond.

ASP.NET onverwerkte uitzondering

Zelfs in de beste scenario's kunnen er gevallen van fouten voorkomen die gewoon niet te voorzien zijn.

Stel dat een gebruiker naar de verkeerde pagina in de applicatie bladert. Dit is iets dat niet kan worden voorspeld. In dergelijke gevallen kan ASP.Net de gebruiker doorsturen naar de errorpage.html.

Laten we hiervan een voorbeeld bekijken.

• We gaan dezelfde 'DemoApplication' gebruiken die de Errorpage.html heeft.
• En we zullen proberen een webpagina te bekijken die niet bestaat in onze applicatie.
• In dit geval moeten we worden doorgestuurd naar onze ErrorPage.html-pagina. Laten we eens kijken naar de stappen om dit te bereiken.

Stap 1) Laten we aan onze demo-applicatie werken. Open het bestand Global.asax.cs vanuit de Solution Explorer

NOTITIE: Het bestand global.asax.cs wordt gebruikt om code toe te voegen die van toepassing is op alle pagina's in de applicatie.

Stap 2) Voeg de onderstaande coderegel toe aan global.asax.cs. Deze regels worden gebruikt om op fouten te controleren en de pagina ErrorPage.html dienovereenkomstig weer te geven.

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-uitleg: -

1. De eerste regel is de gebeurtenishandler Application_Error. Deze gebeurtenis wordt aangeroepen wanneer er een fout optreedt in een toepassing. Houd er rekening mee dat de gebeurtenisnaam 'Application_Error' moet zijn. En de parameters moeten zijn zoals hierboven weergegeven.
2. Vervolgens definiëren we een object van het klassetype HttpException. Dit is een standaardobject dat alle details van de fout bevat. Vervolgens gebruiken we de Server.GetLastError-methode om alle details van de laatste fout die in de toepassing is opgetreden, op te halen.
3. Vervolgens controleren we of de foutcode van de laatste fout 404 is. (De foutcode 404 is de standaardcode die wordt geretourneerd wanneer een gebruiker naar een pagina bladert die niet wordt gevonden). Vervolgens sturen we de gebruiker door naar de ErrorPage.html-pagina als de foutcode overeenkomt.

Voer de code nu uit in Visual Studio en u zou de onderstaande uitvoer moeten krijgen

Uitgang: -

Blader door de pagina http://localhost:53003/Demo1.aspx . Houd er rekening mee dat Demo1.aspx niet bestaat in onze applicatie. Je krijgt dan onderstaande uitvoer.

De bovenstaande pagina toont dat er een fout is geactiveerd in de applicatie. Als gevolg hiervan wordt de pagina Error.html aan de gebruiker getoond.

ASP.NET Foutregistratie

Door applicatiefouten te loggen, helpt het de ontwikkelaar om de fout op een later tijdstip te debuggen en op te lossen. ASP.Net heeft de mogelijkheid om fouten te loggen. Dit gebeurt in het bestand Global.asax.cs wanneer de fout wordt vastgelegd. Tijdens het vastleggen kan het foutbericht in een logbestand worden geschreven.

Laten we hiervan een voorbeeld bekijken.

• We gaan dezelfde DemoApplication gebruiken die de Errorpage.html heeft.
• En we zullen proberen een webpagina te bekijken die niet bestaat in onze applicatie.
• In dit geval moeten we worden doorgestuurd naar onze ErrorPage.html-pagina.
• En tegelijkertijd schrijven we de foutmelding naar een logbestand. Laten we eens kijken naar de stappen om dit te bereiken.

Stap 1) Laten we aan onze demo-applicatie werken. Open het bestand Global.asax.cs vanuit de Solution Explorer

Stap 2) Voeg de onderstaande regel code toe aan global.asax.cs. Het zal controleren op fouten en de ErrorPage.html pagina dienovereenkomstig weergeven. Tegelijkertijd zullen we de foutdetails loggen in een bestand genaamd 'AllErrors.txt.' Voor ons voorbeeld zullen we code schrijven om dit bestand te maken op de D-schijf.

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-uitleg: -

1. De eerste regel is om de fout zelf op te halen met behulp van de 'Server.GetLastError'-methode. Deze wordt vervolgens toegewezen aan de variabele 'exc'.
2. Vervolgens maken we een lege stringvariabele genaamd 'str'. We krijgen de daadwerkelijke foutmelding met behulp van de eigenschap 'exc.Message'. De eigenschap exc.Message heeft het exacte bericht voor elke fout die optreedt bij het uitvoeren van de toepassing. Deze wordt vervolgens toegewezen aan de stringvariabele.
3. Vervolgens definiëren we het bestand met de naam 'AllErrrors.txt.' Hier worden alle foutmeldingen verzonden. We schrijven de string 'str' die alle foutmeldingen bevat naar dit bestand.
4. Ten slotte brengen we de gebruiker over naar het bestand ErrorPage.html.

Uitgang: -

Blader door de pagina http://localhost:53003/Demo1.aspx . Houd er rekening mee dat Demo1.aspx niet bestaat in onze applicatie. Je krijgt dan onderstaande uitvoer.

En als u tegelijkertijd het bestand 'AllErrors.txt' opent, ziet u de onderstaande informatie.

De foutmelding kan dan op een later tijdstip aan de ontwikkelaar worden doorgegeven voor foutopsporing.

Samenvatting

• ASP.Net heeft de mogelijkheid om foutopsporing en foutafhandeling uit te voeren.
• Debuggen kan worden bereikt door breakpoints toe te voegen aan de code. Vervolgens voert men de optie Start with Debugging uit in Visual Studio om de code te debuggen.
• Tracing is de mogelijkheid om meer informatie te verstrekken terwijl de applicatie draait. Dit kan op applicatie- of paginaniveau.
• Op paginaniveau moet de code Trace=true worden toegevoegd aan de pagina-instructie.
• Op applicatieniveau wordt voor de applicatie een extra pagina aangemaakt met de naam Trace.axd. Dit levert alle benodigde traceerinformatie op.