TraceSource Classe

Définition

Fournit un jeu de méthodes et de propriétés qui permet aux applications d'effectuer le suivi de l'exécution du code et des messages de trace associés à leur source.Provides a set of methods and properties that enable applications to trace the execution of code and associate trace messages with their source.

public ref class TraceSource
public class TraceSource
type TraceSource = class
Public Class TraceSource
Héritage
TraceSource

Exemples

L’exemple de code suivant illustre l’utilisation de la classe TraceSource pour transférer les traces aux écouteurs.The following code example shows the use of the TraceSource class to forward traces to listeners. L’exemple illustre également l’utilisation des commutateurs et des filtres.The example also demonstrates switch and filter usage.

/////////////////////////////////////////////////////////////////////////////////
//
// NAME     TraceSource2.cpp : main project file
//
/////////////////////////////////////////////////////////////////////////////////



// The following configuration file can be used with this sample.
// When using a configuration file #define ConfigFile.
//            <source name="TraceTest" switchName="SourceSwitch" switchType="System.Diagnostics.SourceSwitch" >
//                    <add name="console" type="System.Diagnostics.ConsoleTraceListener" initializeData="false" />
//                    <remove name ="Default" />
//            <!-- You can set the level at which tracing is to occur -->
//            <add name="SourceSwitch" value="Warning" />
//            <!-- You can turn tracing off -->
//            <!--add name="SourceSwitch" value="Off" -->
//        <trace autoflush="true" indentsize="4"></trace>

#define TRACE
//#define ConfigFile

#using <System.dll>

using namespace System;
using namespace System::Collections;
using namespace System::Diagnostics;
using namespace System::Reflection;
using namespace System::IO;
using namespace System::Security::Permissions;

void DisplayProperties(TraceSource^ ts);  // Forward Declaration


int main()
{
    TraceSource^ ts = gcnew TraceSource("TraceTest");

    try
        {
        // Initialize trace switches.
#if(!ConfigFile)
        SourceSwitch^ sourceSwitch = gcnew SourceSwitch("SourceSwitch", "Verbose");
        ts->Switch = sourceSwitch;
        int idxConsole = ts->Listeners->Add(gcnew System::Diagnostics::ConsoleTraceListener());
        ts->Listeners[idxConsole]->Name = "console";
#endif
        DisplayProperties(ts);
        ts->Listeners["console"]->TraceOutputOptions |= TraceOptions::Callstack;
        ts->TraceEvent(TraceEventType::Warning, 1);
        ts->Listeners["console"]->TraceOutputOptions = TraceOptions::DateTime;
        // Issue file not found message as a warning.
        ts->TraceEvent(TraceEventType::Warning, 2, "File Test not found");
        // Issue file not found message as a verbose event using a formatted string.
        ts->TraceEvent(TraceEventType::Verbose, 3, "File {0} not found.", "test");
        // Issue file not found message as information.
        ts->TraceInformation("File {0} not found.", "test");
        ts->Listeners["console"]->TraceOutputOptions |= TraceOptions::LogicalOperationStack;
        // Issue file not found message as an error event.
        ts->TraceEvent(TraceEventType::Error, 4, "File {0} not found.", "test");

        // Test the filter on the ConsoleTraceListener.
        ts->Listeners["console"]->Filter = gcnew SourceFilter("No match");
        ts->TraceData(TraceEventType::Error, 5,
            "SourceFilter should reject this message for the console trace listener.");
        ts->Listeners["console"]->Filter = gcnew SourceFilter("TraceTest");
        ts->TraceData(TraceEventType::Error, 6,
            "SourceFilter should let this message through on the console trace listener.");
        ts->Listeners["console"]->Filter = nullptr;

        // Use the TraceData method. 
        ts->TraceData(TraceEventType::Warning, 7, gcnew array<Object^>{ "Message 1", "Message 2" });

        // Activity tests.
        ts->TraceEvent(TraceEventType::Start, 9, "Will not appear until the switch is changed.");
        ts->Switch->Level = SourceLevels::ActivityTracing | SourceLevels::Critical;
        ts->TraceEvent(TraceEventType::Suspend, 10, "Switch includes ActivityTracing, this should appear");
        ts->TraceEvent(TraceEventType::Critical, 11, "Switch includes Critical, this should appear");
        ts->Flush();
        ts->Close();
        Console::WriteLine("Press enter key to exit.");
        Console::Read();
        }
    catch (Exception ^e)
        {
         // Catch any unexpected exception.
         Console::WriteLine("Unexpected exception: " + e->ToString());
         Console::Read();
        }
}


void DisplayProperties(TraceSource^ ts)
{
    Console::WriteLine("TraceSource name = " + ts->Name);
//    Console::WriteLine("TraceSource switch level = " + ts->Switch->Level);         // error C3063: operator '+': all operands must have the same enumeration type
    Console::WriteLine("TraceSource switch level = {0}", ts->Switch->Level);         //  SUCCESS:  does compile.  Weird
    Console::WriteLine("TraceSource Attributes Count " + ts->Attributes->Count);     //  SUCCESS:  also compiles.  Really weird
    Console::WriteLine("TraceSource Attributes Count = {0}", ts->Attributes->Count); //  SUCCESS:  okay, I give up.  Somebody call me a cab.

    Console::WriteLine("TraceSource switch = " + ts->Switch->DisplayName);
    array<SwitchAttribute^>^ switches = SwitchAttribute::GetAll(TraceSource::typeid->Assembly);

    for (int i = 0; i < switches->Length; i++)
        { 
        Console::WriteLine("Switch name = " + switches[i]->SwitchName);
        Console::WriteLine("Switch type = " + switches[i]->SwitchType);
        }

#if(ConfigFile)
            // Get the custom attributes for the TraceSource.
            Console::WriteLine("Number of custom trace source attributes = "
                + ts.Attributes.Count);
            foreach (DictionaryEntry de in ts.Attributes)
                Console::WriteLine("Custom trace source attribute = "
                    + de.Key + "  " + de.Value);
            // Get the custom attributes for the trace source switch.
            foreach (DictionaryEntry de in ts.Switch.Attributes)
                Console::WriteLine("Custom switch attribute = "
                    + de.Key + "  " + de.Value);
#endif
       Console::WriteLine("Number of listeners = " + ts->Listeners->Count);
       for each (TraceListener ^ traceListener in ts->Listeners)
           {
           Console::Write("TraceListener: " + traceListener->Name + "\t");
           // The following output can be used to update the configuration file.
           Console::WriteLine("AssemblyQualifiedName = " +
               (traceListener->GetType()->AssemblyQualifiedName));
           }
}
// The following configuration file can be used with this sample.
// When using a configuration file #define ConfigFile.
//            <source name="TraceTest" switchName="SourceSwitch" switchType="System.Diagnostics.SourceSwitch" >
//                    <add name="console" type="System.Diagnostics.ConsoleTraceListener" initializeData="false" />
//                    <remove name ="Default" />
//            <!-- You can set the level at which tracing is to occur -->
//            <add name="SourceSwitch" value="Warning" />
//            <!-- You can turn tracing off -->
//            <!--add name="SourceSwitch" value="Off" -->
//        <trace autoflush="true" indentsize="4"></trace>
#define TRACE
//#define ConfigFile

using System;
using System.Collections;
using System.Diagnostics;
using System.Reflection;
using System.IO;
using System.Security.Permissions;

namespace Testing
{
    class TraceTest
    {
        // Initialize the trace source.
        static TraceSource ts = new TraceSource("TraceTest");
        [SwitchAttribute("SourceSwitch", typeof(SourceSwitch))]
        static void Main()
        {
            try
            {
                // Initialize trace switches.
#if(!ConfigFile)
                SourceSwitch sourceSwitch = new SourceSwitch("SourceSwitch", "Verbose");
                ts.Switch = sourceSwitch;
                int idxConsole = ts.Listeners.Add(new System.Diagnostics.ConsoleTraceListener());
                ts.Listeners[idxConsole].Name = "console";
#endif
                DisplayProperties(ts);
                ts.Listeners["console"].TraceOutputOptions |= TraceOptions.Callstack;
                ts.TraceEvent(TraceEventType.Warning, 1);
                ts.Listeners["console"].TraceOutputOptions = TraceOptions.DateTime;
                // Issue file not found message as a warning.
                ts.TraceEvent(TraceEventType.Warning, 2, "File Test not found");
                // Issue file not found message as a verbose event using a formatted string.
                ts.TraceEvent(TraceEventType.Verbose, 3, "File {0} not found.", "test");
                // Issue file not found message as information.
                ts.TraceInformation("File {0} not found.", "test");
                ts.Listeners["console"].TraceOutputOptions |= TraceOptions.LogicalOperationStack;
                // Issue file not found message as an error event.
                ts.TraceEvent(TraceEventType.Error, 4, "File {0} not found.", "test");
                // Test the filter on the ConsoleTraceListener.
                ts.Listeners["console"].Filter = new SourceFilter("No match");
                ts.TraceData(TraceEventType.Error, 5,
                    "SourceFilter should reject this message for the console trace listener.");
                ts.Listeners["console"].Filter = new SourceFilter("TraceTest");
                ts.TraceData(TraceEventType.Error, 6,
                    "SourceFilter should let this message through on the console trace listener.");
                ts.Listeners["console"].Filter = null;
                // Use the TraceData method.
                ts.TraceData(TraceEventType.Warning, 7, new object());
                ts.TraceData(TraceEventType.Warning, 8, new object[] { "Message 1", "Message 2" });
                // Activity tests.
                ts.TraceEvent(TraceEventType.Start, 9, "Will not appear until the switch is changed.");
                ts.Switch.Level = SourceLevels.ActivityTracing | SourceLevels.Critical;
                ts.TraceEvent(TraceEventType.Suspend, 10, "Switch includes ActivityTracing, this should appear");
                ts.TraceEvent(TraceEventType.Critical, 11, "Switch includes Critical, this should appear");
                ts.Flush();
                ts.Close();
                Console.WriteLine("Press any key to exit.");
                Console.Read();
            }
            catch (Exception e)
            {
                // Catch any unexpected exception.
                Console.WriteLine("Unexpected exception: " + e.ToString());
                Console.Read();
            }
        }
        public static void DisplayProperties(TraceSource ts)
        {
            Console.WriteLine("TraceSource name = " + ts.Name);
            Console.WriteLine("TraceSource switch level = " + ts.Switch.Level);
            Console.WriteLine("TraceSource switch = " + ts.Switch.DisplayName);
            SwitchAttribute[] switches = SwitchAttribute.GetAll(typeof(TraceTest).Assembly);
            for (int i = 0; i < switches.Length; i++)
            {
                Console.WriteLine("Switch name = " + switches[i].SwitchName);
                Console.WriteLine("Switch type = " + switches[i].SwitchType);
            }
#if(ConfigFile)
            // Get the custom attributes for the TraceSource.
            Console.WriteLine("Number of custom trace source attributes = "
                + ts.Attributes.Count);
            foreach (DictionaryEntry de in ts.Attributes)
                Console.WriteLine("Custom trace source attribute = "
                    + de.Key + "  " + de.Value);
            // Get the custom attributes for the trace source switch.
            foreach (DictionaryEntry de in ts.Switch.Attributes)
                Console.WriteLine("Custom switch attribute = "
                    + de.Key + "  " + de.Value);
#endif
            Console.WriteLine("Number of listeners = " + ts.Listeners.Count);
            foreach (TraceListener traceListener in ts.Listeners)
            {
                Console.Write("TraceListener: " + traceListener.Name + "\t");
                // The following output can be used to update the configuration file.
                Console.WriteLine("AssemblyQualifiedName = " +
                    (traceListener.GetType().AssemblyQualifiedName));
            }
        }
    }
}
' The following configuration file can be used with this sample.
' When using a configuration file #define ConfigFile.
'            <source name="TraceTest" switchName="SourceSwitch" switchType="System.Diagnostics.SourceSwitch" >
'                    <add name="console" type="System.Diagnostics.ConsoleTraceListener" initializeData="false" />
'                    <remove name ="Default" />
'            <!-- You can set the level at which tracing is to occur -->
'            <add name="SourceSwitch" value="Warning" />
'            <!-- You can turn tracing off -->
'            <!--add name="SourceSwitch" value="Off" -->
'        <trace autoflush="true" indentsize="4"></trace>
#Const TRACE = True
'#Const ConfigFile = True

Imports System.Collections
Imports System.Diagnostics
Imports System.Reflection
Imports System.IO
Imports System.Security.Permissions



Class TraceTest
    ' Initialize the trace source.
    Private Shared ts As New TraceSource("TraceTest")
    <SwitchAttribute("SourceSwitch", GetType(SourceSwitch))> _
    Shared Sub Main()
        Try
            ' Initialize trace switches.
#If (ConfigFile = False) Then
            Dim sourceSwitch As New SourceSwitch("SourceSwitch", "Verbose")
            ts.Switch = sourceSwitch
            Dim idxConsole As New Integer()
            idxConsole = ts.Listeners.Add(New System.Diagnostics.ConsoleTraceListener())
            ts.Listeners(idxConsole).Name = "console"
#End If
            DisplayProperties(ts)
            ts.Listeners("console").TraceOutputOptions = ts.Listeners("console").TraceOutputOptions Or TraceOptions.Callstack
            ts.TraceEvent(TraceEventType.Warning, 1)
            ts.Listeners("console").TraceOutputOptions = TraceOptions.DateTime
            ' Issue file not found message as a warning.
            ts.TraceEvent(TraceEventType.Warning, 2, "File Test not found")
            ' Issue file not found message as a verbose event using a formatted string.
            ts.TraceEvent(TraceEventType.Verbose, 3, "File {0} not found.", "test")
            ' Issue file not found message as information.
            ts.TraceInformation("File {0} not found.", "test")
            ts.Listeners("console").TraceOutputOptions = ts.Listeners("console").TraceOutputOptions Or TraceOptions.LogicalOperationStack
            ' Issue file not found message as an error event.
            ts.TraceEvent(TraceEventType.Error, 4, "File {0} not found.", "test")
            ' Test the filter on the ConsoleTraceListener.
            ts.Listeners("console").Filter = New SourceFilter("No match")
            ts.TraceData(TraceEventType.Error, 5, "SourceFilter should reject this message for the console trace listener.")
            ts.Listeners("console").Filter = New SourceFilter("TraceTest")
            ts.TraceData(TraceEventType.Error, 6, "SourceFilter should let this message through on the console trace listener.")
            ts.Listeners("console").Filter = Nothing
            ' Use the TraceData method. 
            ts.TraceData(TraceEventType.Warning, 7, New Object())
            ts.TraceData(TraceEventType.Warning, 8, New Object() {"Message 1", "Message 2"})
            ' Activity tests.
            ts.TraceEvent(TraceEventType.Start, 9, "Will not appear until the switch is changed.")
            ts.Switch.Level = SourceLevels.ActivityTracing Or SourceLevels.Critical
            ts.TraceEvent(TraceEventType.Suspend, 10, "Switch includes ActivityTracing, this should appear")
            ts.TraceEvent(TraceEventType.Critical, 11, "Switch includes Critical, this should appear")
            ts.Flush()
            ts.Close()
            Console.WriteLine("Press any key to exit.")
            Console.Read()
        Catch e As Exception
            ' Catch any unexpected exception.
            Console.WriteLine("Unexpected exception: " + e.ToString())
            Console.Read()
        End Try

    End Sub

    Public Shared Sub DisplayProperties(ByVal ts As TraceSource)
        Console.WriteLine("TraceSource name = " + ts.Name)
        Console.WriteLine("TraceSource switch level = " + ts.Switch.Level.ToString())
        Console.WriteLine("TraceSource switch = " + ts.Switch.DisplayName.ToString())
        Dim switches As SwitchAttribute() = SwitchAttribute.GetAll(GetType(TraceTest).Assembly)
        Dim i As Integer
        For i = 0 To switches.Length - 1
            Console.WriteLine("Switch name = " + switches(i).SwitchName.ToString())
            Console.WriteLine("Switch type = " + switches(i).SwitchType.ToString())
        Next i

#If (ConfigFile) Then
        ' Get the custom attributes for the TraceSource.
        Console.WriteLine("Number of custom trace source attributes = " + ts.Attributes.Count)
        Dim de As DictionaryEntry
        For Each de In ts.Attributes
            Console.WriteLine("Custom trace source attribute = " + de.Key + "  " + de.Value)
        Next de
        ' Get the custom attributes for the trace source switch.
        For Each de In ts.Switch.Attributes
            Console.WriteLine("Custom switch attribute = " + de.Key + "  " + de.Value)
        Next de
#End If
        Console.WriteLine("Number of listeners = " + ts.Listeners.Count.ToString())
        Dim traceListener As TraceListener
        For Each traceListener In ts.Listeners
            Console.Write("TraceListener: " + traceListener.Name + vbTab)
            ' The following output can be used to update the configuration file.
            Console.WriteLine("AssemblyQualifiedName = " + traceListener.GetType().AssemblyQualifiedName)
        Next traceListener

    End Sub
End Class

Remarques

La classe TraceSource est utilisée par les applications pour produire des traces qui peuvent être associées à l'application.The TraceSource class is used by applications to produce traces that can be associated with the application. TraceSource fournit des méthodes de traçage qui vous permettent de tracer facilement des événements et des données, ainsi que de fournir des traces d'information.TraceSource provides tracing methods that allow you to easily trace events, trace data, and issue informational traces. La sortie de trace de TraceSource peut être contrôlée par les paramètres du fichier de configuration.Trace output from TraceSource can be controlled by configuration file settings. Le fichier de configuration se trouve dans le dossier avec l’exécutable de l’application et porte le nom de l’application avec l’extension de nom de fichier. config ajoutée.The configuration file is located in the folder with the application executable and has the name of the application with the .config file name extension added. Par exemple, le nom du fichier de configuration pour TraceSourceSample. exe est TraceSourceSample. exe. config. Le fichier de configuration peut être utilisé pour déterminer où les informations de trace doivent être envoyées et quels niveaux d’activité doivent être suivis.For example, the name of the configuration file for TraceSourceSample.exe is TraceSourceSample.exe.config. The configuration file can be used to determine where the trace information is to be sent and what levels of activity are to be traced. L’exemple suivant montre le contenu d’un exemple de fichier de configuration de l’application.The following example shows the contents of a sample application configuration file.

<configuration>  
  <system.diagnostics>  
    <sources>  
      <source name="TraceTest" switchName="SourceSwitch"   
        switchType="System.Diagnostics.SourceSwitch" >  
        <listeners>  
          <add name="console" />  
          <remove name ="Default" />  
        </listeners>  
      </source>  
    </sources>  
    <switches>  
      <!-- You can set the level at which tracing is to occur -->  
      <add name="SourceSwitch" value="Warning" />  
        <!-- You can turn tracing off -->  
        <!--add name="SourceSwitch" value="Off" -->  
    </switches>  
    <sharedListeners>  
      <add name="console"   
        type="System.Diagnostics.ConsoleTraceListener"   
        initializeData="false"/>  
    </sharedListeners>  
    <trace autoflush="true" indentsize="4">  
      <listeners>  
        <add name="console" />  
      </listeners>  
    </trace>  
  </system.diagnostics>  
</configuration>  

La classe TraceSource est identifiée par le nom d’une source, en général le nom de l’application.The TraceSource class is identified by the name of a source, typically the name of the application. Les messages de suivi provenant d’un composant particulier peuvent être initiés par une source de suivi particulière, ce qui permet d’identifier facilement tous les messages provenant de ce composant.The trace messages coming from a particular component can be initiated by a particular trace source, allowing all messages coming from that component to be easily identified.

TraceSource définit des méthodes de traçage, mais ne fournit pas réellement de mécanisme spécifique pour la génération et le stockage des données de suivi.TraceSource defines tracing methods but does not actually provide any specific mechanism for generating and storing tracing data. Les données de suivi sont produites par les écouteurs de la trace, qui sont des plug-ins qui peuvent être chargés par les sources de suivi.The tracing data is produced by trace listeners, which are plug-ins that can be loaded by trace sources.

Notes

Vous ne devez pas appeler les méthodes de suivi pendant la finalisation.You should not call the tracing methods during finalization. Cela peut entraîner la levée d’une ObjectDisposedException.Doing so can result in an ObjectDisposedException being thrown.

Vous pouvez personnaliser la cible de la sortie de traçage en ajoutant ou en supprimant des instances de TraceListener vers ou à partir de la collection stockée dans la propriété TraceSource.Listeners.You can customize the tracing output's target by adding or removing TraceListener instances to or from the collection stored in the TraceSource.Listeners property. Par défaut, la sortie de trace est générée à l’aide d’une instance de la classe DefaultTraceListener.By default, trace output is produced using an instance of the DefaultTraceListener class. L’exemple de fichier de configuration précédent montre la suppression de l' DefaultTraceListener et l’ajout d’une ConsoleTraceListener pour produire la sortie de trace pour la source de suivi.The preceding configuration file example demonstrates removing the DefaultTraceListener and adding a ConsoleTraceListener to produce the trace output for the trace source. Pour plus d’informations, consultez <des écouteurs> et <sharedListeners>.For more information, see <listeners> and <sharedListeners>.

Notes

L’ajout d’un écouteur de suivi à la collection Listeners peut provoquer la levée d’une exception lors du traçage, si une ressource utilisée par l’écouteur de la trace n’est pas disponible.Adding a trace listener to the Listeners collection can cause an exception to be thrown while tracing, if a resource used by the trace listener is not available. Les conditions et l’exception levée dépendent de l’écouteur de suivi et ne peuvent pas être énumérées dans cette rubrique.The conditions and the exception thrown depend on the trace listener and cannot be enumerated in this topic. Il peut être utile de placer les appels aux méthodes TraceSource dans try/catch les blocs pour détecter et gérer les exceptions des écouteurs de suivi.It may be useful to place calls to the TraceSource methods in try/catch blocks to detect and handle any exceptions from trace listeners.

La classe SourceSwitch fournit les moyens de contrôler dynamiquement la sortie de traçage.The SourceSwitch class provides the means to dynamically control the tracing output. L’exemple de fichier de configuration précédent montre comment vous pouvez désactiver le suivi à partir d’une source de suivi et contrôler le niveau auquel le suivi se produit.The preceding configuration file example shows how you can turn off tracing from a trace source and control the level at which tracing occurs. Vous pouvez modifier la valeur du commutateur source sans recompiler votre application.You can modify the value of the source switch without recompiling your application. Pour plus d’informations sur l’utilisation du fichier de configuration pour définir un commutateur, consultez Switch et Comment : créer, initialiser et configurer des commutateurs de trace.For information on using the configuration file to set a switch, see Switch and How to: Create, Initialize and Configure Trace Switches.

Notes

Si vous modifiez un fichier de configuration alors qu’une application est en cours d’exécution, l’application doit être arrêtée et redémarrée, ou la méthode Refresh doit être appelée avant que les nouveaux paramètres prennent effet.If you modify a configuration file while an application is executing, the application must be stopped and restarted or the Refresh method must be called before the new settings take effect.

L’énumération TraceEventType est utilisée pour définir le type d’événement du message de trace.The TraceEventType enumeration is used to define the event type of the trace message. Les filtres de trace utilisent la TraceEventType pour déterminer si un écouteur de suivi doit produire le message de trace.Trace filters use the TraceEventType to determine if a trace listener should produce the trace message.

Les écouteurs de la trace peuvent éventuellement avoir une couche supplémentaire de filtrage par le biais d’un filtre de trace.The trace listeners can optionally have an additional layer of filtering through a trace filter. Si un écouteur de suivi est associé à un filtre, l’écouteur appelle la méthode ShouldTrace sur ce filtre pour déterminer s’il doit ou non produire les informations de trace.If a trace listener has an associated filter, the listener calls the ShouldTrace method on that filter to determine whether or not to produce the trace information.

Les écouteurs de la trace utilisent les valeurs des propriétés de la classe Trace Indent, IndentSizeet AutoFlush pour mettre en forme la sortie de suivi.The trace listeners use the values of the Trace class properties Indent, IndentSize, and AutoFlush to format trace output. Vous pouvez utiliser les attributs du fichier de configuration pour définir les propriétés Indent, IndentSizeet AutoFlush.You can use configuration file attributes to set the Indent, IndentSize, and AutoFlush properties. L’exemple suivant affecte la valeur false à la propriété AutoFlush et la valeur 3 à la propriété IndentSize.The following example sets the AutoFlush property to false and the IndentSize property to 3.

<configuration>  
  <system.diagnostics>  
    <trace autoflush="false" indentsize="3" />  
  </system.diagnostics>  
</configuration>  

Constructeurs

TraceSource(String)

Initialise une nouvelle instance de la classe TraceSource à l'aide du nom spécifié pour la source.Initializes a new instance of the TraceSource class, using the specified name for the source.

TraceSource(String, SourceLevels)

Initialise une nouvelle instance de la classe TraceSource à l'aide du nom spécifié pour la source et du niveau de la source par défaut où le traçage doit se produire.Initializes a new instance of the TraceSource class, using the specified name for the source and the default source level at which tracing is to occur.

Propriétés

Attributes

Obtient les attributs de commutateur personnalisés définis dans le fichier de configuration de l'application.Gets the custom switch attributes defined in the application configuration file.

Listeners

Obtient la collection des écouteurs de la trace pour la source de trace.Gets the collection of trace listeners for the trace source.

Name

Obtient le nom de la source de trace.Gets the name of the trace source.

Switch

Obtient ou définit la valeur du commutateur source.Gets or sets the source switch value.

Méthodes

Close()

Ferme tous les écouteurs de la trace dans la collection d’écouteurs de la trace.Closes all the trace listeners in the trace listener collection.

Equals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
Flush()

Vide tous les écouteurs de la trace dans la collection d’écouteurs de la trace.Flushes all the trace listeners in the trace listener collection.

GetHashCode()

Fait office de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetSupportedAttributes()

Obtient les attributs personnalisés pris en charge par la source de la trace.Gets the custom attributes supported by the trace source.

GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
ToString()

Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object.

(Hérité de Object)
TraceData(TraceEventType, Int32, Object)

Écrit les données de trace dans les écouteurs de la trace de la collection Listeners à l'aide du type d'événement spécifié, de l'identificateur d'événement et des données de trace.Writes trace data to the trace listeners in the Listeners collection using the specified event type, event identifier, and trace data.

TraceData(TraceEventType, Int32, Object[])

Écrit les données de trace dans les écouteurs de la trace de la collection Listeners à l’aide du type d’événement spécifié, de l’identificateur d’événement et des données de trace.Writes trace data to the trace listeners in the Listeners collection using the specified event type, event identifier, and trace data array.

TraceEvent(TraceEventType, Int32)

Écrit un message d’événement de trace dans les écouteurs de la trace de la collection Listeners à l’aide du type d’événement spécifié et de l’identificateur d’événement.Writes a trace event message to the trace listeners in the Listeners collection using the specified event type and event identifier.

TraceEvent(TraceEventType, Int32, String)

Écrit un message d’événement de trace dans les écouteurs de la trace de la collection Listeners à l’aide du type d’événement spécifié, de l’identificateur d’événement et du message.Writes a trace event message to the trace listeners in the Listeners collection using the specified event type, event identifier, and message.

TraceEvent(TraceEventType, Int32, String, Object[])

Écrit un événement de trace dans les écouteurs de la trace de la collection Listeners à l’aide du type d’événement spécifié, de l’identificateur d’événement, du tableau des arguments et du format.Writes a trace event to the trace listeners in the Listeners collection using the specified event type, event identifier, and argument array and format.

TraceInformation(String)

Écrit un message d’information dans les écouteurs de la trace de la collection Listeners à l’aide du message spécifié.Writes an informational message to the trace listeners in the Listeners collection using the specified message.

TraceInformation(String, Object[])

Écrit un message d'information dans les écouteurs de la trace de la collection Listeners à l'aide du tableau spécifié d'objets et des informations de mise en forme.Writes an informational message to the trace listeners in the Listeners collection using the specified object array and formatting information.

TraceTransfer(Int32, String, Guid)

Écrit un message de transfert de la trace dans les écouteurs de traçage de la collection Listeners à l'aide de l'identificateur numérique spécifié, du message et de l'identificateur d'activité connexe.Writes a trace transfer message to the trace listeners in the Listeners collection using the specified numeric identifier, message, and related activity identifier.

S’applique à

Cohérence de thread

Ce type est thread-safe.This type is thread safe.

Voir aussi