EventSchemaTraceListener Classe

Référence

Définition

Espace de noms:: System.Diagnostics

Assembly:: System.Core.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Dirige la sortie du traçage ou du débogage d'événements de bout en bout vers un fichier journal encodé XML conforme au schéma.

public ref class EventSchemaTraceListener : System::Diagnostics::TextWriterTraceListener

public class EventSchemaTraceListener : System.Diagnostics.TextWriterTraceListener

type EventSchemaTraceListener = class
    inherit TextWriterTraceListener

Public Class EventSchemaTraceListener
Inherits TextWriterTraceListener

Héritage: Object

MarshalByRefObject

TraceListener

TextWriterTraceListener
EventSchemaTraceListener

Exemples

L’exemple de code suivant montre comment utiliser la EventSchemaTraceListener classe .


///////////////////////////////////////////////////////////////////////
//
// EventSchemaTraceListener.cpp : main project file.
// Expected Output:
// 1)
//      EventSchemaTraceListener CPP Sample
//
//      IsThreadSafe? True
//      BufferSize =  65536
//      MaximumFileSize =  20480000
//      MaximumNumberOfFiles =  2
//      Name =  eventListener
//      TraceLogRetentionOption = LimitedCircularFiles
//      TraceOutputOptions = DateTime, Timestamp, ProcessId
//
//      Press the enter key to exit
//
// 2) An output file is created named TraceOutput.xml.  It will be
//    opened and displayed in Microsoft Notepad.
//
// NOTE 1:
//  Under certain circumstances, the VS C++ compiler will treat
//          Console::WriteLine("MyText = " + MyVar);
//        differently then the VS CSharp compiler.
//        The C++ compiler will produce error C3063, whereas the 
//        CSharp compiler accepts the statement.
//        This occurs when the VS C++ compiler cannot determine the
//        datatype of "MyVar" because it is an enumeration type.
//        The solution is:
//        Use either of the following two methods:
//          Console::WriteLine("MyText = {0} " , MyVar);
//          Console::WriteLine("MyText =  " + MyVar.ToString());
//
//        Although not specific to this particular pieces of code,
//        this is demonstrated below in the Display function:  The
//        last two members, TraceLogRetentionOption, and
//        TraceOutputOptions, are enumerations, and cannot simply be
//        concatenated into Console::WriteLine.
//
///////////////////////////////////////////////////////////////////////
#using <System.dll>
#using <System.Core.dll>

#define NOCONFIGFILE 1
using namespace System;
using namespace System::IO;
using namespace System::Diagnostics;


[STAThreadAttribute]
void main()
{
    Console::WriteLine("EventSchemaTraceListener CPP Sample\n");

    File::Delete("TraceOutput.xml");
    TraceSource ^ ts = gcnew TraceSource("TestSource");


#if NOCONFIGFILE
    ts->Listeners->Add(gcnew EventSchemaTraceListener("TraceOutput.xml",
                            "eventListener", 65536,
                            TraceLogRetentionOption::LimitedCircularFiles,
                            20480000, 2));
    ts->Listeners["eventListener"]->TraceOutputOptions =
                                    TraceOptions::DateTime |
                                    TraceOptions::ProcessId |
                                    TraceOptions::Timestamp;
#endif

    EventSchemaTraceListener ^ ESTL =
               (EventSchemaTraceListener^)(ts->Listeners["eventListener"]);


    Console::WriteLine("IsThreadSafe?            = " + ESTL->IsThreadSafe);
    Console::WriteLine("BufferSize               = " + ESTL->BufferSize);
    Console::WriteLine("MaximumFileSize          = " + ESTL->MaximumFileSize);
    Console::WriteLine("MaximumNumberOfFiles     = " + ESTL->MaximumNumberOfFiles);
    Console::WriteLine("Name                     = " + ESTL->Name);
    Console::WriteLine("TraceLogRetentionOption  = " + ESTL->TraceLogRetentionOption.ToString());
    Console::WriteLine("TraceOutputOptions       = {0}\n", ESTL->TraceOutputOptions);

    ts->Switch->Level = SourceLevels::All;
    String ^ testString = "<Test><InnerElement Val=\"1\" />"
                        + "<InnerElement Val=\"Data\"/>"
                        + "<AnotherElement>11</AnotherElement></Test>";

    UnescapedXmlDiagnosticData ^ unXData = gcnew UnescapedXmlDiagnosticData(testString);
    ts->TraceData(TraceEventType::Error, 38, unXData);
    ts->TraceEvent(TraceEventType::Error, 38, testString);
    ts->Flush();
    ts->Close();

    Process::Start("notepad.exe", "TraceOutput.xml");
    Console::WriteLine("\nPress the enter key to exit");
    Console::ReadLine();
}

#define NOCONFIGFILE
using System;
using System.IO;
using System.Xml;
using System.Xml.XPath;
using System.Diagnostics;

class testClass
{
    [STAThreadAttribute]
    static void Main()
    {
        File.Delete("TraceOutput.xml");
        TraceSource ts = new TraceSource("TestSource");
#if NOCONFIGFILE
        //ts.Listeners.Add(new EventSchemaTraceListener("TraceOutput.xml", "eventListener", 65536, TraceLogRetentionOption.LimitedCircularFiles, 20480000, 2));
        ts.Listeners.Add(new EventSchemaTraceListener("TraceOutput.xml", "eventListener"));
        ts.Listeners["eventListener"].TraceOutputOptions = TraceOptions.DateTime | TraceOptions.ProcessId | TraceOptions.Timestamp;
#endif
        ts.Switch.Level = SourceLevels.All;
        string testString = "<Test><InnerElement Val=\"1\" /><InnerElement Val=\"Data\"/><AnotherElement>11</AnotherElement></Test>";
        UnescapedXmlDiagnosticData unXData = new UnescapedXmlDiagnosticData(testString);
        ts.TraceData(TraceEventType.Error, 38, unXData);
        ts.TraceEvent(TraceEventType.Error, 38, testString);
        Trace.Listeners.Add(new EventSchemaTraceListener("TraceOutput.xml"));
        Trace.Write("test", "test");
        Trace.Flush();
        ts.Flush();
        ts.Close();
        DisplayProperties(ts);
        Process.Start("notepad.exe", "TraceOutput.xml");
        Console.WriteLine("Press the enter key to exit");
        Console.ReadLine();
    }
    private static void DisplayProperties(TraceSource ts)
    {
        Console.WriteLine("IsThreadSafe? " + ((EventSchemaTraceListener)ts.Listeners["eventListener"]).IsThreadSafe);
        Console.WriteLine("BufferSize =  " + ((EventSchemaTraceListener)ts.Listeners["eventListener"]).BufferSize);
        Console.WriteLine("MaximumFileSize =  " + ((EventSchemaTraceListener)ts.Listeners["eventListener"]).MaximumFileSize);
        Console.WriteLine("MaximumNumberOfFiles =  " + ((EventSchemaTraceListener)ts.Listeners["eventListener"]).MaximumNumberOfFiles);
        Console.WriteLine("Name =  " + ((EventSchemaTraceListener)ts.Listeners["eventListener"]).Name);
        Console.WriteLine("TraceLogRetentionOption =  " + ((EventSchemaTraceListener)ts.Listeners["eventListener"]).TraceLogRetentionOption);
        Console.WriteLine("TraceOutputOptions =  " + ((EventSchemaTraceListener)ts.Listeners["eventListener"]).TraceOutputOptions);
    }
}

#Const NOCONFIGFILE = True
Imports System.IO
Imports System.Xml
Imports System.Xml.XPath
Imports System.Diagnostics

Class testClass

    <STAThreadAttribute()> _
    Shared Sub Main()
        File.Delete("TraceOutput.xml")
        Dim ts As New TraceSource("TestSource")
#If NOCONFIGFILE Then
        ts.Listeners.Add(New EventSchemaTraceListener("TraceOutput.xml", "eventListener", 65536, TraceLogRetentionOption.LimitedCircularFiles, 20480000, 2))
        ts.Listeners("eventListener").TraceOutputOptions = TraceOptions.DateTime Or TraceOptions.ProcessId Or TraceOptions.Timestamp
#End If
        ts.Switch.Level = SourceLevels.All
        Dim testString As String = "<Test><InnerElement Val=""1"" /><InnerElement Val=""Data""/><AnotherElement>11</AnotherElement></Test>"
        Dim unXData As New UnescapedXmlDiagnosticData(testString)
        ts.TraceData(TraceEventType.Error, 38, unXData)
        ts.TraceEvent(TraceEventType.Error, 38, testString)
        ts.Flush()
        ts.Close()
        DisplayProperties(ts)
        Process.Start("notepad.exe", "TraceOutput.xml")
        Console.WriteLine("Press the enter key to exit")
        Console.ReadLine()

    End Sub

    Private Shared Sub DisplayProperties(ByVal ts As TraceSource)
        Console.WriteLine("IsThreadSafe? " + CType(ts.Listeners("eventListener"), EventSchemaTraceListener).IsThreadSafe.ToString())
        Console.WriteLine("BufferSize =  " + CType(ts.Listeners("eventListener"), EventSchemaTraceListener).BufferSize.ToString())
        Console.WriteLine("MaximumFileSize =  " + CType(ts.Listeners("eventListener"), EventSchemaTraceListener).MaximumFileSize.ToString())
        Console.WriteLine("MaximumNumberOfFiles =  " + CType(ts.Listeners("eventListener"), EventSchemaTraceListener).MaximumNumberOfFiles.ToString())
        Console.WriteLine("Name =  " + CType(ts.Listeners("eventListener"), EventSchemaTraceListener).Name)
        Console.WriteLine("TraceLogRetentionOption =  " + CType(ts.Listeners("eventListener"), EventSchemaTraceListener).TraceLogRetentionOption.ToString())
        Console.WriteLine("TraceOutputOptions =  " + CType(ts.Listeners("eventListener"), EventSchemaTraceListener).TraceOutputOptions.ToString())
    End Sub
End Class

Remarques

La EventSchemaTraceListener classe fournit le suivi des événements conformes au schéma de bout en bout. Vous pouvez utiliser le suivi de bout en bout pour un système qui a des composants hétérogènes qui traversent les limites des threads, AppDomaindes processus et de l’ordinateur. Un schéma d’événement standardisé permet le suivi au-delà de ces limites. Le schéma permet l’ajout d’éléments personnalisés conformes au schéma. Vous pouvez utiliser l’outil Service Trace Viewer Tool (SvcTraceViewer.exe) pour afficher les données d’événement.

EventSchemaTraceListener est paramétré pour les performances de journalisation avec la prise en charge implicite du suivi sans verrou.

La EventSchemaTraceListener classe convertit les informations de suivi et de débogage en flux de texte encodé en XML. La description de la sortie XML est présentée dans les tableaux plus loin dans cette section.

Vous pouvez créer un EventSchemaTraceListener objet dans votre code. Pour les applications .NET Framework, vous pouvez également activer ou désactiver un objet via le fichier de configuration de EventSchemaTraceListener l’application, puis utiliser l’objet configuré EventSchemaTraceListener dans votre application. Pour plus d’informations sur l’utilisation des fichiers de configuration pour le suivi et le débogage dans les applications .NET Framework, consultez Schéma des paramètres de suivi et de débogage.

Pour configurer un EventSchemaTraceListener objet dans une application .NET Framework, modifiez le fichier de configuration qui correspond au nom de votre application. Dans ce fichier, vous pouvez ajouter, supprimer ou définir les propriétés d’un écouteur. Le fichier de configuration doit être mis en forme comme suit :

<configuration>  
    <system.diagnostics>  
        <sources>  
            <source name="TestSource" >  
                <listeners>  
                    <!--Remove the default trace listener for better performance.-->  
                    <remove name="Default"/>  
                    <!--Note: Removing the default trace listener prevents the dialog box   
                    from being displayed for Debug.Fail or Debug.Assert commands that are   
                    executed in user mode.-->  
                    <add name="eventListener"   
                      type="System.Diagnostics.EventSchemaTraceListener,  system.core"  
                      initializeData="TraceOutput.xml"   
                      traceOutputOptions="ProcessId, DateTime, Timestamp"   
                      bufferSize="65536"  
                      maximumFileSize="20480000"  
                      logRetentionOption="LimitedCircularFiles"  
                      maximumNumberOfFiles="2"/>  
                </listeners>  
            </source>  
        </sources>  
    </system.diagnostics>

La EventSchemaTraceListener classe hérite de la Filter propriété de la classe TraceListenerde base . La Filter propriété permet un niveau supplémentaire de filtrage de la sortie de trace au niveau de l’écouteur. Si un filtre est présent, les Trace méthodes de l’écouteur de trace appellent la ShouldTrace méthode du filtre pour déterminer s’il faut émettre la trace.

Si une tentative d’écriture est effectuée dans un fichier utilisé ou non disponible, un suffixe GUID est automatiquement ajouté au nom de fichier.

Notes

Les méthodes d’écouteur sont destinées à être appelées par les Debugméthodes des classes , Traceet TraceSource . N’appelez pas les méthodes de l’écouteur directement à partir du code de l’application. L’écouteur EventSchemaTraceListener est principalement destiné à être utilisé par la TraceSource classe .

Le tableau suivant décrit les éléments et les attributs de la sortie XML.

Élément	Attributs	Sortie	Notes
`CallStack`	Aucun	Dépend de la présence de l’indicateur Callstack dans la TraceOutputOptions propriété .	Les caractères spéciaux tels que > ou < sont remplacés par des séquences d’échappement. Consultez la table de traduction de caractères d’échappement dans le tableau suivant.
`Computer`	Aucun	Toujours présent.	Cet élément représente la valeur de la MachineName propriété .
`Correlation`	`ActivityID`	Toujours présent.	Si `ActivityID` n’est pas spécifié, la valeur par défaut est un GUID vide.
	`RelatedActivityID`	Dépend de la présence du `relatedActivityId` paramètre dans l’appel de méthode `Trace` .	L’attribut `RelatedActivityID` correspond au `relatedActivityId` paramètre de la TraceTransfer méthode .
`Data`	Aucun	Toujours présent.	Cet élément représente l’entrée de paramètre (`data`). Un élément est fourni pour chaque objet de données. Dans le cas des journaux des événements, l’élément contient des `Data` données XML d’échappement. Dans le cas des journaux de données, l’élément `Data` contient des données sans séquence d’échappement. La sortie du journal de données utilise la `ToString` méthode des objets de données transmis.
`Event`	Aucun	Toujours présent.	Cet élément contient un événement de trace.
`EventData`	Aucun	Présent pour les journaux des événements.	Cet élément représente l’entrée de paramètre (`message`, `args`). Il contient des `Data` éléments avec des données XML d’échappement créées en appelant la TraceEvent méthode .
`EventID`	Aucun	Toujours présent.	Cet élément représente l’entrée de paramètre (`id`).
`Execution`	`ProcessID`	Dépend de la présence de l’indicateur ProcessId dans la TraceOutputOptions propriété .	L’attribut `ProcessID` est spécifié dans .TraceEventCache
	`ThreadID`	Présent quand `ProcessID` est présent.	L’attribut `ThreadID` est spécifié dans .TraceEventCache
`Level`	Aucun	Toujours présent.	Cet élément représente l’entrée de paramètre (la valeur numérique de `eventType`). Les valeurs de paramètre supérieures à 255 sont sorties sous la forme d’un niveau 8, qui représente TraceEventType.Information. Les types d’événements Criticalde trace , Error, Warning Information, et Verbose sont générés aux niveaux 1, 2, 4, 8 et 10, respectivement.
`LogicalOperationStack`	Aucun	Dépend de la présence de l’indicateur LogicalOperationStack dans la TraceOutputOptions propriété .	Une seule opération logique peut exister. Par conséquent, les valeurs sont écrites en tant que `LogicalOperation` nœuds sous l’élément `LogicalOperationStack` .
`OpCode`	Aucun	Présent quand `Level` est supérieur à 255.	Cet élément représente les types d’événements Trace dont les valeurs numériques sont supérieures à 255. Start, Stop, Suspend, Resumeou Transfer sont des niveaux 1, 2, 4, 8 et 10, respectivement.
`Provider`	`GUID`	Toujours présent.	Toujours vide.
`RenderingInfo`	`Culture`	Toujours présent.	Cet attribut représente une chaîne de ressource pour le type d’événement. Il s’agit toujours de « en-EN\ ».
`System`	`Name`	Toujours présent.
`TimeCreated`	`SystemTime`	Dépend de la présence de l’indicateur DateTime dans la TraceOutputOptions propriété .	L’heure est la valeur de la TraceEventCache.DateTime propriété . Cette propriété est exprimée en temps universel coordonné
`TimeStamp`	Aucun	Dépend de la présence de l’indicateur Timestamp dans la TraceOutputOptions propriété .	Cet élément est spécifié dans le TraceEventCache.
`UserData`	Aucun	Présent pour les journaux de données.	Cet élément contient des `Data` éléments avec des données fournies par l’utilisateur sans séquence d’échappement à partir d’une TraceData méthode.

Le tableau suivant montre les caractères qui sont placés dans une séquence d’échappement dans la sortie XML. L’échappement se produit dans tous les éléments et attributs, à l’exception de l’élément UserData , qui contient des données fournies par l’utilisateur sans séquence d’échappement. L’élément UserData est le résultat d’appels à la TraceData méthode .

Caractère d’échappement	Valeur
&	&
<	<
>	>
"	"
\|'
0xD
0xA

Constructeurs

EventSchemaTraceListener(String)	Initialise une nouvelle instance de la classe EventSchemaTraceListener, à l'aide du fichier spécifié comme destinataire de la sortie de débogage et de traçage.
EventSchemaTraceListener(String, String)	Initialise une nouvelle instance de la classe EventSchemaTraceListener avec le nom spécifié, à l'aide du fichier spécifié comme destinataire de la sortie de débogage et de traçage.
EventSchemaTraceListener(String, String, Int32)	Initialise une nouvelle instance de la classe EventSchemaTraceListener avec le nom spécifié et la taille de la mémoire tampon spécifiée, à l'aide du fichier spécifié comme destinataire de la sortie de débogage et de traçage.
EventSchemaTraceListener(String, String, Int32, TraceLogRetentionOption)	Initialise une nouvelle instance de la classe EventSchemaTraceListener avec le nom et la taille de mémoire tampon spécifiés, à l'aide du fichier spécifié, avec la stratégie de rétention de journal spécifiée, comme destinataire de sortie de débogage et de traçage.
EventSchemaTraceListener(String, String, Int32, TraceLogRetentionOption, Int64)	Initialise une nouvelle instance de la classe EventSchemaTraceListener avec le nom et la taille de mémoire tampon spécifiés, à l'aide du fichier spécifié, avec la stratégie de rétention de journal et la taille maximale spécifiées, comme destinataire de sortie de débogage et de traçage.
EventSchemaTraceListener(String, String, Int32, TraceLogRetentionOption, Int64, Int32)	Initialise une nouvelle instance de la classe EventSchemaTraceListener avec le nom et la taille de mémoire tampon spécifiés, à l'aide du fichier spécifié, avec la stratégie de rétention de journal, la taille maximale et le nombre de fichiers spécifiés, comme destinataire de sortie de débogage et de traçage.

Propriétés

Attributes	Obtient les attributs d'écouteur de trace personnalisés définis dans le fichier de configuration de l'application. (Hérité de TraceListener)
BufferSize	Obtient la taille de la mémoire tampon de sortie.
Filter	Obtient ou définit le filtre de trace pour l’écouteur de la trace. (Hérité de TraceListener)
IndentLevel	Obtient ou définit le niveau de retrait. (Hérité de TraceListener)
IndentSize	Obtient ou définit le nombre d'espaces dans un retrait. (Hérité de TraceListener)
IsThreadSafe	Obtient une valeur qui indique si l'écouteur de trace est thread-safe.
MaximumFileSize	Obtient la taille maximale du fichier journal.
MaximumNumberOfFiles	Obtient le nombre maximal de fichiers journaux.
Name	Obtient ou définit un nom pour ce TraceListener. (Hérité de TraceListener)
NeedIndent	Obtient ou définit une valeur indiquant si la sortie doit être mise en retrait. (Hérité de TraceListener)
TraceLogRetentionOption	Obtient l'option de rétention du journal de suivi pour le fichier.
TraceOutputOptions	Obtient ou définit les options de sortie de trace. (Hérité de TraceListener)
Writer	Obtient ou définit le writer de texte sous-jacent qui écrit dans le fichier journal.

Méthodes

Close()	Ferme le fichier journal pour cet écouteur pour qu'il ne reçoive plus la sortie de traçage ou de débogage.
CreateObjRef(Type)	Crée un objet contenant toutes les informations appropriées requises pour générer un proxy permettant de communiquer avec un objet distant. (Hérité de MarshalByRefObject)
Dispose()	Libère toutes les ressources utilisées par TraceListener. (Hérité de TraceListener)
Dispose(Boolean)	Supprime cet objet TextWriterTraceListener. (Hérité de TextWriterTraceListener)
Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
Fail(String)	Émet un message d'erreur à l'écouteur que vous créez lors de l'implémentation de la classe TraceListener. (Hérité de TraceListener)
Fail(String, String)	Écrit des informations sur l'erreur, y compris un message d'erreur de base et un message d'erreur détaillé, dans le fichier journal.
Flush()	Provoque l'écriture dans le journal des données mises en mémoire tampon pour cet écouteur.
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetLifetimeService()	Obsolète. Récupère l'objet de service de durée de vie en cours qui contrôle la stratégie de durée de vie de cette instance. (Hérité de MarshalByRefObject)
GetSupportedAttributes()	Obtient les attributs de configuration XML personnalisés pris en charge par l'écouteur de suivi.
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
InitializeLifetimeService()	Obsolète. Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance. (Hérité de MarshalByRefObject)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
MemberwiseClone(Boolean)	Crée une copie superficielle de l'objet MarshalByRefObject actuel. (Hérité de MarshalByRefObject)
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)
TraceData(TraceEventCache, String, TraceEventType, Int32, Object)	Écrit des informations de suivi, un objet de données unique et des informations d'événements dans le fichier journal.
TraceData(TraceEventCache, String, TraceEventType, Int32, Object[])	Écrit des informations de suivi, des objets de données multiples et des informations d'événements dans le fichier journal.
TraceEvent(TraceEventCache, String, TraceEventType, Int32)	Écrit les informations sur la trace et les événements dans la sortie spécifique de l'écouteur. (Hérité de TraceListener)
TraceEvent(TraceEventCache, String, TraceEventType, Int32, String)	Écrit des informations de suivi, un message et des informations d'événements dans le fichier journal.
TraceEvent(TraceEventCache, String, TraceEventType, Int32, String, Object[])	Écrit des informations de suivi, un message mis en forme et des informations d'événements dans le fichier journal.
TraceTransfer(TraceEventCache, String, Int32, String, Guid)	Écrit des informations de suivi, y compris une identité d'activité connexe, un message et des informations d'événements dans le fichier journal.
Write(Object)	Écrit la valeur de la méthode ToString() de l'objet dans l'écouteur que vous créez lors de l'implémentation de la classe TraceListener. (Hérité de TraceListener)
Write(Object, String)	Écrit un nom de catégorie ou la valeur de la méthode ToString() de l'objet dans l'écouteur que vous créez lors de l'implémentation de la classe TraceListener. (Hérité de TraceListener)
Write(String)	Écrit un message dans le fichier journal sans fournir d'informations de contexte supplémentaires.
Write(String, String)	Écrit un nom de catégorie et un message dans l'écouteur que vous créez lors de l'implémentation de la classe TraceListener. (Hérité de TraceListener)
WriteIndent()	Écrit la mise en retrait dans l'écouteur que vous créez lors de l'implémentation de cette classe et rétablit la valeur `false` à la propriété NeedIndent. (Hérité de TraceListener)
WriteLine(Object)	Écrit la valeur de la méthode ToString() de l'objet dans l'écouteur que vous créez lors de l'implémentation de la classe TraceListener, suivie d'une marque de fin de ligne. (Hérité de TraceListener)
WriteLine(Object, String)	Écrit un nom de catégorie ou la valeur de la méthode ToString() de l'objet dans l'écouteur que vous créez lors de l'implémentation de la classe TraceListener, suivis d'une marque de fin de ligne. (Hérité de TraceListener)
WriteLine(String)	Écrit un message, suivi de la marque de fin de ligne actuelle, dans le fichier journal, sans fournir d'informations de contexte supplémentaires.
WriteLine(String, String)	Écrit un nom de catégorie ou un message dans l'écouteur que vous créez lors de l'implémentation de la classe TraceListener, suivis d'une marque de fin de ligne. (Hérité de TraceListener)

S’applique à