Procedura: creare file di log
Aggiornamento: novembre 2007
È possibile creare file di log contenenti informazioni diagnostiche sull'interoperabilità, sul caricamento del programma e sulle reti. È possibile attivare la registrazione impostando le opportune chiavi del Registro di sistema. È necessario impostare innanzitutto una chiave di registro per attivare la registrazione generale, quindi le chiavi di registro per i componenti e le opzioni di registrazione desiderati.
Sono disponibili i metodi seguenti per impostare le chiavi del Registro di sistema:
Utilizzare Remote Registry Editor di Visual Studio.
In .NET Compact Framework 2.0 Service Pack 1 utilizzare le opzioni di registrazione di Remote Performance Monitor. Per ulteriori informazioni su Remote Performance Monitor, vedere Procedura: monitorare le prestazioni in fase di esecuzione.
In .NET Compact Framework 3.5 è possibile utilizzare lo strumento di registrazione NetCFLogging.exe che dispone di una semplice interfaccia grafica per l'attivazione e la disattivazione della registrazione. Questo strumento è incluso in Power Toys per .NET Compact Framework. Per ulteriori informazioni, vedere Power Toys for .NET Compact Framework (informazioni in lingua inglese).
Utilizzare le classi Registry e RegistryKey, supportate in .NET Compact Framework versione 2.0 e successive.
Nella tabella riportata di seguito sono riepilogati i file di log.
Componente di registrazione |
Contenuto del file di log |
||
|---|---|---|---|
Interop |
Consente la registrazione delle chiamate all'interoperabilità COM. Fornisce informazioni sul richiamo piattaforma e sul marshalling. |
||
Error |
Consente la registrazione di tutte le eccezioni non gestite e native. Gli errori vengono registrati in un file di log e in OutputDebugString. Il file di log viene creato per ogni assembly nel percorso corrente ed è valido per la sessione corrente. Dopo la prima occorrenza di un'eccezione non gestita o nativa, il file di log viene sovrascritto. |
||
Loader |
Consente la registrazione delle informazioni sul caricamento del programma. L'intestazione del file contiene le informazioni seguenti:
Nel file sono fornite le seguenti informazioni:
È anche possibile includere informazioni sulla Global Assembly Cache. |
||
Networking |
Consente la registrazione del traffico di rete. Il file di log relativo alle attività di rete è binario ed è possibile accedervi solo utilizzando il visualizzatore log di .NET Compact Framework, Logviewer.exe. In .NET Compact Framework 3.5 e versioni successive il visualizzatore log è incluso in Power Toys per .NET Compact Framework. Per ulteriori informazioni, vedere Power Toys for .NET Compact Framework (informazioni in lingua inglese). Poiché la registrazione delle attività di rete viene eseguita al livello di Windows Sockets, il file di log contiene solo informazioni sui pacchetti di rete, inclusi i dati inviati in rete, che possono essere riservati se non crittografi. |
||
Finalizer |
Registra il nome della classe di oggetti che non vengono eliminati prima di essere cancellati dal Garbage Collector. Questo log è supportato in .NET Compact Framework 3.5 e versioni successive. I nomi degli oggetti non sono inclusi nel log perché non sono disponibili a Common Language Runtime (CLR). Tuttavia, i nomi di classe per gli oggetti non eliminati possono facilitarne l'identificazione. Gli oggetti non eliminati possono creare problemi di prestazioni nelle applicazioni.
In questo file sono incluse le seguenti informazioni:
|
||
Trace |
Registra le eccezioni del codice per Windows Communication Foundation (WCF). Sul desktop, .NET Framework supporta tre tipi di registrazione: la registrazione dell'analisi, la registrazione dei messaggi e la registrazione degli eventi. WCF per .NET Compact Framework supporta unicamente la registrazione dell'analisi per tenere traccia delle eccezioni del codice. Non è prevista alcuna registrazione di messaggi di avviso o di errore. Questo log è supportato in .NET Compact Framework 3.5 e versioni successive. |
.gif "Nota")
Nota:Per impostazione predefinita, i file di log vengono scritti nella stessa directory dell'applicazione che viene esaminata. È tuttavia possibile specificare un percorso e altre opzioni mediante le chiavi del Registro di sistema, come descritto di seguito:
Utilizzo di un percorso alternativo per la scrittura dei file di log. Per effettuare questa operazione è necessario disporre di accesso privilegiato al Registro di sistema sicuro.
Inclusione del nome dell'applicazione nel nome del file di log.
Inclusione dell'ID processo nel nome del file di log.
Un nome di file di log è composto dalle parti indicate di seguito, dove componente può essere "Interop", "Error", "Loader", "Network", "Finalizer" o "Trace":
netcf_nome-applicazione_componente_ID processo.log
Il nome dell'applicazione e l'ID processo sono facoltativi e si basano sulle impostazioni del Registro di sistema.
Un file di log del caricatore per un'applicazione denominata MyApp.exe può ad esempio essere denominato come segue:
netcf_MyApp_Loader_2066923010.log
Per informazioni su come esaminare i file di log, quali Interop e Loader, vedere Informazioni sui file di log.
Per attivare la registrazione
Impostare su 1 il valore della chiave Enabled seguente:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\Enabled
Il valore di questa chiave deve essere impostato in modo da attivare i sei tipi di registrazione: Interop, Loader, Error, Networking, Finalizer e Trace. Per impostazione predefinita, la chiave Logging non contiene sottochiavi.
È possibile disattivare tutti i tipi di registrazione impostando questo valore su 0 (zero).
Per specificare un percorso per il file di log (facoltativo)
Impostare il valore della chiave Path seguente su una stringa che rappresenta il percorso dei file di log:
HKLM\Security\.NETCompactFramework\Diagnostics\Logging\Path
A tale chiave possono accedere solo le applicazioni cui è consentita la scrittura nel Registro di sistema sicuro. Se non viene specificato alcun percorso, il file di log viene scritto nella stessa directory dell'applicazione.
Per includere il nome dell'applicazione nel nome (facoltativo)
Impostare su 1 il valore della chiave UseApp seguente:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\UseApp
Tale chiave risulta utile quando si desidera eseguire più applicazioni e ottenere file di log distinti per ogni applicazione. Se due applicazioni scrivono i file di log nella stessa directory, quando la seconda applicazione viene eseguita il file di log precedente verrà sempre sovrascritto da quello più recente. La chiave UseApp può essere utilizzata come elemento differenziatore per il file di log.
Per includere l'ID processo nel nome (facoltativo)
Impostare su 1 il valore della chiave UsePid seguente:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\UsePid
Tale chiave risulta utile quando si desidera eseguire un'applicazione più volte e creare file di log distinti per ogni istanza. Questa impostazione consente di aggiungere l'ID processo al nome del file di log in modo che ogni istanza dell'applicazione crei un nuovo file di log con un nome differente.
Per registrare gli eventi secondo l'ordine di generazione (facoltativo)
Impostare su 1 il valore della chiave Flush seguente:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\Flush
Se si imposta questo valore, in Common Language Runtime (CLR) gli eventi di log vengono scritti nel file di log man mano che si verificano, anziché essere conservati nel buffer per poi essere scritti quando il buffer è pieno. Questa impostazione influisce negativamente sulle prestazione dell'applicazione e potrebbe modificare leggermente la temporizzazione dell'applicazione. Può tuttavia essere utile per diagnosticare i problemi relativi agli errori dell'applicazione o ad altri errori per i quali può essere utile visualizzare gli ultimi eventi che hanno restituito un errore. Se la chiave non è presente o non è impostata, i dati non verranno scritti nei file di log finché il buffer non sarà pieno.
Registrazione Interop
Per attivare la registrazione Interop
Impostare su 1 il valore della chiave Enabled seguente:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\Interop\Enabled
Registrazione degli errori
Per attivare la registrazione degli errori
Impostare su 1 il valore della chiave Enabled seguente:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\Error\Enabled
Registrazione Loader
Per attivare la registrazione Loader
Impostare su 1 il valore della chiave Enabled seguente per attivare la registrazione per il caricatore o impostarla su 2 per attivare la registrazione per il caricatore e la Global Assembly Cache:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\Loader\Enabled
Registrazione Networking
Per attivare la registrazione Networking
Impostare su 1 il valore della chiave Enabled seguente:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\Networking\Enabled
Il file di log Networking è binario e può essere letto solo utilizzando il visualizzatore di log Logviewer.exe di .NET Compact Framework che consente di convertire il log dal formato binario in un formato leggibile. In .NET Compact Framework 3.5 e versioni successive il visualizzatore log è incluso in Power Toys per .NET Compact Framework. Per scaricare questo strumento, visitare la pagina .NET Compact Framework Downloads (informazioni in lingua inglese).
Registrazione Finalizer
Per attivare la registrazione relativa al finalizzatore
Impostare su 1 il valore della chiave Enabled seguente:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\Finalizer\Enabled
Registrazione Trace
Per attivare la registrazione dell'analisi WCF
Impostare su 1 il valore della chiave Enabled seguente:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\WCF\Enabled
Esempio
Per impostare i valori delle chiavi del Registro di sistema è possibile utilizzare Remote Registry Editor o in alternativa scrivere un'applicazione che imposterà tali valori. Nell'esempio riportato in questa sezione sono contenuti i metodi seguenti per la gestione delle attività del Registro di sistema necessarie:
Il metodo EnableLogging consente di attivare la registrazione generale e contiene parametri utilizzabili per specificare un percorso alternativo per il file di log, per specificare se il nome dell'applicazione e l'ID processo verranno aggiunti al nome del file di log nonché per specificare se gli eventi verranno registrati man mano che si verificano.
I metodi SetInteropLogging, SetLoaderLogging e SetNetworkLogging consentono di impostare il valore della chiave Enabled corrispondente su 1 in modo da attivare la registrazione per tale componente.
Il metodo DisableLogging disattiva tutti i tipi di registrazione.
Il metodo WriteLoggingSettings esamina in modo ricorsivo le chiavi contenute nella sottochiave Logging e scrive i relativi nomi e valori in un file di log. Il file di log è denominato logsettings.txt e si trova nella directory contenente questa applicazione di esempio.
' This method enables general logging. It contains parameters
' to specify a path, and Boolean values of true to include
' the application name, process ID, and events in the log.
Private Sub EnableLogging(ByVal useApp As Boolean, ByVal usePid As Boolean, ByVal useFlush As Boolean)
' Specify values for setting the registry.
Dim userRoot As String = "HKEY_LOCAL_MACHINE"
Dim subkey As String = "SOFTWARE\Microsoft\.NETCompactFramework\Diagnostics\Logging"
Dim keyName As String = userRoot + "\" + subkey
' Set the Enabled registry value.
Registry.SetValue(keyName, "Enabled", 1)
If useApp = True Then
Registry.SetValue(keyName, "UseApp", 1)
Else
Registry.SetValue(keyName, "UseApp", 0)
End If
If usePid = True Then
Registry.SetValue(keyName, "UsePid", 1)
Else
Registry.SetValue(keyName, "UsePid", 0)
End If
If useFlush = True Then
Registry.SetValue(keyName, "UseFlush", 1)
Else
Registry.SetValue(keyName, "UseFlush", 0)
End If
End Sub
' This method sets the Enabled key value to 1
' so that logging for Interoperability is enabled.
Private Sub SetInteropLogging(ByVal logOn As Boolean)
' Specify values for setting the registry.
Dim userRoot As String = "HKEY_LOCAL_MACHINE"
Dim subkey As String = "Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\Interop"
Dim keyName As String = userRoot + "\" + subkey
Dim logSet As Integer
If logOn = True Then
logSet = 1
Else
logSet = 0
End If
' Set the registry value.
Try
Registry.SetValue(keyName, "Enabled", logSet)
If logOn = True Then
MessageBox.Show("Interop Logging On")
Else
MessageBox.Show("Interop Logging Off")
End If
Catch ex As System.Exception
MessageBox.Show(ex.Message)
End Try
End Sub
' This method sets the Enabled key value to 1
' so that logging for class loading is enabled.
Private Sub SetLoaderLogging(ByVal logOn As Boolean)
' Specify values for setting the registry.
Dim userRoot As String = "HKEY_LOCAL_MACHINE"
Dim subkey As String = "Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\Loader"
Dim keyName As String = userRoot + "\" + subkey
Dim logSet As Integer
If logOn = True Then
logSet = 1
Else
logSet = 0
End If
' Set the registry value.
Try
Registry.SetValue(keyName, "Enabled", logSet)
If logOn = True Then
MessageBox.Show("Loader Logging On")
Else
MessageBox.Show("Loader Loggin Off")
End If
Catch ex As System.Exception
MessageBox.Show(ex.Message)
End Try
End Sub
' This method sets the Enabled key value to 1,
' so that logging for networking is enabled.
Private Sub SetNetworkLogging(ByVal logOn As Boolean)
' Specify values for setting the registry.
Dim userRoot As String = "HKEY_LOCAL_MACHINE"
Dim subkey As String = "Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\Networking"
Dim keyName As String = userRoot + "\" + subkey
Dim logSet As Integer
If logOn = True Then
logSet = 1
Else
logSet = 0
End If
' Set the registry value.
Try
Registry.SetValue(keyName, "Enabled", logSet)
If logOn = True Then
MessageBox.Show("Networking Logging On")
Else
MessageBox.Show("Networking Logging Off")
End If
Catch ex As System.Exception
MessageBox.Show(ex.Message)
End Try
End Sub
' This method disables all logging.
Private Sub DisableLogging()
' Specify values for setting the registry.
Dim userRoot As String = "HKEY_LOCAL_MACHINE"
Dim subkey As String = "SOFTWARE\Microsoft\.NETCompactFramework\Diagnostics\Logging"
Dim keyName As String = userRoot + "\" + subkey
' Set the Enabled registry value.
Registry.SetValue(keyName, "Enabled", 0)
MessageBox.Show("Logging Disabled")
End Sub
' This method recursively examines the keys
' under the Logging subkey and writes their
' key names and values to a log file. It saves
' the information in "logsettings.txt", located
' in the directory that contains this example
' application.
Private Sub WriteLoggingSettings()
Dim sw As New StreamWriter("logsettings.txt", False)
sw.WriteLine("General Logging Settings:")
Dim rkLogging As RegistryKey = Registry.LocalMachine.OpenSubKey("SOFTWARE\Microsoft\.NETCompactFramework\Diagnostics\Logging")
Dim valNames As String() = rkLogging.GetValueNames()
Dim x As Integer
For x = 0 To valNames.Length
sw.WriteLine(valNames(x).ToString() + ": " + rkLogging.GetValue(valNames(x)).ToString())
Next x
sw.WriteLine()
sw.WriteLine("Interop Logging:")
Dim rkInterop As RegistryKey = Registry.LocalMachine.OpenSubKey("SOFTWARE\Microsoft\.NETCompactFramework\Diagnostics\Logging\Interop")
Dim interopNames As String() = rkInterop.GetValueNames()
For x = 0 To interopNames.Length
sw.WriteLine(interopNames(x).ToString() + ": " + rkInterop.GetValue(interopNames(x)).ToString())
Next x
sw.WriteLine()
sw.WriteLine("Loader Logging:")
Dim rkLoader As RegistryKey = Registry.LocalMachine.OpenSubKey("SOFTWARE\Microsoft\.NETCompactFramework\Diagnostics\Logging\Loader")
Dim loaderNames As String() = rkLoader.GetValueNames()
For x = 0 To loaderNames.Length
sw.WriteLine(loaderNames(x).ToString() + ": " + rkLoader.GetValue(loaderNames(x)).ToString())
Next x
sw.WriteLine()
sw.WriteLine("Networking Logging:")
Dim rkNetworking As RegistryKey = Registry.LocalMachine.OpenSubKey("SOFTWARE\Microsoft\.NETCompactFramework\Diagnostics\Logging\Networking")
Dim netNames As String() = rkNetworking.GetValueNames()
For x = 0 To netNames.Length
sw.WriteLine(netNames(x).ToString() + ": " + rkNetworking.GetValue(netNames(x)).ToString())
Next x
sw.Close()
End Sub
// This method enables general logging. It contains parameters
// to specify a path, and Boolean values of true to include
// the application name, process ID, and events in the log.
private void EnableLogging(bool useApp, bool usePid, bool useFlush)
{
// Specify values for setting the registry.
string userRoot = "HKEY_LOCAL_MACHINE";
string subkey = "SOFTWARE\\Microsoft\\.NETCompactFramework\\Diagnostics\\Logging";
string keyName = userRoot + "\\" + subkey;
// Set the Enabled registry value.
Registry.SetValue(keyName, "Enabled", 1);
if (useApp == true)
Registry.SetValue(keyName, "UseApp", 1);
else
Registry.SetValue(keyName, "UseApp", 0);
if (usePid == true)
Registry.SetValue(keyName, "UsePid", 1);
else
Registry.SetValue(keyName, "UsePid", 0);
if (useFlush == true)
Registry.SetValue(keyName, "UseFlush", 1);
else
Registry.SetValue(keyName, "UseFlush", 0);
}
// This method sets the Enabled key value to 1
// so that logging for Interoperability is enabled.
private void SetInteropLogging(bool logOn)
{
// Specify values for setting the registry.
string userRoot = "HKEY_LOCAL_MACHINE";
string subkey = "Software\\Microsoft\\.NETCompactFramework\\Diagnostics\\Logging\\Interop";
string keyName = userRoot + "\\" + subkey;
int logSet;
if(logOn == true)
logSet = 1;
else
logSet = 0;
// Set the registry value.
try
{
Registry.SetValue(keyName, "Enabled", logSet);
if(logOn == true)
MessageBox.Show("Interop Logging On");
else
MessageBox.Show("Interop Logging Off");
}
catch(System.Exception ex)
{
MessageBox.Show(ex.Message);
}
}
// This method sets the Enabled key value to 1
// so that logging for class loading is enabled.
private void SetLoaderLogging(bool logOn)
{
// Specify values for setting the registry.
string userRoot = "HKEY_LOCAL_MACHINE";
string subkey = "Software\\Microsoft\\.NETCompactFramework\\Diagnostics\\Logging\\Loader";
string keyName = userRoot + "\\" + subkey;
int logSet;
if(logOn == true)
logSet = 1;
else
logSet = 0;
// Set the registry value.
try
{
Registry.SetValue(keyName, "Enabled", logSet);
if(logOn == true)
MessageBox.Show("Loader Logging On");
else
MessageBox.Show("Loader Logging Off");
}
catch(System.Exception ex)
{
MessageBox.Show(ex.Message);
}
}
// This method sets the Enabled key value to 1
// so that logging for networking is enabled.
private void SetNetworkLogging(bool logOn)
{
// Specify values for setting the registry.
string userRoot = "HKEY_LOCAL_MACHINE";
string subkey = "Software\\Microsoft\\.NETCompactFramework\\Diagnostics\\Logging\\Networking";
string keyName = userRoot + "\\" + subkey;
int logSet;
if(logOn == true)
logSet = 1;
else
logSet = 0;
// Set the registry value.
try
{
Registry.SetValue(keyName, "Enabled", logSet);
if(logOn == true)
MessageBox.Show("Networking Logging On");
else
MessageBox.Show("Networking Loggin Off");
}
catch(System.Exception ex)
{
MessageBox.Show(ex.Message);
}
}
// This method disables all logging.
private void DisableLogging()
{
// Specify values for setting the registry.
string userRoot = "HKEY_LOCAL_MACHINE";
string subkey = "SOFTWARE\\Microsoft\\.NETCompactFramework\\Diagnostics\\Logging";
string keyName = userRoot + "\\" + subkey;
// Set the Enabled registry value.
Registry.SetValue(keyName, "Enabled", 0);
MessageBox.Show("Logging Disabled");
}
// This method recursively examines the keys
// under the Logging subkey and writes their
// key names and values to a log file. It saves
// the information in "logsettings.txt" located
// in the directory that contains this
// example application.
private void WriteLoggingSettings()
{
StreamWriter sw = new StreamWriter("logsettings.txt",false);
sw.WriteLine("General Logging Settings:");
RegistryKey rkLogging = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Microsoft\\.NETCompactFramework\\Diagnostics\\Logging");
string[] valNames = rkLogging.GetValueNames();
for (int x = 0; x < valNames.Length; x++)
{
sw.WriteLine(valNames[x].ToString() + ": " + rkLogging.GetValue(valNames[x]).ToString());
}
sw.WriteLine();
sw.WriteLine("Interop Logging:");
RegistryKey rkInterop = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Microsoft\\.NETCompactFramework\\Diagnostics\\Logging\\Interop");
string[] interopNames = rkInterop.GetValueNames();
for (int x = 0; x < interopNames.Length; x++)
{
sw.WriteLine(interopNames[x].ToString() + ": " + rkInterop.GetValue(interopNames[x]).ToString());
}
sw.WriteLine();
sw.WriteLine("Loader Logging:");
RegistryKey rkLoader = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Microsoft\\.NETCompactFramework\\Diagnostics\\Logging\\Loader");
string[] loaderNames = rkLoader.GetValueNames();
for (int x = 0; x < loaderNames.Length; x++)
{
sw.WriteLine(loaderNames[x].ToString() + ": " + rkLoader.GetValue(loaderNames[x]).ToString());
}
sw.WriteLine();
sw.WriteLine("Networking Logging:");
RegistryKey rkNetworking = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Microsoft\\.NETCompactFramework\\Diagnostics\\Logging\\Networking");
string[] netNames = rkNetworking.GetValueNames();
for (int x = 0; x < netNames.Length; x++)
{
sw.WriteLine(netNames[x].ToString() + ": " + rkNetworking.GetValue(netNames[x]).ToString());
}
sw.Close();
}
Compilazione del codice
In questo esempio sono richiesti riferimenti ai seguenti spazi dei nomi: