Cómo: Crear archivos de registro
Actualización: noviembre 2007
Se pueden crear archivos de registro que contengan información de diagnóstico sobre la interoperabilidad, la carga del programa y la conexión de red. Se puede habilitar el registro estableciendo las claves del Registro. En primer lugar, establezca una clave del Registro para habilitar el registro general y, a continuación, establezca las claves del Registro para las opciones y el componente de registro deseados.
Puede utilizar los métodos siguientes para establecer las claves del Registro:
Utilice el Editor de Registro remoto en Visual Studio.
En .NET Compact Framework 2.0 Service Pack 1, utilice las opciones de registro de Supervisión remota del rendimiento. Para obtener más información sobre Supervisión remota del rendimiento, vea Cómo: Supervisar el rendimiento en tiempo de ejecución.
En .NET Compact Framework 3.5, puede utilizar la herramienta de registro NetCFLogging.exe, que proporciona una sencilla interfaz de usuario gráfica que permite habilitar y deshabilitar el registro. Esta herramienta se incluye en las herramientas avanzadas de .NET Compact Framework. Para obtener más información, vea Power Toys for .NET Compact Framework.
Utilice las clases Registry y RegistryKey, que son compatibles con .NET Compact Framework versión 2.0 y versiones posteriores.
En la tabla siguiente se incluye un resumen de los archivos de registro.
Componente de registro |
Contenido del archivo de registro |
|---|---|
Interoperabilidad |
Registra las llamadas de interoperabilidad COM. Proporciona información sobre las llamadas de invocación de plataforma y el cálculo de referencias. |
Error |
Registra todas las excepciones, las no controladas y las nativas. Los errores se graban a un archivo de registro y en OutputDebugString. Se crea un archivo de registro para cada ensamblado en la ruta de acceso actual y se aplica a la sesión actual. Después de la primera aparición de una excepción no controlada o nativa, el archivo de registro se sobrescribirá. |
Cargador |
Registra información sobre la carga del programa. El encabezado del archivo contiene la siguiente información:
El archivo proporciona la información siguiente:
También puede incluir información sobre la memoria caché de ensamblados global. |
Conexión de red |
Registra el tráfico de red. El archivo de registro de la conexión de red es binario y no se puede obtener acceso a él sin el visor de registros de .NET Compact Framework, Logviewer.exe. En .NET Compact Framework 3.5 y versiones posteriores, el visor de registros se suministra con las herramientas avanzadas de .NET Compact Framework. Para obtener más información, vea Power Toys for .NET Compact Framework. Dado que el registro de la conexión de red se produce en el nivel de Windows Sockets, el archivo de registro sólo contiene información sobre los paquetes de red. Esta información incluye los datos enviados a través de la red, que pueden ser confidenciales si no se cifran. |
Finalizador |
Registra el nombre de clase de los objetos que no se han desechado antes de que los descarte el recolector de elementos no utilizados. Este registro es compatible con .NET Compact Framework 3.5 y versiones posteriores. Los nombres de objeto no se incluyen en el registro porque no están disponibles en Common Language Runtime (CLR). Sin embargo, los nombres de clase de los objetos que no se han desechado pueden ayudar a la identificación de estos objetos. Los objetos no desechados pueden provocar problemas de rendimiento en las aplicaciones. .gif "Nota") Nota:
En algunos casos, .NET Compact Framework llama al finalizador en lugar de llamar al código de la aplicación.
Este archivo contiene la siguiente información:
|
Seguimiento |
Registra las excepciones de código de Windows Communication Foundation (WCF). En la versión para escritorio, .NET Framework admite tres tipos de registro: registro de seguimiento, mensajería y eventos. En .NET Compact Framework, WCF sólo admite el registro de seguimiento para rastrear las excepciones de código, pero no registra los mensajes de advertencia y error. Este registro es compatible con .NET Compact Framework 3.5 y versiones posteriores. |
De manera predeterminada, los archivos de registro se escriben en el directorio que contiene la aplicación objeto de diagnóstico. Sin embargo, se puede especificar una ruta de acceso y otras opciones con claves del Registro del modo siguiente:
Utilice una ruta de acceso alternativa para escribir los archivos de registro. Esto requiere acceso privilegiado al Registro seguro.
Incluya el nombre de la aplicación en el nombre del archivo de registro.
Incluya el identificador de proceso en el nombre del archivo de registro.
Un nombre de archivo de registro se compone de las partes siguientes, donde componente puede ser "Interop", "Error", "Loader", "Network", "Finalizer" o "Trace":
netcf_nombreDeAplicación_componente_IdentificadorDeProceso.log
El nombre de la aplicación y el identificador del proceso son opcionales y dependen de la configuración del Registro.
Por ejemplo, un archivo de registro del cargador de una aplicación denominada MyApp.exe podría denominarse del modo siguiente:
netcf_MyApp_Loader_2066923010.log
Para obtener información acerca de cómo se examinan los archivos de registro, por ejemplo el archivo de registro del cargador o de interoperabilidad, vea Información del archivo de registro.
Para habilitar el registro
Establezca el siguiente valor de clave Enabled en 1:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\Enabled
Este valor de clave debe establecerse de modo que se habiliten los siguientes seis tipos de registro: interop, loader, error, networking, finalizer y trace. Observe que las subclaves situadas bajo Registro no existen de manera predeterminada.
Para desactivar todo el registro, puede establecer este valor en 0 (cero).
Para especificar una ruta de acceso para el archivo de registro (opcional)
Establezca el valor de clave Path en una cadena que represente la ubicación de los archivos de registro:
HKLM\Security\.NETCompactFramework\Diagnostics\Logging\Path
A esta clave sólo tienen acceso las aplicaciones que pueden escribir en el Registro seguro. Si no se especifica una ruta de acceso, el archivo de registro se escribe en el directorio que contiene la aplicación.
Para incluir la aplicación en el nombre (opcional)
Establezca el siguiente valor de clave UseApp en 1:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\UseApp
Esta clave resulta útil si desea ejecutar varias aplicaciones y obtener archivos de registro independientes para cada aplicación. Si hay dos aplicaciones que escriben archivos de registro en el mismo directorio, el archivo de registro más antiguo siempre se sobrescribirá con el archivo de registro más moderno cuando se ejecute la segunda aplicación. La clave UseApp se puede utilizar como diferenciador del archivo de registro.
Para incluir el identificador de proceso en el nombre (opcional)
Establezca el siguiente valor de clave UseApp en 1:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\UsePid
Esta clave es útil si desea ejecutar varias veces una aplicación y crear registros independientes para cada instancia. Esta configuración agrega el identificador de proceso al nombre del archivo de registro para que cada instancia de la aplicación cree un nuevo archivo de registro con un nombre diferente.
Para registrar los eventos según se produzcan (opcional)
Establezca el siguiente valor de clave Flush en 1:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\Flush
Este valor hace que Common Language Runtime (CLR) escriba los eventos de registro en el archivo de registro a medida que se producen, en lugar de mantenerlos en el búfer y escribirlos cuando el búfer está lleno. Este valor afecta negativamente al rendimiento de la aplicación y puede modificar ligeramente el control de tiempo de la aplicación. Sin embargo, puede resultar útil para diagnosticar problemas relacionados con los errores de la aplicación u otro tipo de errores, ya que es posible que desee ver los últimos eventos en los que se han producido errores. Si esta clave no está presente o no está definida, los datos no se escriben en los archivos de registro hasta que el búfer está lleno.
Registro de interoperabilidad
Para habilitar el registro Interop
Establezca el siguiente valor de clave Enabled en 1:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\Interop\Enabled
Registro de errores
Para habilitar el registro Error
Establezca el siguiente valor Enabled en 1:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\Error\Enabled
Registro Loader
Para habilitar el registro Loader
Establezca el siguiente valor Enabled en 1 para habilitar el registro del cargador o establézcalo en 2 para habilitar el registro del cargador y la memoria caché de ensamblados global:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\Loader\Enabled
Registro Networking
Para habilitar el registro Networking
Establezca el siguiente valor Enabled en 1:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\Networking\Enabled
El archivo de registro de conexión de red es binario y no se puede leer sin el visor de registros de .NET Compact Framework, Logviewer.exe, que transforma el registro en formato binario en un formato legible. En .NET Compact Framework 3.5 y versiones posteriores, el visor de registros se suministra con las herramientas avanzadas de .NET Compact Framework. Puede descargar esta herramienta de la página .NET Compact Framework Downloads page.
Registro del finalizador
Para habilitar el registro del finalizador
Establezca el siguiente valor Enabled en 1:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\Finalizer\Enabled
Registro de seguimiento
Para habilitar el registro de seguimiento de WCF
Establezca el siguiente valor Enabled en 1:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\WCF\Enabled
Ejemplo
Puede establecer los valores de clave del Registro utilizando el Editor de registro remoto o puede escribir una aplicación que establezca estos valores. El ejemplo de esta sección contiene los métodos siguientes que administran las tareas de Registro necesarias:
El método EnableLogging habilita el registro general y contiene parámetros que permiten especificar una ruta de acceso alternativa para el archivo de registro, permiten determinar si el nombre de aplicación y el identificador de proceso se van a agregar al nombre del archivo de registro y permiten establecer si los eventos se van a registrar a medida que se produzcan.
Los métodos SetInteropLogging, SetLoaderLogging y SetNetworkLogging establecen el valor de clave Enabled correspondiente en 1 para que se habilite el registro de ese componente.
El método DisableLogging deshabilita todo el registro.
El método WriteLoggingSettings examina de forma recursiva las claves situadas bajo la subclave Registro y escribe sus nombres y valores en un archivo de registro. El archivo de registro se denomina logsettings.txt y se encuentra en el directorio que contiene esta aplicación de ejemplo.
' 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();
}
Compilar el código
Para este ejemplo se requieren referencias a los siguientes espacios de nombres:
Vea también
Conceptos
Información del archivo de registro