Tracciamento e strumentazione delle applicazioni

2025-06-17

Annotazioni

Questo articolo è specifico di .NET Framework. Non si applica alle implementazioni più recenti di .NET, incluse .NET 6 e versioni successive.

Monitorare è un modo per tracciare l'esecuzione dell'applicazione mentre è in funzione. È possibile aggiungere la strumentazione di traccia e debug all'applicazione .NET Framework durante lo sviluppo e usare tale strumentazione sia durante lo sviluppo dell'applicazione che dopo averla distribuita. È possibile usare le System.Diagnostics.Traceclassi , System.Diagnostics.Debuge System.Diagnostics.TraceSource per registrare informazioni sugli errori e l'esecuzione dell'applicazione nei log, nei file di testo o in altri dispositivi per un'analisi successiva.

Il termine strumentazione si riferisce a una capacità di monitorare o misurare il livello delle prestazioni di un prodotto e di diagnosticare gli errori. Nella programmazione, ciò significa la capacità di un'applicazione di incorporare:

Traccia del codice : ricezione di messaggi informativi sull'esecuzione di un'applicazione in fase di esecuzione.
Debug : rilevamento e correzione degli errori di programmazione in un'applicazione in fase di sviluppo. Per altre informazioni, vedere Debug.
Contatori delle prestazioni : componenti che consentono di tenere traccia delle prestazioni dell'applicazione. Per altre informazioni, vedere i contatori delle prestazioni.
Log eventi : componenti che consentono di ricevere e tenere traccia degli eventi principali nell'esecuzione dell'applicazione. Per altre informazioni, vedere la classe EventLog.

Instrumentare l'applicazione inserendo istruzioni di traccia in posizioni strategiche nel codice è particolarmente utile per le applicazioni distribuite. Usando istruzioni di traccia è possibile instrumentare un'applicazione non solo per visualizzare informazioni quando si verificano problemi, ma anche per monitorare le prestazioni dell'applicazione.

La TraceSource classe fornisce funzionalità di traccia avanzate e può essere usata al posto dei metodi statici delle classi precedenti Trace e Debug di traccia. Le classi familiari Trace e Debug sono ancora ampiamente usate, ma è consigliata la classe TraceSource per i nuovi comandi di traccia, ad esempio TraceEvent e TraceData.

Le Trace classi e Debug sono identiche, ad eccezione del fatto che le procedure e le funzioni della Trace classe vengono compilate per impostazione predefinita nelle build di rilascio, ma quelle della Debug classe non sono.

Le Trace classi e Debug forniscono i mezzi per monitorare ed esaminare le prestazioni dell'applicazione durante lo sviluppo o dopo la distribuzione. Ad esempio, è possibile usare la Trace classe per tenere traccia di determinati tipi di azioni in un'applicazione distribuita man mano che si verificano (ad esempio, la creazione di nuove connessioni di database) e quindi monitorare l'efficienza dell'applicazione.

Traccia e debug del codice

Durante lo sviluppo, è possibile usare i metodi di output della Debug classe per visualizzare i messaggi nella finestra Output dell'ambiente di sviluppo integrato (IDE) di Visual Studio. Per esempio:

Trace.WriteLine("Hello World!")
Debug.WriteLine("Hello World!")

System.Diagnostics.Trace.WriteLine("Hello World!");
System.Diagnostics.Debug.WriteLine("Hello World!");

Ognuno di questi esempi visualizzerà "Hello World!" nella finestra Output quando l'applicazione viene eseguita nel debugger.

In questo modo è possibile eseguire il debug delle applicazioni e ottimizzarne le prestazioni in base al comportamento nell'ambiente di test. È possibile eseguire il debug dell'applicazione nella compilazione di debug con l'attributo condizionale attivato, in modo da ricevere tutto l'output di debug Debug. Quando l'applicazione è pronta per il rilascio, è possibile compilare la build di versione senza attivare l'attributo Debug condizionale, in modo che il compilatore non includa il codice di debug nell'eseguibile finale. Per ulteriori informazioni, vedere Procedura: Compilare in modo condizionale con Trace e Debug. Per altre informazioni sulle diverse configurazioni di compilazione per la tua applicazione, vedere Compilazione e Creazione.

È anche possibile tracciare l'esecuzione del codice in un'applicazione installata usando i metodi della Trace classe . Inserendo interruttori di traccia nel codice, è possibile controllare se la traccia viene eseguita e quanto è estesa. In questo modo è possibile monitorare lo stato dell'applicazione in un ambiente di produzione. Ciò è particolarmente importante in un'applicazione aziendale che usa più componenti in esecuzione in più computer. È possibile controllare come vengono usati gli interruttori dopo la distribuzione tramite il file di configurazione. Per ulteriori informazioni, vedere Come: Creare, inizializzare e configurare gli interruttori di traccia.

Quando si sviluppa un'applicazione per cui si intende usare la traccia, in genere si includono sia messaggi di traccia che di debug nel codice dell'applicazione. Quando si è pronti per distribuire l'applicazione, è possibile compilare la build di versione senza attivare l'attributo condizionale Debug . Tuttavia, è possibile attivare l'attributo condizionale Trace in modo che il compilatore includa il codice di traccia nell'eseguibile. Per ulteriori informazioni, vedere Procedura: Compilare in modo condizionale con Trace e Debug.

Fasi della traccia del codice

Esistono tre fasi di traccia del codice:

Strumentazione : si aggiunge il codice di traccia all'applicazione.
Traccia : il codice di traccia scrive informazioni nella destinazione specificata.
Analisi : si valutano le informazioni di traccia per identificare e comprendere i problemi nell'applicazione.

Durante lo sviluppo, tutti i metodi di output di debug e traccia scrivono informazioni nella finestra Output in Visual Studio per impostazione predefinita. In un'applicazione distribuita i metodi scrivono informazioni di traccia nelle destinazioni specificate. Per ulteriori informazioni sulla specificazione di una destinazione di output per il tracciamento o il debug, vedere Listener di tracciamento.

Di seguito è riportata una panoramica generale dei passaggi principali in genere coinvolti nell'uso della traccia per analizzare e correggere potenziali problemi nelle applicazioni distribuite. Per altre informazioni su come eseguire questi passaggi, vedere il collegamento appropriato.

Per utilizzare il tracciamento in un'applicazione

Prendere in considerazione l'output di traccia che si vuole ricevere in loco dopo aver distribuito l'applicazione.
Creare un set di interruttori. Per ulteriori informazioni, vedere Come: Configurare i Trace Switches.
Aggiungere le istruzioni di traccia al codice dell'applicazione.
Stabilire dove visualizzare l'output di tracciamento e aggiungere i listener appropriati. Per altre informazioni, vedere La creazione e l'inizializzazione dei listener di traccia.
Testare ed eseguire il debug dell'applicazione e il codice di traccia che contiene.
Compilare l'applicazione in codice eseguibile usando una delle procedure seguenti:
- Usare il menu Compila insieme alla pagina Debug della finestra di dialogo Pagine delle proprietà in Esplora soluzioni. Usare questa opzione durante la compilazione in Visual Studio.
  
  - o -
- Usare le direttive del compilatore Trace e Debug per il metodo della riga di comando di compilazione. Per altre informazioni, vedere Compilazione condizionale con traccia e debug. Usare questa opzione durante la compilazione dalla riga di comando.
Se si verifica un problema durante l'esecuzione, attivare l'opzione di traccia appropriata. Per ulteriori informazioni, vedere Configurazione degli interruttori di traccia.

Il codice di traccia scrive messaggi di traccia in una destinazione specificata, ad esempio una schermata, un file di testo o un registro eventi. Il tipo di listener che hai incluso nella raccolta Trace.Listeners determina l'obiettivo.
Analizzare i messaggi di traccia per identificare e comprendere il problema nell'applicazione.

Strumentazione traccia e applicazioni distribuite

Quando si crea un'applicazione distribuita, potrebbe risultare difficile testare l'applicazione nel modo in cui verrà usato. Pochi team di sviluppo hanno la possibilità di testare tutte le possibili combinazioni di sistemi operativi o Web browser (incluse tutte le opzioni del linguaggio localizzato) o di simulare il numero elevato di utenti che accederanno all'applicazione contemporaneamente. In queste circostanze, non è possibile testare il modo in cui un'applicazione distribuita risponderà a volumi elevati, configurazioni diverse e comportamenti univoci dell'utente finale. Inoltre, molte parti di un'applicazione distribuita non hanno un'interfaccia utente con cui è possibile interagire direttamente o visualizzare l'attività di tali parti.

Tuttavia, è possibile compensare questo problema consentendo alle applicazioni distribuite di descrivere determinati eventi di interesse per gli amministratori di sistema, in particolare le cose che vanno storte, instrumentando l'applicazione, ovvero inserendo istruzioni di traccia in posizioni strategiche nel codice. Quindi, se si verifica qualcosa di imprevisto in fase di esecuzione (ad esempio, tempo di risposta eccessivamente lento), è possibile determinare la causa probabile.

Con le istruzioni di traccia è possibile evitare l'attività difficile di esaminare il codice sorgente originale, modificarlo, ricompilare e tentare di generare l'errore di runtime all'interno dell'ambiente di debug. Tenere presente che è possibile instrumentare un'applicazione non solo per visualizzare gli errori, ma anche per monitorare le prestazioni.

Posizionamento strategico delle dichiarazioni di traccia

È necessario prestare particolare attenzione quando si inseriscono le istruzioni di traccia da usare durante l'esecuzione. È necessario considerare quali informazioni di traccia sono probabilmente necessarie in un'applicazione distribuita, in modo che tutti gli scenari di traccia probabili siano adeguatamente trattati. Poiché le applicazioni che usano la traccia variano notevolmente, tuttavia, non esistono linee guida generali per il posizionamento strategico della traccia. Per altre informazioni sull'inserimento di istruzioni di traccia, vedere Procedura: Aggiungere istruzioni di traccia al codice dell'applicazione.

Output di tracciamento

L'output di traccia viene raccolto da oggetti denominati listener. Un listener è un oggetto che riceve la traccia di output e la scrive in un dispositivo di output (in genere una finestra, un log o un file di testo). Quando viene creato un ascoltatore di tracce, viene in genere aggiunto alla collezione Trace.Listeners, consentendo all'ascoltatore di ricevere tutto l'output di traccia.

Le informazioni di traccia vengono sempre scritte almeno nella destinazione di output predefinita Trace, il DefaultTraceListener. Se per qualche motivo hai eliminato DefaultTraceListener senza aggiungere altri listener alla raccolta Listeners, non riceverai messaggi di monitoraggio. Per altre informazioni, vedere Listener di tracce.

I sei Debug membri e Trace i metodi che scrivono informazioni di traccia sono elencati nella tabella seguente.

Metodo	Risultato
`Assert`	Testo specificato; oppure, se non viene specificato, lo stack di chiamate. L'output viene scritto solo se la condizione specificata come argomento nell'istruzione `Assert` è false.
`Fail`	Testo specificato; oppure, se non viene specificato, lo stack di chiamate.
`Write`	Testo specificato.
`WriteIf`	Testo specificato, se la condizione specificata come argomento nell'istruzione `WriteIf` viene soddisfatta.
`WriteLine`	Testo specificato e ritorno a capo.
`WriteLineIf`	Testo specificato e ritorno a capo, se la condizione specificata come argomento nell'istruzione `WriteLineIf` viene soddisfatta.

Tutti i listener nella Listeners raccolta ricevono i messaggi descritti nella tabella precedente, ma le azioni eseguite possono variare a seconda del tipo di listener che riceve il messaggio. Ad esempio, DefaultTraceListener visualizza una finestra di dialogo di asserzione quando riceve una Fail o una notifica Assert non riuscita, mentre invece TextWriterTraceListener scrive semplicemente l'output nel suo flusso.

È possibile produrre risultati personalizzati implementando il proprio listener. Un listener di traccia personalizzato potrebbe, ad esempio, visualizzare i messaggi in una finestra di messaggio o connettersi a un database per aggiungere messaggi a una tabella. Tutti i listener personalizzati devono supportare i sei metodi indicati in precedenza. Per altre informazioni sulla creazione di listener definiti dallo sviluppatore, vedere TraceListener nella guida di riferimento del .NET Framework.

I Write metodi e WriteLine scrivono sempre il testo specificato. Assert, WriteIfe WriteLineIf richiedono un argomento booleano che controlla se scrivono o meno il testo specificato; scrivono il testo specificato solo se l'espressione è true (per WriteIf e WriteLineIf) o false (per Assert). Il Fail metodo scrive sempre il testo specificato. Per altre informazioni, vedere Procedura: Aggiungere istruzioni di traccia al codice dell'applicazione e informazioni di riferimento su .NET Framework.

Problemi di sicurezza

Se non si disabilita la traccia e il debug prima di distribuire un'applicazione ASP.NET, l'applicazione potrebbe rivelare informazioni su se stesso che potrebbero essere sfruttate da un programma dannoso. Per altre informazioni, vedere Procedura: Compilare in modo condizionale con Traccia e Debug, Compilazione e Costruzione e Procedura: Creare, inizializzare e configurare interruttori di traccia. Il debug è configurabile anche tramite Internet Information Services (IIS).

Condividi tramite