Compartilhar via


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:

  • Nome do aplicativo.

  • ID de processo (sistema autônomo fornecidos por Windows Embedded CE).

  • Local de data e time em que o arquivo de log foi criado.O formato não é global ou específico de cultura.

  • .NET Compact Framework versão, sistema autônomo 2.0.5021.00.

  • Informações relacionadas à plataforma, sistema autônomo Windows Embedded CE V5.0.1400 (CEPC) WinCE5x86 depurar Dev i386 IJITv2.

O arquivo fornece as seguintes informações:

  • Estado coerção (modo de compatibilidade).

  • Nível de confiança atribuídos aos módulos à medida que eles são carregados.

  • Falha ao resolver método.

  • Falha ao resolver tipo.

  • Falha ao localizar ou carregar o assembly ou módulo.

  • Êxito no carregamento do assembly.

  • Versão de metadados inválida.

  • Falha ao localizar invocação de plataforma DLL.

  • Falha ao localizar função dentro de invocação de plataforma DLL.

  • Nome do arquivo de diretiva ou o fato da sua ausência.

  • Principais erros durante processamento de arquivo de diretiva.

  • Redirecionamento baseada em diretivas dos módulos gerenciados.

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.

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:

  • O carimbo de data / time que indica quando o finalizador executado o coletor de lixo no objeto.

  • A classe do objeto que foi finalizado.

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:

Consulte também

Conceitos

Informações de arquivo de log

Outros recursos

Desempenho e o diagnóstico no .NET Compact estrutura