Asp.Net sidnivå Tracfelsökning, felsökning, felhantering

I alla applikationer kan fel uppstå under utvecklingsprocessen. Det är viktigt att kunna upptäcka fel i ett tidigt skede.

I Visual Studio är det möjligt att göra detta för ASP.NET-applikationer. Visual Studio används för felsökning och har felhanteringstekniker för ASP.NET.

Vad är felsökning i ASP.NET?

Debugging är processen att lägga till brytpunkter i en applikation. Dessa brytpunkter används för att pausa körningen av ett program som körs. Detta gör det möjligt för utvecklaren att förstå vad som händer i ett program vid en viss tidpunkt.

Låt oss ta ett exempel på ett program. Programmet visar strängen "Vi felsöker" för användaren. Anta att när vi kör programmet visas strängen av någon anledning inte. För att identifiera problemet måste vi lägga till en brytpunkt. Vi kan lägga till en brytpunkt i kodraden som visar strängen. Denna brytpunkt pausar programmets körning. Vid denna tidpunkt kan programmeraren se vad som eventuellt går fel. Programmeraren åtgärdar programmet därefter.

Här i exemplet använder vi vår DemoApplication som skapades i tidigare kapitel. I följande exempel ser vi:

• Hur man får demoapplikationen att visa en sträng.
• Hur man lägger till brytpunkter i en applikation.
• Hur man felsöker applikationen med denna brytpunkt.

Hur man felsöker ett program i ASP.NET

Nedan följer stegen för att skapa en demoapplikation, lägga till brytpunkter och felsöka i ASP.NET:

Steg 1) Öppna programmet i Visual Studio.
Låt oss först se till att vi har vår webbapplikation öppen i Visual Studio. Se till att DemoApplication är öppen i Visual Studio.

Steg 2) Öppna nu filen Demo.aspx.cs och lägg till kodraden nedan.

• Vi lägger bara till kodraden Response.Write för att visa en sträng.
• Så när applikationen körs bör den visa strängen "Vi felsöker" i webbläsaren.

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

Steg 3) Lägg till en brytpunkt i applikationen.
En brytpunkt är en punkt i Visual Studio där du vill att programmet ska stoppas.

1. För att lägga till en brytpunkt måste du klicka på kolumnen där du vill infoga brytpunkten. Så i vårt fall vill vi att vårt program ska stanna vid kodraden "Response.Write". Du behöver inte lägga till något kommando för att lägga till en brytpunkt. Du behöver bara klicka på raden där du vill lägga till en brytpunkt.
2. När detta är gjort kommer du att märka att koden markeras med rött. Dessutom kommer en röd bubbla upp i kolumnen bredvid kodraden.

Obs: Du kan lägga till flera brytpunkter i en applikation.

Steg 4) Kör programmet i felsökningsläge.
Nu måste du köra din applikation med felsökningsläge. I Visual Studio väljer du menyalternativet Debug->Start Debugging.

Produktion:-

När du utför alla steg korrekt kommer exekveringen av programmet att avbrytas. Visual Studio kommer att gå till brytpunkten och markera kodraden i gult.

Nu, om programmeraren känner att koden är felaktig, kan exekveringen stoppas. Koden kan sedan ändras därefter. För att fortsätta med programmet måste programmeraren klicka på F5-knappen på tangentbordet.

Vad är TracAnvända ASP.NET?

Ansökan tracanvändning låter en se om några begärda sidor resulterar i ett fel. tracär aktiverad, en extra sida som heter trace.axd läggs till i applikationen (se bilden nedan). Den här sidan är bifogad till applikationen och visar alla förfrågningar och deras status.

Så här aktiverar du Tracför en applikation i ASP.NET

Låt oss titta på hur man aktiverar tracing för en ASP.NET-applikation:

Steg 1) Låt oss arbeta med vår DemoApplication. Öppna web.config-filen från Solution Explorer.

Steg 2) Lägg till följande kodrad i web.config-filen. trace-satsen används för att aktivera tracför ansökan.

• RequestLimit i trace-satsen anger antalet sidförfrågningar som måste göras traced.
• I vårt exempel anger vi en gräns på 40. Vi anger en gräns eftersom ett högre värde försämrar programmets prestanda.

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

Kör demoapplikationen i Visual Studio.

Produktion:-

Om du nu bläddrar till URL http://localhost:53003/trace.axd, ser du informationen för varje begäran. Här kan du se om några fel uppstår i en applikation. Följande typer av information visas på sidan:

1. Tidpunkten för begäran om webbsidan.
2. Namnet på den webbsida som begärs.
3. Statuskoden för webbförfrågan (en statuskod på 200 betyder att förfrågan lyckades).
4. Länken Visa detaljer som låter dig se mer information om webbförfrågan. En viktig detalj som anges är rubrikinformationen, som visar vilken information som skickas i rubriken för varje webbförfrågan.

Sidnivå Traci ASP.NET

Sidnivå Tracanvändning I ASP.NET visas all allmän information om en webbsida när den bearbetas. Detta är användbart vid felsökning om en sida inte fungerar av någon anledning. Visual Studio ger detaljerad information om olika aspekter av sidan, till exempel tiden för varje metod som anropas i webbförfrågan.

Om till exempel din webbapplikation har prestandaproblem kan den här informationen hjälpa till att felsöka problemet. Informationen visas när applikationen körs i Visual Studio.

Så här aktiverar du Tracpå sidnivå i ASP.NET

Låt oss titta på hur man aktiverar sidnivå tracför en ASP.NET-applikation:

Steg 1) Låt oss arbeta med vår DemoApplication. Öppna filen demo.aspx från Solution Explorer.

Steg 2) Lägg till kodraden nedan för att aktivera sidan tracing. I Page-deklarationen, lägg bara till attributet Trace="true". Den här kodraden tillåter sidnivå 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>

Kör programmet i Visual Studio.

Produktion:-

Nu när webbsidan Demo.aspx visas kommer du att få en hel del information om sidan. Information såsom tiden för varje aspekt av sidans livscykel visas på den här sidan.

Felhantering: Visar en anpassad felsida

In ASP.NET, kan du få anpassade felsidor att visas för användarna. Om en applikation innehåller någon form av fel kommer en anpassad sida att visa detta fel för användaren.

I vårt exempel ska vi först lägga till en HTML-sida. Den här sidan visar en sträng för användaren med texten "Vi undersöker problemet". Sedan lägger vi till en felkod på vår demo.aspx-sida så att felsidan visas. Låt oss följa stegen nedan.

Steg 1) Låt oss arbeta med vår demoapplikation. Låt oss lägga till en HTML-sida i applikationen.

1. Högerklicka på DemoApplication i Solution Explorer.
2. Välj menyalternativet Lägg till->HTML-sida.

Steg 2) I nästa steg måste vi ge ett namn till den nya HTML-sidan.

1. Ange namnet som ErrorPage.
2. Klicka på OK-knappen för att fortsätta.

Steg 3) ErrorPage öppnas automatiskt i Visual Studio. Om du går till Solution Explorer ser du filen tillagd.

Lägg till kodraden "Vi undersöker problemet" på HTML-sidan. Du behöver inte stänga HTML-filen innan du gör ändringen i web.config-filen.

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

Steg 4) Nu behöver du göra en ändring i web.config-filen. Denna ändring meddelar att när ett fel uppstår i applikationen måste den anpassade felsidan visas. Taggen customErrors gör det möjligt att definiera en anpassad felsida. Egenskapen defaultRedirect sätts till namnet på vår anpassade felsida som skapades i föregående steg.

<configuration>
    <system.web>
        <compilation debug="true" targetFramework="4.0" />
        <httpRuntime targetFramework="4.0" />

        <customErrors mode="On" defaultRedirect="ErrorPage.html">
        </customErrors>

    </system.web>
</configuration>

Steg 5) Nu ska vi lägga till lite felaktig kod på sidan demo.aspx.cs. Öppna sidan genom att dubbelklicka på filen i Solution Explorer.

Lägg till koden nedan i filen Demo.aspx.cs.

• Dessa kodrader är utformade för att läsa textrader från en fil.
• Filen ska finnas på D-enheten med namnet Example.txt.
• Men i vår situation finns den här filen inte riktigt. Så den här koden kommer att resultera i ett fel när programmet körs.

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

Kör nu koden in Visual Studio och du bör få utdata nedan.

Produktion:-

Sidan ovan visar att ett fel har utlösts i applikationen. Som ett resultat visas sidan ErrorPage.html för användaren.

ASP.NET Ohanterat undantag

Även i de bästa fall kan det förekomma fel som helt enkelt inte förutses. Anta att en användare bläddrar till fel sida i applikationen. Detta är något som inte kan förutses. I sådana fall kan ASP.NET omdirigera användaren till ErrorPage.html.

Låt oss se ett exempel på detta.

• Vi kommer att använda samma DemoApplication som har ErrorPage.html.
• Och vi kommer att försöka se en webbsida som inte finns i vår applikation.
• Vi bör i det här fallet omdirigeras till vår ErrorPage.html-sida. Låt oss se stegen för att uppnå detta.

Steg 1) Låt oss arbeta med vår DemoApplication. Öppna filen Global.asax.cs från Solution Explorer.

Obs: Filen Global.asax.cs används för att lägga till kod som kommer att vara tillämplig på alla sidor i applikationen.

Steg 2) Lägg till följande kodrad i Global.asax.cs. Dessa rader kommer att användas för att kontrollera om det finns fel och visa ErrorPage.html-sidan i enlighet med detta.

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 Förklaring:-

1. Den första raden är händelsehanteraren Application_Error. Denna händelse anropas när ett fel uppstår i ett program. Observera att händelsenamnet måste vara Application_Error och att parametrarna ska vara som visas ovan.
2. Därefter definierar vi ett objekt av klasstypen HttpException. Detta är ett standardobjekt som kommer att innehålla alla detaljer om felet. Vi använder sedan Server.GetLastError-metoden för att få alla detaljer om det senaste felet som inträffade i applikationen.
3. Vi kontrollerar sedan om felkoden för det senaste felet är 404 (felkoden 404 är standardkoden som returneras när en användare bläddrar till en sida som inte hittas). Vi överför sedan användaren till sidan ErrorPage.html om felkoden matchar.

Kör nu koden i Visual Studio så bör du få följande utdata.

Produktion:-

Bläddra på sidan http://localhost:53003/Demo1.aspx. Kom ihåg att Demo1.aspx inte finns i vår applikation. Du får då utdata nedan.

Sidan ovan visar att ett fel har utlösts i applikationen. Som ett resultat visas sidan ErrorPage.html för användaren.

ASP.NET-felloggning

Genom att logga programfel hjälper det utvecklaren att felsöka och lösa felet vid en senare tidpunkt. ASP.NET har möjlighet att logga fel. Detta görs i Global.asax.cs-filen när felet registreras. Under registreringsprocessen kan felmeddelandet skrivas till en loggfil.

Låt oss se ett exempel på detta.

• Vi kommer att använda samma DemoApplication som har ErrorPage.html.
• Och vi kommer att försöka se en webbsida som inte finns i vår applikation.
• Vi bör omdirigeras till vår ErrorPage.html-sida i det här fallet.
• Och samtidigt skriver vi felmeddelandet till en loggfil. Låt oss se stegen för att uppnå detta.

Steg 1) Låt oss arbeta med vår DemoApplication. Öppna filen Global.asax.cs från Solution Explorer.

Steg 2) Lägg till följande kodrad i Global.asax.cs. Den kommer att söka efter fel och visa sidan ErrorPage.html i enlighet med detta. Samtidigt loggar vi felinformationen i en fil som heter AllErrors.txt. I vårt exempel skriver vi kod för att skapa den här filen på D-enheten.

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 Förklaring:-

1. Den första raden är till för att hämta själva felet med hjälp av Server.GetLastError-metoden. Detta tilldelas sedan variabeln exc.
2. Sedan skapar vi en tom strängvariabel som heter str. Vi får det faktiska felmeddelandet med hjälp av egenskapen exc.Message. Egenskapen exc.Message kommer att ha det exakta meddelandet för alla fel som uppstår när applikationen körs. Detta tilldelas sedan strängvariabeln.
3. Nästa steg är att definiera filen AllErrors.txt. Det är hit alla felmeddelanden skickas. Vi skriver strängen str som innehåller alla felmeddelanden till den här filen.
4. Slutligen överför vi användaren till filen ErrorPage.html.

Produktion:-

Bläddra på sidan http://localhost:53003/Demo1.aspx. Kom ihåg att Demo1.aspx inte finns i vår applikation. Du får då utdata nedan.

Och samtidigt, om du öppnar filen AllErrors.txt kommer du att se informationen nedan.

Felmeddelandet kan sedan skickas vidare till utvecklaren vid en senare tidpunkt i felsökningssyfte.

Vanliga frågor