ASP.NET-paginaniveau TracDebuggen, Foutafhandeling

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 dit mogelijk voor ASP.NET-applicaties. Visual Studio wordt gebruikt voor debuggen en beschikt over foutafhandelingstechnieken voor ASP.NET.

Wat is foutopsporing in ASP.NET?

Debugging Het toevoegen van breakpoints aan een applicatie is een proces waarbij de uitvoering van een programma wordt gepauzeerd. Hierdoor kan de ontwikkelaar inzicht krijgen in wat er op een bepaald moment in het programma gebeurt.

Laten we een voorbeeld nemen van een programma. Het programma toont de tekst "We are debugging" aan de gebruiker. Stel dat wanneer we de applicatie uitvoeren, deze tekst om de een of andere reden niet wordt weergegeven. Om het probleem te identificeren, moeten we een breakpoint toevoegen. We kunnen een breakpoint plaatsen op de regel code die de tekst weergeeft. Dit breakpoint pauzeert de uitvoering van het programma. Op dit punt kan de programmeur zien wat er mogelijk misgaat. De programmeur kan het programma vervolgens aanpassen.

In dit voorbeeld gebruiken we onze demo-applicatie die we in eerdere hoofdstukken hebben gemaakt. In het volgende voorbeeld zullen we het volgende zien:

• 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 debug je een applicatie in ASP.NET?

Hieronder volgen de stappen voor het maken van een demo-applicatie, het toevoegen van breakpoints en het debuggen in ASP.NET:

Stap 1) Open de applicatie in Visual Studio.
Laten we er eerst voor zorgen dat onze webapplicatie geopend is in Visual Studio. Zorg ervoor dat de DemoApplication geopend 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 breakpoint 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, klikt u op de kolom waar u het breekpunt wilt plaatsen. In ons geval willen we dat het programma stopt bij de regel "Response.Write". U hoeft geen opdracht toe te voegen om een ​​breekpunt te plaatsen. U hoeft alleen maar op de regel te klikken waar u het breekpunt wilt invoegen.
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.

Let op: Je kunt meerdere breakpoints toevoegen aan een applicatie.

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 Tracing in ASP.NET?

Toepassing tracING Hiermee kun je zien of er fouten optreden bij de opgevraagde pagina's. Wanneer tracing is ingeschakeld, een extra pagina genaamd trace.axd is toegevoegd aan de applicatie (zie onderstaande afbeelding). Deze pagina is gekoppeld aan de applicatie en toont alle aanvragen en hun status.

Hoe in te schakelen Traceen applicatie ontwikkelen in ASP.NET

Laten we eens kijken hoe we dit kunnen inschakelen. tracing voor een ASP.NET-toepassing:

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

Stap 2) Voeg de onderstaande regel code toe aan het web.config-bestand. tracDe e-verklaring wordt gebruikt om in te schakelen tracing voor de aanvraag.

• De requestLimit in de tracDe e-instructie specificeert het aantal paginaverzoeken dat moet worden uitgevoerd. traced..
• In ons voorbeeld stellen we een limiet van 40 in. We geven een limiet op omdat een hogere waarde de prestaties van de applicatie negatief zal beïnvloeden.

<?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 enabled="true" pageOutput="false" requestLimit="40" localOnly="false" />

    </system.web>
</configuration>

Voer de demo-applicatie uit in Visual Studio.

Uitgang: -

Als u nu naar de volgende pagina navigeert: URL http://localhost:53003/trace.axdHier ziet u de informatie voor elk verzoek. U kunt hier zien of er fouten zijn opgetreden in een applicatie. De volgende soorten informatie worden op de pagina weergegeven:

1. Het tijdstip van de aanvraag voor de webpagina.
2. De naam van de opgevraagde webpagina.
3. De statuscode van het webverzoek (een statuscode van 200 betekent dat het verzoek succesvol is).
4. Via de link 'Details bekijken' kunt u meer informatie over het webverzoek inzien. Een belangrijk detail dat wordt weergegeven, is de headerinformatie, die laat zien welke gegevens in de header van elk webverzoek worden verzonden.

Paginaniveau Tracing in ASP.NET

Paginaniveau TracING In ASP.NET wordt alle algemene informatie over een webpagina weergegeven tijdens de verwerking. Dit is handig bij het debuggen als een pagina om welke reden dan ook niet werkt. Visual Studio biedt gedetailleerde informatie over verschillende aspecten van de pagina, zoals de tijd die nodig is voor elke methode die in het webverzoek wordt aangeroepen.

Als uw webapplicatie bijvoorbeeld prestatieproblemen ondervindt, kan deze informatie helpen bij het oplossen van het probleem. Deze informatie wordt weergegeven wanneer de applicatie in Visual Studio wordt uitgevoerd.

Hoe in te schakelen Tracing op paginaniveau in ASP.NET

Laten we eens kijken hoe we paginaniveau kunnen inschakelen. tracing voor een ASP.NET-applicatie:

Stap 1) Laten we aan de slag gaan met onze demo-applicatie. Open het bestand demo.aspx in de Solution Explorer.

Stap 2) Voeg de onderstaande code toe om de pagina in te schakelen. tracing. Voeg in de paginadeclaratie eenvoudigweg het attribuut toe. Trace=”true”. Deze coderegel maakt paginaniveau mogelijk. tracIng.

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

<!DOCTYPE html>
<html xmlns="http://www.w3.org/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 voegen we eerst een HTML-pagina toe. Deze pagina toont de gebruiker de tekst "We onderzoeken het probleem". Vervolgens voegen we foutcode toe aan onze demo.aspx-pagina, zodat de foutpagina wordt weergegeven. Volg hiervoor de onderstaande stappen.

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

1. Klik met de rechtermuisknop op DemoApplication 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 de naam op als ErrorPage.
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 are looking into the problem" 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.org/1999/xhtml">
<head runat="server">
    <title></title>
</head>
<body>
    We are looking into the problem
</body>
</html>

Stap 4) Nu moet je een wijziging aanbrengen in het web.config-bestand. Deze wijziging zorgt ervoor dat de aangepaste foutpagina wordt weergegeven wanneer er een fout optreedt in de applicatie. Met de tag customErrors kun je een aangepaste foutpagina definiëren. De eigenschap defaultRedirect wordt ingesteld op de naam van de aangepaste foutpagina die we in de vorige stap hebben 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 pagina demo.aspx.cs. 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 regels code zijn ontworpen om de tekstregels uit een bestand te lezen.
• Het bestand zou zich op de D-schijf moeten bevinden onder 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 laat zien dat er een fout is opgetreden in de applicatie. Als gevolg hiervan wordt de pagina ErrorPage.html aan de gebruiker getoond.

ASP.NET onverwerkte uitzondering

Zelfs in de meest gunstige scenario's kunnen er onverwachte fouten optreden. Stel dat een gebruiker op de verkeerde pagina van de applicatie terechtkomt. Dit is iets wat niet te voorspellen is. In dergelijke gevallen kan ASP.NET de gebruiker doorverwijzen naar ErrorPage.html.

Laten we eens een voorbeeld bekijken.

• We gaan dezelfde demo-applicatie gebruiken die de ErrorPage.html bevat.
• En we zullen proberen een webpagina te bekijken die niet bestaat in onze applicatie.
• In dit geval zouden we moeten worden doorgestuurd naar onze ErrorPage.html-pagina. Laten we eens kijken hoe we dit kunnen bereiken.

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

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

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

namespace DemoApplication
{
    public class Global : System.Web.HttpApplication
    {
        protected void Application_Error(object sender, EventArgs e)
        {
            HttpException lastErrorWrapper = Server.GetLastError() as HttpException;

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

Code Uitleg:-

1. De eerste regel is de eventhandler voor Application_Error. Deze eventhandler wordt aangeroepen wanneer er een fout optreedt in een applicatie. Let op: de eventnaam moet Application_Error zijn en de parameters moeten overeenkomen met de parameters die hierboven worden 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 (foutcode 404 is de standaardcode die wordt geretourneerd wanneer een gebruiker een pagina probeert te openen die niet gevonden kan worden). Als de foutcode overeenkomt, sturen we de gebruiker door naar de pagina ErrorPage.html.

Voer de code nu uit in Visual Studio en je 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 laat zien dat er een fout is opgetreden in de applicatie. Als gevolg hiervan wordt de pagina ErrorPage.html aan de gebruiker getoond.

ASP.NET-foutregistratie

Door applicatiefouten te loggen, kan de ontwikkelaar de fout later gemakkelijker opsporen en oplossen. ASP.NET biedt de mogelijkheid om fouten te loggen. Dit gebeurt in het bestand Global.asax.cs wanneer de fout optreedt. Tijdens het vastleggen van de fout kan het foutbericht in een logbestand worden geschreven.

Laten we eens een voorbeeld bekijken.

• We gaan dezelfde demo-applicatie gebruiken die de ErrorPage.html bevat.
• 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.
• Tegelijkertijd schrijven we het foutbericht naar een logbestand. Laten we eens kijken hoe we dit kunnen 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 code toe aan Global.asax.cs. Deze code controleert op fouten en geeft de ErrorPage.html-pagina weer. Tegelijkertijd worden de foutdetails opgeslagen in een bestand met de naam AllErrors.txt. In ons voorbeeld schrijven we code om dit bestand op de D-schijf aan te maken.

namespace DemoApplication
{
    public class Global : System.Web.HttpApplication
    {
        protected void Application_Error(object sender, EventArgs e)
        {
            Exception exc = Server.GetLastError();
            String str = "";
            str = exc.Message;

            String path = @"D:\AllErrors.txt";
            File.WriteAllText(path, str);
            Server.Transfer("~/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 aan met de naam `str`. We halen het daadwerkelijke foutbericht op met behulp van de eigenschap `exc.Message`. De eigenschap `exc.Message` bevat het exacte bericht voor elke fout die optreedt tijdens het uitvoeren van de applicatie. Dit bericht wordt vervolgens toegewezen aan de stringvariabele.
3. Vervolgens definiëren we het bestand met de naam AllErrors.txt. Hier worden alle foutmeldingen naartoe gestuurd. We schrijven de tekenreeks 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 tegelijkertijd, als je het bestand AllErrors.txt opent, zie je de onderstaande informatie.

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

Veelgestelde vragen