Tracciatura a livello di pagina Asp.Net, debug, gestione degli errori [Esempio]
Giacobbe Lee
In qualsiasi applicazione, è probabile che si verifichino errori durante il processo di sviluppo. È importante poter scoprire gli errori in una fase iniziale.
In Visual Studio, è possibile farlo per le applicazioni ASP.Net. Visual Studio è utilizzato per il debug e ha tecniche di gestione degli errori per ASP.Net.
Cos'è il debug in ASP.NET?
Il debug è il processo di aggiunta di punti di interruzione a un'applicazione. Questi punti di interruzione vengono utilizzati per mettere in pausa l'esecuzione di un programma in esecuzione. Ciò consente allo sviluppatore di capire cosa sta succedendo in un programma in un particolare momento.
Prendiamo un esempio di programma. Il programma mostra all'utente la stringa "Stiamo eseguendo il debug". Supponiamo che quando eseguiamo l'applicazione, per qualche motivo, la stringa non venga visualizzata. Per identificare il problema dobbiamo aggiungere un punto di interruzione. Possiamo aggiungere un punto di interruzione alla riga di codice che visualizza la stringa. Questo punto di interruzione metterà in pausa l'esecuzione del programma. A questo punto, il programmatore può vedere cosa potrebbe non andare storto. Il programmatore rettifica il programma di conseguenza.
Qui nell'esempio, useremo la nostra 'DemoApplication' creata nei capitoli precedenti. Nell'esempio seguente, vedremo
- Come fare in modo che l'applicazione demo visualizzi una stringa.
- Come aggiungere punti di interruzione a un'applicazione.
- Come eseguire il debug dell'applicazione utilizzando questo punto di interruzione.
Come eseguire il debug di un'applicazione in ASP.NET
Di seguito sono riportati i passaggi per creare un'applicazione demo, aggiungere punti di interruzione ed eseguire il debug in ASP.Net:
Passaggio 1) Aprire l'applicazione in Visual Studio
Per prima cosa assicuriamoci di avere la nostra applicazione web aperta in Visual Studio. Assicuriamoci che DemoApplication sia aperta in Visual Studio.
Passaggio 2) Ora apri il file Demo.aspx.cs e aggiungi la riga di codice seguente.
- Stiamo semplicemente aggiungendo la riga di codice Response.Write per visualizzare una stringa.
- Pertanto, quando l'applicazione viene eseguita, dovrebbe visualizzare la stringa "Stiamo eseguendo il debug" nel browser web.
namespace DemoApplication
{
public partial class Demo : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
Response.Write("We are debugging");
}
}
}
Passaggio 3) Aggiungere un punto di interruzione all'applicazione
Un punto di interruzione è un punto in Visual Studio in cui si desidera interrompere l'esecuzione del programma.
- Per aggiungere un punto di interruzione, è necessario fare clic sulla colonna in cui si desidera inserire il punto di interruzione. Quindi, nel nostro caso, vogliamo che il nostro programma si fermi alla riga di codice “Response.Write”. Non è necessario aggiungere alcun comando per aggiungere un punto di interruzione. Devi solo fare clic sulla riga su cui desideri aggiungere un punto di interruzione.
- Fatto ciò, noterai che il codice viene contrassegnato in rosso. Inoltre, nella colonna accanto alla riga del codice appare una bolla rossa.
Nota: - È possibile aggiungere più punti di interruzione in un'applicazione
Passaggio 4) Eseguire l'applicazione in modalità Debug
Ora devi eseguire la tua applicazione usando la modalità Debug. In Visual Studio, scegli l'opzione di menu Debug->Start Debugging.
Produzione:-
Quando esegui tutti i passaggi correttamente, l'esecuzione del programma si interromperà. Visual Studio andrà al punto di interruzione e contrassegnerà la riga di codice in giallo.
Ora, se il programmatore ritiene che il codice non sia corretto, l'esecuzione può essere interrotta. Il codice può quindi essere modificato di conseguenza. Per continuare a procedere con il programma, il programmatore deve fare clic sul pulsante F5 sulla tastiera.
Cos'è la traccia in ASP.NET?
Il tracciamento dell'applicazione consente di verificare se le pagine richieste restituiscono un errore. Quando la traccia è abilitata, all'applicazione viene aggiunta una pagina aggiuntiva denominata trace.axd. (Vedi immagine sotto). Questa pagina è allegata alla domanda. In questa pagina verranno visualizzate tutte le richieste e il loro stato.
Come abilitare la traccia per un'applicazione in ASP.NET
Diamo un'occhiata a come abilitare la traccia per un file Applicazione ASP.Net:
Passo 1) Lavoriamo sulla nostra 'DemoApplication'. Aprire il file web.config da Esplora soluzioni.
Passo 2) Aggiungi la riga di codice seguente al file Web.config.
L'istruzione trace viene utilizzata per abilitare la traccia per l'applicazione.
- Viene utilizzato il "requestLimit" nell'istruzione trace. Specifica il numero di richieste di pagina che devono essere tracciate.
- Nel nostro esempio, stiamo dando un limite di 40. Diamo un limite perché un valore più alto degraderà le prestazioni dell'applicazione.
<?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>
Eseguire la "demoapplication" in Visual Studio.
Produzione:-
Se ora accedi all'URL: http://localhost:53003/trace.axd , vedrai le informazioni per ogni richiesta. Qui puoi vedere se si verificano errori in un'applicazione. I seguenti tipi di informazioni sono mostrati nella pagina soprastante
- L'ora della richiesta della pagina web.
- Il nome della pagina web richiesta.
- Il codice di stato della richiesta web. (il codice di stato 200 significa che la richiesta ha avuto successo).
- I dettagli di visualizzazione che consentono di visualizzare maggiori dettagli sulla richiesta web. Un esempio di questo è mostrato di seguito. Un'importante informazione dettagliata fornita è l'informazione dell'intestazione. Questa informazione mostra quali sono le informazioni inviate nell'intestazione di ogni richiesta web.
Traccia a livello di pagina in ASP.NET
Tracciamento a livello di pagina in ASP.Net mostra tutte le informazioni generali su una pagina web quando viene elaborata. Questo è utile nel debug se una pagina non funziona per qualsiasi motivo. Visual Studio fornisce informazioni dettagliate su vari aspetti della pagina e informazioni come l'ora per ogni metodo che viene chiamato nella richiesta web.
Ad esempio, se la tua applicazione web ha un problema di prestazioni, queste informazioni possono aiutare a risolvere il problema. Queste informazioni vengono visualizzate quando l'applicazione viene eseguita in Visual Studio.
Come abilitare la traccia a livello di pagina in ASP.NET
Diamo un'occhiata a come abilitare la traccia a livello di pagina per un'applicazione ASP.Net:
Passo 1) Lavoriamo sulla nostra DemoApplication. Aprire il file demo.aspx da Esplora soluzioni
Passo 2) Aggiungi la riga di codice seguente per abilitare il tracciamento della pagina. Nella dichiarazione Page, aggiungi semplicemente la riga Trace="true". Questa riga di codice consentirà la traccia a livello di pagina.
<%@ 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>
Eseguire l'applicazione in Visual Studio.
Produzione:-
Ora, quando viene visualizzata la pagina Web Demo.aspx, otterrai molte informazioni sulla pagina. In questa pagina vengono visualizzate informazioni come il tempo per ciascun aspetto del ciclo di vita della pagina.
Gestione degli errori: visualizzazione di una pagina di errore personalizzata
In ASP.Net, è possibile visualizzare agli utenti pagine di errore personalizzate. Se un'applicazione contiene qualsiasi tipo di errore, una pagina personalizzata visualizzerà questo errore all'utente.
Nel nostro esempio, aggiungeremo prima una pagina HTML. Questa pagina mostrerà all'utente la stringa "Stiamo esaminando il problema". Aggiungeremo quindi un codice di errore alla nostra pagina demo.aspx in modo che venga visualizzata la pagina di errore.
Seguiamo i passaggi indicati di seguito
Passo 1) Lavoriamo sulla nostra DemoApplication. Aggiungiamo una pagina HTML all'applicazione
- Fare clic con il pulsante destro del mouse sull'applicazione Demo in Esplora soluzioni
- Scegli l'opzione di menu 'Aggiungi'->Pagina HTML
Passo 2) Nel passaggio successivo, dobbiamo fornire un nome alla nuova pagina HTML.
- Fornire il nome "ErrorPage".
- Fare clic sul pulsante "OK" per procedere.
Passo 3) La Errorpage si aprirà automaticamente in Visual Studio. Se vai in Solution Explorer, vedrai il file aggiunto.
Aggiungi la riga di codice "Stiamo esaminando il problema" alla pagina HTML. Non è necessario chiudere il file HTML prima di apportare la modifica al file web.config.
<!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>
Passo 4) Ora devi apportare una modifica al file web.config. Questa modifica avviserà che ogni volta che si verifica un errore nell'applicazione, è necessario visualizzare la pagina di errore personalizzata.
Il tag "customErrors" consente di definire una pagina di errore personalizzata. La proprietà defaultRedirect è impostata sul nome della nostra pagina di errore personalizzata creata nel passaggio precedente.
<configuration> <system.web> <compilation debug="true" targetFramework="4.0" /> <httpRuntime targetFramework="4.0” /> <customErrors mode="On" defaultRedirect="ErrorPage.html"> </customErrors> </system.web> </configuration>
Passo 5) Ora aggiungiamo un po' di codice difettoso alla pagina demo.aspx.cs. Apri questa pagina facendo doppio clic sul file in Esplora soluzioni
Aggiungi il codice seguente al file Demo.aspx.cs.
- Queste righe di codice sono progettate per leggere le righe di un testo da un file.
- Il file dovrebbe trovarsi nell'unità D con il nome "Example.txt".
- Ma nella nostra situazione, questo file in realtà non esiste. Quindi questo codice genererà un errore durante l'esecuzione dell'applicazione.
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);
}
}
}
Ora esegui il codice in Di Visual Studio e dovresti ottenere l'output seguente.
Produzione:-
La pagina precedente mostra che è stato generato un errore nell'applicazione. Di conseguenza, all'utente viene visualizzata la pagina Error.html.
Eccezione non gestita ASP.NET
Anche nella migliore delle ipotesi possono verificarsi casi di errori imprevisti.
Supponiamo che un utente visiti la pagina sbagliata nell'applicazione. Questo è qualcosa che non può essere previsto. In questi casi, ASP.Net può reindirizzare l'utente a errorpage.html.
Vediamo un esempio a riguardo.
- Utilizzeremo la nostra stessa "DemoApplication" che contiene Errorpage.html.
- E proveremo a visualizzare una pagina web che non esiste nella nostra applicazione.
- In questo caso dovremmo essere reindirizzati alla nostra pagina ErrorPage.html. Vediamo i passaggi per raggiungere questo obiettivo.
Passo 1) Lavoriamo sulla nostra DemoApplication. Aprire il file Global.asax.cs da Esplora soluzioni
NOTA: il file global.asax.cs viene utilizzato per aggiungere codice che sarà applicabile a tutte le pagine dell'applicazione.
Passo 2) Aggiungi la riga di codice seguente a global.asax.cs. Queste righe verranno utilizzate per verificare la presenza di errori e visualizzare di conseguenza la pagina ErrorPage.html.
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");
}
}
}
Spiegazione del codice: -
- La prima riga è il gestore eventi Application_Error. Questo evento viene chiamato ogni volta che si verifica un errore in un'applicazione. Tieni presente che il nome dell'evento deve essere "Application_Error". E i parametri dovrebbero essere come mostrato sopra.
- Successivamente, definiamo un oggetto del tipo di classe HttpException. Questo è un oggetto standard che conterrà tutti i dettagli dell'errore. Utilizziamo quindi il metodo Server.GetLastError per ottenere tutti i dettagli dell'ultimo errore verificatosi nell'applicazione.
- Quindi controlliamo se il codice di errore dell'ultimo errore è 404. (Il codice di errore 404 è il codice standard restituito quando un utente accede a una pagina che non viene trovata). Trasferiamo quindi l'utente alla pagina ErrorPage.html se il codice di errore corrisponde.
Ora esegui il codice in Visual Studio e dovresti ottenere l'output seguente
Produzione:-
Sfoglia la pagina http://localhost:53003/Demo1.aspx . Ricorda che Demo1.aspx non esiste nella nostra applicazione. Otterrai quindi l'output seguente.
La pagina precedente mostra che è stato generato un errore nell'applicazione. Di conseguenza, all'utente viene visualizzata la pagina Error.html.
ASP.NET Registrazione degli errori
Registrando gli errori dell'applicazione, aiuta lo sviluppatore a eseguire il debug e a risolvere l'errore in un secondo momento. ASP.Net ha la possibilità di registrare gli errori. Ciò avviene nel file Global.asax.cs quando l'errore viene catturato. Durante il processo di cattura, il messaggio di errore può essere scritto in un file di registro.
Vediamo un esempio a riguardo.
- Utilizzeremo la nostra stessa DemoApplication che ha Errorpage.html.
- E proveremo a visualizzare una pagina web che non esiste nella nostra applicazione.
- In questo caso dovremmo essere reindirizzati alla nostra pagina ErrorPage.html.
- E allo stesso tempo scriveremo il messaggio di errore in un file di registro. Vediamo i passaggi per raggiungere questo obiettivo.
Passo 1) Lavoriamo sulla nostra DemoApplication. Aprire il file Global.asax.cs da Esplora soluzioni
Passo 2) Aggiungere la riga di codice sottostante a global.asax.cs. Verificherà gli errori e visualizzerà la pagina ErrorPage.html di conseguenza. Inoltre, allo stesso tempo, registreremo i dettagli dell'errore in un file chiamato 'AllErrors.txt'. Per il nostro esempio, scriveremo il codice per creare questo file sull'unità D.
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");
}
}
}
Spiegazione del codice: -
- La prima riga è ottenere l'errore stesso utilizzando il metodo "Server.GetLastError". Questo viene quindi assegnato alla variabile 'exc'.
- Creiamo quindi una variabile stringa vuota chiamata 'str'. Otteniamo il messaggio di errore effettivo utilizzando la proprietà 'exc.Message'. La proprietà exc.Message avrà il messaggio esatto per qualsiasi errore che si verifica durante l'esecuzione dell'applicazione. Questo viene quindi assegnato alla variabile stringa.
- Successivamente, definiamo il file chiamato "AllErrrors.txt". Qui è dove verranno inviati tutti i messaggi di errore. Scriviamo la stringa 'str' che contiene tutti i messaggi di errore in questo file.
- Infine, trasferiamo l'utente nel file ErrorPage.html.
Produzione:-
Sfoglia la pagina http://localhost:53003/Demo1.aspx . Ricorda che Demo1.aspx non esiste nella nostra applicazione. Otterrai quindi l'output seguente.
E allo stesso tempo, se apri il file "AllErrors.txt" vedrai le informazioni seguenti.
Il messaggio di errore può quindi essere inoltrato allo sviluppatore in un secondo momento per scopi di debug.
Sommario
- ASP.Net ha la possibilità di eseguire il debug e la gestione degli errori.
- Il debug può essere ottenuto aggiungendo punti di interruzione al codice. Si esegue quindi l'opzione Start with Debugging in Visual Studio per eseguire il debug del codice.
- La traccia è la possibilità di fornire ulteriori informazioni durante l'esecuzione dell'applicazione. Questa operazione può essere eseguita a livello di applicazione o di pagina.
- A livello di pagina, il codice Trace=true deve essere aggiunto alla direttiva della pagina.
- A livello di applicazione, viene creata una pagina aggiuntiva denominata Trace.axd per l'applicazione. Ciò fornisce tutte le informazioni di tracciabilità necessarie.
