Comment : créer des fichiers journaux

Article
08/21/2008

Mise à jour : novembre 2007

Vous pouvez créer des fichiers journaux contenant des informations de diagnostic sur l'interopérabilité, le chargement du programme et le réseau. Vous pouvez activer l'enregistrement dans un journal en définissant les clés de Registre. En premier lieu, définissez une clé de Registre pour activer l'enregistrement en général, puis définissez les clés de Registre pour le composant et les options de journal souhaités.

Vous pouvez utiliser les méthodes suivantes pour définir des clés de Registre :

Utilisez l'outil Remote Registry Editor dans Visual Studio.
Dans .NET Compact Framework 2.0 Service Pack 1, utilisez les options d'enregistrement dans l'Analyseur de performances distant. Pour plus d'informations sur l'Analyseur de performances distant, consultez Comment : analyser les performances au moment de l'exécution.
Dans .NET Compact Framework 3.5, vous pouvez utiliser l'outil d'enregistrement NetCFLogging.exe qui fournit une interface utilisateur graphique simple pour activer et désactiver l'enregistrement. Cet outil est inclus dans les Power Toys pour le .NET Compact Framework. Pour plus d'informations, consultez Power Toys pour le .NET Compact Framework (en anglais).
Utilisez les classes Registry et RegistryKey prises en charge dans le .NET Compact Framework version 2.0 et versions ultérieures.

Le tableau ci-dessous récapitule les fichiers journaux.

Interopérabilité

Enregistre des appels COM Interop. Fournit des informations sur les appels et le marshaling d'appel de code non managé.

Erreur

Enregistre toutes les exceptions natives et non gérées. Les erreurs sont enregistrées dans un fichier journal et dans OutputDebugString. Le fichier journal est créé pour chaque assembly dans le chemin d'accès actuel et s'applique à la session actuelle. Après la première occurrence d'une exception native ou non gérée, le fichier journal est remplacé.

Chargeur

Enregistre des informations sur le chargement du programme. L'en-tête de fichier contient les informations suivantes :

le nom de l'application ;
l'ID de processus (tel qu'il est fourni par Windows Embedded CE) ;
les date et heure locales auxquelles le fichier journal a été créé ; le format n'est ni global, ni spécifique à la culture ;
la version du .NET Compact Framework, telle que 2.0.5021.00 ;
des informations relatives à la plateforme, telles que Windows Embedded CE v5.0.1400 (CEPC) WinCE5x86 debug Dev i386 IJITv2.

Le fichier fournit les informations suivantes :

l'état de contrainte (mode de compatibilité) ;
le niveau de confiance assigné aux modules lors de leur chargement ;
l'échec de résolution d'une méthode ;
l'échec de résolution d'un type ;
l'échec de la recherche ou du chargement d'un assembly ou d'un module ;
la réussite du chargement d'un assembly ;
la version de métadonnées non valide ;
l'échec de la recherche de la DLL d'appel de code non managé ;
l'échec de la recherche d'une fonction dans la DLL d'appel de code non managé ;
le nom du fichier de stratégie ou la mention de son absence ;
les erreurs majeures survenues pendant le traitement du fichier de stratégie ;
la redirection basée sur la stratégie des assemblys managés.

Vous pouvez également inclure des informations concernant le Global Assembly Cache.

Réseau

Enregistre le trafic réseau. Le fichier journal du réseau est binaire et ne peut pas être lu sans la visionneuse du journal du .NET Compact Framework, Logviewer.exe. Dans le .NET Compact Framework 3.5 et versions ultérieures, la visionneuse du journal est incluse dans les Power Toys pour le .NET Compact Framework. Pour plus d'informations, consultez Power Toys pour le .NET Compact Framework (en anglais).

Étant donné que l'enregistrement réseau se produit au niveau de la couche Windows Sockets, le fichier journal contient seulement des données de paquet réseau, comme celles envoyées sur le réseau qui peuvent être sensibles si elles ne sont pas chiffrées.

Finaliseur

Enregistre le nom de classe des objets qui ne sont pas supprimés avant d'être ignorés par le garbage collector. Ce journal est pris en charge dans le .NET Compact Framework 3.5 et versions ultérieures.

Les noms d'objet ne sont pas inclus dans le journal, car ces noms ne sont pas disponibles au Common Language Runtime (CLR). Toutefois, les noms de classe pour les objets non supprimés peuvent aider à identifier ces objets. Les objets non supprimés peuvent créer des problèmes de performances dans les applications.

Remarque :
Dans certains cas, le .NET Compact Framework, au lieu du code d'application, appelle le finaliseur.

Ce fichier comporte les informations suivantes :

l'horodatage qui indique quand le finaliseur a exécuté le garbage collector sur l'objet ;
la classe de l'objet qui a été finalisé.

Trace

Enregistre les exceptions de code pour Windows Communication Foundation (WCF). Sur le bureau, le .NET Framework prend en charge trois types de journalisation : trace (suivi), messagerie et enregistrement des événements. WCF sur le .NET Compact Framework prend en charge uniquement la journalisation du suivi pour suivre les exceptions de code, mais n'enregistre pas les messages d'avertissement et d'erreur.

Ce journal est pris en charge dans le .NET Compact Framework 3.5 et versions ultérieures.

Par défaut, les fichiers journaux sont écrits dans le répertoire qui contient l'application diagnostiquée. Toutefois, vous pouvez spécifier un autre chemin d'accès et d'autres options avec les clés de Registre, comme suit :

utiliser un autre chemin d'accès pour écrire les fichiers journaux ; cela requiert un accès privilégié au Registre sécurisé ;
inclure le nom de l'application dans le nom du fichier journal ;
inclure l'ID de processus dans le nom du fichier journal.

Le nom d'un fichier journal se compose des parties suivantes, où composant correspond à "Interopérabilité", "Erreur", "Chargeur", "Réseau", "Finaliseur" ou "Trace".

netcf_nom-application_composant_IDprocessus.log

Le nom de l'application et l'ID de processus sont facultatifs et reposent sur les paramètres du Registre.

Par exemple, un fichier journal de chargeur pour une application nommée "MyApp.exe" pourrait s'intituler comme suit :

netcf_MyApp_Loader_2066923010.log

Pour plus d'informations sur l'examen des fichiers journaux, tels que les fichiers d'interopérabilité et les fichiers de chargeur, consultez Informations sur le fichier journal.

Pour activer l'enregistrement dans le journal

Affectez 1 à la valeur de clé Enabled suivante :

HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\Enabled

Cette valeur de clé doit être définie pour activer les six types d'enregistrement (interopérabilité, chargeur, erreur, réseau, finaliseur et trace). Notez que les sous-clés sous Logging n'existent pas par défaut.

Vous pouvez désactiver tout enregistrement en affectant la valeur 0 (zéro).

Pour spécifier un chemin d'accès pour le fichier journal (facultatif)

Affectez à la valeur de clé Path suivante une chaîne qui représente l'emplacement des fichiers journaux :

HKLM\Security\.NETCompactFramework\Diagnostics\Logging\Path

Seules les applications pouvant écrire dans le Registre sécurisé peuvent accéder à cette clé. Si aucun chemin d'accès n'est spécifié, le fichier journal est écrit dans le répertoire qui contient l'application.

Pour inclure l'application dans le nom (facultatif)

Affectez 1 à la valeur de clé UseApp suivante :

HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\UseApp

Cette clé est utile si vous souhaitez exécuter plusieurs applications et obtenir des fichiers journaux distincts pour chaque application. Si deux applications écrivent des fichiers journaux dans le même répertoire, le fichier journal le plus ancien est toujours remplacé par le fichier journal le plus récent lorsque la deuxième application est exécutée. La clé UseApp peut être utilisée comme différentiateur pour le fichier journal.

Pour inclure l'ID de processus dans le nom (facultatif)

Affectez 1 à la valeur de clé UsePid suivante :

HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\UsePid

Cette clé est utile si vous souhaitez exécuter une application plusieurs fois et créer des journaux distincts pour chaque instance. Ce paramètre ajoute l'ID de processus au nom du fichier journal ; ainsi, chaque instance de l'application crée un fichier journal avec un nom différent.

Pour enregistrer les événements au moment où ils se produisent (facultatif)

Affectez 1 à la valeur de clé Flush suivante :

HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\Flush

Cette valeur provoque l'écriture, par le Common Language Runtime (CLR), des événements de journal dans le fichier journal lorsqu'ils se produisent au lieu de les conserver dans la mémoire tampon et de les écrire lorsque cette dernière est pleine. Ce paramètre a une incidence négative sur la performance de l'application et peut modifier légèrement le minutage de l'application. Toutefois, il peut être utile pour diagnostiquer des problèmes liés aux échecs d'application ou les autres erreurs pour lesquelles vous souhaiterez éventuellement consulter les derniers événements qui ont provoqué l'erreur. Si cette clé est absente ou n'est pas définie, les données ne sont écrites dans les fichiers journaux que lorsque la mémoire tampon est pleine.

Enregistrement d'interopérabilité

Pour activer l'enregistrement d'interopérabilité

Affectez 1 à la valeur de clé Enabled suivante :

HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\Interop\Enabled

Enregistrement des erreurs

Pour activer l'enregistrement des erreurs

Affectez 1 à la valeur Enabled suivante :

HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\Error\Enabled

Enregistrement de chargeur

Pour activer l'enregistrement de chargeur

Affectez 1 à la valeur Enabled suivante afin d'activer l'enregistrement pour le chargeur ou 2 afin d'activer l'enregistrement pour le chargeur et le Global Assembly Cache :

HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\Loader\Enabled

Enregistrement de réseau

Pour activer l'enregistrement de réseau

Affectez 1 à la valeur Enabled suivante :

HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\Networking\Enabled

Le fichier journal du réseau est binaire et ne peut pas être lu sans la visionneuse du journal du .NET Compact Framework, Logviewer.exe, qui convertit le format binaire du journal en un format lisible par l'utilisateur. Dans le .NET Compact Framework 3.5 et versions ultérieures, la visionneuse du journal est incluse dans les Power Toys pour le .NET Compact Framework. Vous pouvez télécharger cet outil à partir de la page Téléchargements du .NET Compact Framework (en anglais).

Enregistrement de finaliseur

Pour activer l'enregistrement de finaliseur

Affectez 1 à la valeur Enabled suivante :

HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\Finalizer\Enabled

Enregistrement de trace

Pour activer l'enregistrement de trace WCF

Affectez 1 à la valeur Enabled suivante :

HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\WCF\Enabled

Exemple

Vous pouvez définir les valeurs de clé de Registre à l'aide de l'outil Remote Registry Editor ou écrire une application qui définira les valeurs. L'exemple de cette section contient les méthodes suivantes qui gèrent les tâches de Registre nécessaires :

La méthode EnableLogging active l'enregistrement en général et contient des paramètres qui permettent de spécifier un autre chemin d'accès pour le fichier journal, d'indiquer si le nom de l'application et l'ID de processus seront ajoutés au nom du fichier journal et de préciser si les événements seront enregistrés dès qu'ils se produisent.
Les méthodes SetInteropLogging, SetLoaderLogging et SetNetworkLogging affectent 1 à la valeur de clé Enabled correspondante afin que l'enregistrement de ce composant soit activé.
La méthode DisableLogging désactive tout enregistrement.
La méthode WriteLoggingSettings examine de manière récursive les clés se trouvant sous la sous-clé Logging et écrit leurs noms et valeurs de clé dans un fichier journal. Le fichier journal s'intitule "logsettings.txt" et se trouve dans le répertoire qui contient cet exemple d'application.

' 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();
}

Compilation du code

Cet exemple nécessite des références aux espaces de noms suivants :

Voir aussi

Concepts

Informations sur le fichier journal

Autres ressources

Performance et diagnostics dans le .NET Compact Framework

Partager via