Como: Criar arquivos de log
Você pode criar arquivos de log que contêm informações de diagnóstico sobre interoperabilidade, carregar o programa e de rede.Você pode ativar o log, definindo as chaves do Registro.Primeiro, defina uma chave de Registro para ativar o log geral, e então defina as chaves do Registro para o componente de log e as opções desejadas.
Você pode usar os seguintes métodos para conjunto chaves do registro:
Use o Editor do Registro remoto em Visual Studio.
No .NET Compact Framework 2,0 serviço empacotar 1, use as opções de registrar registrar registrar em log no desempenho remoto monitor. Para obter mais informações sobre desempenho do sistema remoto, consulte Como: monitor Desempenho em time de execução.
No .NET Compact Framework 3,5, você pode usar a ferramenta de registro em registrar registrar registrar em log, NetCFLogging.exe, que fornece uma interface gráfica do usuário simples para habilitar e desabilitar o registrar registrar registrar em log. Essa ferramenta está incluída no potência Toys para o .NET Compact Framework. Para obter mais informações, consulte potência Toys para o .NET Compact estrutura.
Use o Registry e RegistryKey classes, que são compatíveis com o .NET Compact Framework versão 2,0 e versões posteriores.
A tabela a seguir resume os arquivos de log.
Componente de Log |
Conteúdo do arquivo de log |
|---|---|
Interoperabilidade |
Registra chamadas interop COM.Fornece informações sobre chamadas de invocação de plataforma e empacotamento. |
Erro |
Logs tudo sem tratamento e nativo exceções.Os erros são registrados para um arquivo de log e OutputDebugString. O arquivo de log é criado para cada assembly no caminho corrente e aplica-se à sessão corrente.Após a primeira ocorrência de uma exceção não tratada ou nativa, o arquivo de log é sobrescrito. |
Carregador |
Registra informações sobre como carregar o programa.O cabeçalho do arquivo contém as seguintes informações:
O arquivo fornece as seguintes informações:
Você também pode incluir informações sobre o cache global de assemblies. |
Rede |
Logs de tráfego de rede.O arquivo de log de rede é binário e não pode ser acessado sem o .NET Compact Framework Visualizador de log, logviewer.exe. No .NET Compact Framework 3,5 e mais tarde, o Visualizador de log está incluído no potência Toys para o .NET Compact Framework. Para obter mais informações, consulte potência Toys para o .NET Compact estrutura. Como o registrar registrar registrar em log de rede ocorre na camada de soquetes de segurança do Windows, o arquivo de registrar registrar registrar em log contém somente informações de pacote de rede.Isso inclui os dados enviados pela rede, que pode ser dados confidenciais se não estiverem criptografado. |
Finalizador |
Registra o nome de classe de objetos que não são eliminados antes que eles são descartados pelo coletor de lixo.Esse log é suportado no .NET Compact Framework 3,5 e versões posteriores. Os nomes de objeto não estão incluídos no log de como os nomes não estão disponível para o common linguagem tempo de execução (CLR).No entanto, os nomes de classes para objetos undisposed podem ajudar a identificar esses objetos.Objetos undisposed podem criar problemas de desempenho em aplicativos. .gif "Observação") Observação:
Em alguns casos, o .NET Compact Framework em vez do aplicativo o código chamará o finalizador.
Este arquivo inclui as seguintes informações:
|
Rastreamento |
O código de logs de exceções para o Windows Communication Foundation (WCF).Na área de trabalho, .NET Framework oferece suporte a três tipos de registrar registrar registrar em log: rastreamento, sistema de sistema sistema de mensagens e registrar registrar registrar em log de eventos.WCF a .NET Compact Framework suporta somente rastrear registrar registrar registrar em log para rastrear código exceções, mas não registra mensagens de aviso e erro. Esse log é suportado no .NET Compact Framework 3,5 e versões posteriores. |
Por padrão, os arquivos de log são gravados para o diretório que contém o aplicativo está sendo diagnosticado.No entanto, você pode especificar um caminho e outras opções com chaves do registro da seguinte maneira:
Use um caminho alternativo para gravar os arquivos de log.Isso requer privilégios acesso para o Registro seguro.
Inclua o nome do aplicativo no nome do arquivo de log.
Inclua o processo de identificação no nome do arquivo de log.
Um nome de arquivo de log possui as seguintes partes, em que componente pode ser "Interoperabilidade", "erro", "Loader", "Rede", "finalizador" ou "Rastrear":
netcf_ nome do aplicativo_componente_Identificação_do_processo.log
O aplicativo, nome e ID do processo são opcionais e baseados em configurações do registro.
Por exemplo, um arquivo de log de carregador para um aplicativo chamado MyApp.exe pode ser nomeado sistema autônomo segue:
netcf_MyApp_Loader_2066923010.log
Para obter informações sobre sistema autônomo examinar arquivos de log sistema autônomo a interoperabilidade e o arquivo de log loader, consulte Informações de arquivo de log.
Para ativar o log
conjunto seguintes habilitado valor de chave para 1:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnóstico\registrar registrar registrar em log\Enabled
Esse valor de chave deve ser definido como ativar os seis tipos de registrar registrar registrar em log: a interoperabilidade, carregador, erro, redes, finalizador e rastreamento.Observe que as subchaves de registro não existem por padrão.
Você pode desativar todos registrar registrar registrar em log definindo este valor como 0 (zero).
Para especificar um caminho para o arquivo de log (opcional)
conjunto o seguinte valor de chave de caminho como uma seqüência de caracteres que representa o local para os arquivos de log:
HKLM\segurança\.NETCompactFramework\Diagnóstico\registrar registrar registrar em log\caminho
Essa chave pode ser acessada somente por aplicativos que podem gravar o registro seguro.Se um caminho não for especificado, o arquivo de log é gravado no diretório que contém o aplicativo.
Para incluir o aplicativo no nome (opcional)
conjunto o seguinte valor de chave UseApp para 1:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnóstico\registrar registrar registrar em log\UseApp
Essa chave é útil se você quiser executar vários aplicativos e obter arquivos de log separados para cada aplicativo.Se os dois aplicativos gravam arquivos de log no mesmo diretório, o arquivo de log mais antigo sempre será substituído pelo arquivo de log mais recente quando o segundo aplicativo é executado.A chave UseApp pode ser usada sistema autônomo um diferencial para o arquivo de log.
Para incluir a identificação do processo no nome (opcional)
conjunto o seguinte valor de chave UsePid para 1:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnóstico\registrar registrar registrar em log\UsePid
Essa chave é útil se você desejar executar um aplicativo várias vezes e criar logs separados para cada instância.Esta configuração adiciona a ID do processo ao nome de arquivo de log para que cada instância do aplicativo cria um novo arquivo de log com um nome diferente.
Para registrar eventos à medida que ele ocorrerem (opcional)
conjunto seguintes flush valor da chave para 1:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnóstico\registrar registrar registrar em log\Flush
Este valor faz com que o common linguagem tempo de execução (CLR) para gravar eventos de log no arquivo de log que ocorrem em vez de mantê-los no buffer e gravá-los quando o buffer está cheio.Esta configuração negativamente afeta o desempenho do aplicativo e pode modificar a temporização do aplicativo um pouco.No entanto, pode ser útil para diagnosticar problemas relacionados a falhas do aplicativo ou outros erros onde talvez você deseja ver últimos alguns eventos que resultaram em erro.Se esta chave não estiver presente ou não conjunto, dados não são gravados em arquivos de log até que o buffer esteja cheio.
Log de Interoperabilidade
Para habilitar o registrar registrar registrar em log interop
conjunto seguintes habilitado valor de chave para 1:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnóstico\registrar registrar registrar em log\Interop\Enabled
registrar registrar registrar em log de erro
Para habilitar o registrar registrar registrar em log de erro
conjunto o seguinte valor de Enabled para 1:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnóstico\registrar registrar registrar em log\erro\Enabled
Log de carregador
Para habilitar o registrar registrar registrar em log de carregador
conjunto o seguinte valor de Enabled para 1 para habilitar o registrar registrar registrar em log de carregador, ou conjunto para 2 para habilitar o registrar registrar registrar em log para o carregador e GAC:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnóstico\registrar registrar registrar em log\Loader\Enabled
Log de rede
Para ativar o registrar registrar registrar em log de rede
conjunto o seguinte valor de Enabled para 1:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnóstico\registrar registrar registrar em log\Networking\Enabled
O arquivo de log de rede é binário e não pode ser lido sem o .NET Compact Framework Visualizador de log, logviewer.exe, que converte o log do formato binário em formato legível. No .NET Compact Framework 3,5 e mais tarde, o Visualizador de log está incluído no potência Toys para o .NET Compact Framework. Você pode baixar essa ferramenta from a Página de downloads do .NET compact estrutura.
registrar registrar registrar em log de finalizador
Para habilitar o finalizador de registrar registrar registrar em log
conjunto o seguinte valor de Enabled para 1:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnóstico\registrar registrar registrar em log\finalizador\Enabled
registrar registrar registrar em log de rastreamento
Para habilitar o registrar registrar registrar em log de rastreamento do WCF
conjunto o seguinte valor de Enabled para 1:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnóstico\registrar registrar registrar em log\WCF\Enabled
Exemplo
Você pode conjunto valores de chave do registro usando Editor do Registro remoto, ou você pode escrever um aplicativo que irá conjunto os valores.O exemplo desta seção contém os seguintes métodos que manipulam as tarefas necessárias no registro:
The EnableLogging método habilita o registrar registrar registrar em log geral e contém parâmetros para especificar um caminho alternativo para o arquivo de registrar registrar registrar em log, para especificar se o aplicativo nome e ID do processo será adicionada ao arquivo de registrar registrar registrar em log nome e para especificar se sistema autônomo eventos serão registrados quando ocorrem.
The SetInteropLogging, SetLoaderLogging, e SetNetworkLogging métodos definido o valor da chave Enabled correspondente como 1 para que registrar registrar registrar em log desse componente é ativado.
The DisableLogging método desativa todos registrar registrar registrar em log.
The WriteLoggingSettings método examina recursivamente as chaves sob a subchave registrar registrar registrar em log e grava seus valores e nomes em um arquivo de registrar registrar registrar em log. O arquivo de log chamado logsettings.txt e está localizado no diretório que contém este aplicativo de exemplo.
' 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();
}
Compilando o código
Este exemplo requer referências aos seguintes namespaces: