EventSchemaTraceListener Klasse

Referenz

Definition

Namespace:: System.Diagnostics

Assembly:: System.Core.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Leitet die Ablaufverfolgungs- oder Debugausgabe von End-to-End-Ereignissen an eine XML-codierte, schemakompatible Protokolldatei weiter.

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

public class EventSchemaTraceListener : System.Diagnostics.TextWriterTraceListener

type EventSchemaTraceListener = class
    inherit TextWriterTraceListener

Public Class EventSchemaTraceListener
Inherits TextWriterTraceListener

Vererbung: Object

MarshalByRefObject

TraceListener

TextWriterTraceListener
EventSchemaTraceListener

Beispiele

Im folgenden Codebeispiel wird die Verwendung der EventSchemaTraceListener -Klasse veranschaulicht.


///////////////////////////////////////////////////////////////////////
//
// 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

Hinweise

Die EventSchemaTraceListener -Klasse bietet die Ablaufverfolgung von End-to-End-schemakonformen Ereignissen. Sie können die End-to-End-Ablaufverfolgung für ein System mit heterogenen Komponenten verwenden, die Thread-, AppDomainProzess- und Computergrenzen überschreiten. Ein standardisiertes Ereignisschema ermöglicht die Ablaufverfolgung über diese Grenzen hinweg. Das Schema ermöglicht das Hinzufügen benutzerdefinierter, schemakonformer Elemente. Sie können das Service Trace Viewer-Tool (SvcTraceViewer.exe) verwenden, um die Ereignisdaten anzuzeigen.

EventSchemaTraceListener ist für die Protokollierungsleistung mit impliziter Unterstützung für die sperrfreie Ablaufverfolgung optimiert.

Die EventSchemaTraceListener -Klasse konvertiert Ablaufverfolgungs- und Debuginformationen in einen XML-codierten Textstream. Die Beschreibung der XML-Ausgabe wird in den Tabellen weiter unten in diesem Abschnitt angezeigt.

Sie können ein EventSchemaTraceListener Objekt im Code erstellen. Alternativ können Sie für .NET Framework-Apps ein Objekt über die Anwendungskonfigurationsdatei EventSchemaTraceListener aktivieren oder deaktivieren und dann das konfigurierte EventSchemaTraceListener Objekt in Ihrer Anwendung verwenden. Informationen zur Verwendung von Konfigurationsdateien für die Ablaufverfolgung und das Debuggen in .NET Framework-Apps finden Sie unter Schema der Ablaufverfolgungs- und Debugeinstellungen.

Um ein EventSchemaTraceListener Objekt in einer .NET Framework-App zu konfigurieren, ändern Sie die Konfigurationsdatei, die dem Namen Ihrer Anwendung entspricht. In dieser Datei können Sie die Eigenschaften für einen Listener hinzufügen, entfernen oder festlegen. Die Konfigurationsdatei sollte wie folgt formatiert sein:

<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>

Die EventSchemaTraceListener -Klasse erbt die Filter -Eigenschaft von der Basisklasse TraceListener. Die Filter -Eigenschaft ermöglicht eine zusätzliche Ebene der Ablaufverfolgungsausgabefilterung im Listener. Wenn ein Filter vorhanden ist, rufen die Trace Methoden des Ablaufverfolgungslisteners die ShouldTrace Methode des Filters auf, um zu bestimmen, ob die Ablaufverfolgung ausgegeben werden soll.

Wenn versucht wird, in eine Datei zu schreiben, die verwendet wird oder nicht verfügbar ist, wird dem Dateinamen automatisch ein GUID-Suffix hinzugefügt.

Hinweis

Listenermethoden sollen von Methoden der DebugKlassen , Traceund TraceSource aufgerufen werden. Rufen Sie die Listenermethoden nicht direkt aus Dem Anwendungscode auf. Der EventSchemaTraceListener Listener ist in erster Linie für die Verwendung durch die TraceSource -Klasse vorgesehen.

In der folgenden Tabelle werden die Elemente und Attribute der XML-Ausgabe beschrieben.

Element	Attribute	Ausgabe	Hinweise
`CallStack`	Keine	Hängt vom Vorhandensein des Flags Callstack in der TraceOutputOptions -Eigenschaft ab.	Sonderzeichen wie > oder < werden durch Escapesequenzen ersetzt. Sehen Sie sich die Escapezeichenübersetzungstabelle in der nächsten Tabelle an.
`Computer`	Keine	Immer vorhanden.	Dieses Element stellt den Wert der MachineName -Eigenschaft dar.
`Correlation`	`ActivityID`	Immer vorhanden.	Wenn `ActivityID` nicht angegeben ist, ist der Standardwert eine leere GUID.
	`RelatedActivityID`	Hängt vom Vorhandensein des `relatedActivityId` Parameters im `Trace` Methodenaufruf ab.	Das `RelatedActivityID` Attribut entspricht dem `relatedActivityId` Parameter der TraceTransfer -Methode.
`Data`	Keine	Immer vorhanden.	Dieses Element stellt die Parametereingabe (`data`) dar. Für jedes Datenobjekt wird ein Element bereitgestellt. Bei Ereignisprotokollen enthält das `Data` Element xml-Daten mit Escapezeichen. Im Fall von Datenprotokollen enthält das `Data` Element nicht gescapete Daten. Die Datenprotokollausgabe verwendet die `ToString` Methode der übergebenen Datenobjekte.
`Event`	Keine	Immer vorhanden.	Dieses Element enthält ein Ablaufverfolgungsereignis.
`EventData`	Keine	Für Ereignisprotokolle vorhanden.	Dieses Element stellt die Parametereingabe (`message`, `args`) dar. Sie enthält `Data` Elemente mit xml-Escapedaten, die durch Aufrufen der TraceEvent -Methode erstellt werden.
`EventID`	Keine	Immer vorhanden.	Dieses Element stellt die Parametereingabe (`id`) dar.
`Execution`	`ProcessID`	Hängt vom Vorhandensein des Flags ProcessId in der TraceOutputOptions -Eigenschaft ab.	Das `ProcessID` -Attribut wird in TraceEventCacheangegeben.
	`ThreadID`	Vorhanden, wenn `ProcessID` vorhanden ist.	Das `ThreadID` -Attribut wird in TraceEventCacheangegeben.
`Level`	Keine	Immer vorhanden.	Dieses Element stellt die Parametereingabe dar (der numerische Wert von `eventType`). Parameterwerte, die größer als 255 sind, werden als Ebene 8 ausgegeben, die darstellt TraceEventType.Information. Typen von Ablaufverfolgungsereignissen Critical, Error, Warning, Information, und Verbose werden Sie als Ebenen 1, 2, 4, 8 und 10, ausgegeben bzw.
`LogicalOperationStack`	Keine	Hängt vom Vorhandensein des Flags LogicalOperationStack in der TraceOutputOptions -Eigenschaft ab.	Es kann nur ein logischer Vorgang vorhanden sein. Daher werden die Werte als `LogicalOperation` Knoten unter dem `LogicalOperationStack` -Element geschrieben.
`OpCode`	Keine	Vorhanden, wenn `Level` größer als 255 ist.	Dieses Element stellt Ablaufverfolgungsereignistypen dar, die numerische Werte größer als 255 aufweisen. Start, Stop, Suspend, Resume, oder Transfer werden Sie als Ebenen 1, 2, 4, 8 und 10, ausgegeben bzw.
`Provider`	`GUID`	Immer vorhanden.	Immer leer.
`RenderingInfo`	`Culture`	Immer vorhanden.	Dieses Attribut stellt eine Ressourcenzeichenfolge für den Ereignistyp dar. Es ist immer "en-EN\".
`System`	`Name`	Immer vorhanden.
`TimeCreated`	`SystemTime`	Hängt vom Vorhandensein des Flags DateTime in der TraceOutputOptions -Eigenschaft ab.	Die Zeit ist der Wert der TraceEventCache.DateTime Eigenschaft. Diese Eigenschaft wird als koordinierte Weltzeit ausgedrückt.
`TimeStamp`	Keine	Hängt vom Vorhandensein des Flags Timestamp in der TraceOutputOptions -Eigenschaft ab.	Dieses Element wird in TraceEventCacheangegeben.
`UserData`	Keine	Für Datenprotokolle vorhanden.	Dieses Element enthält `Data` Elemente mit nicht vom Benutzer bereitgestellten Daten aus einer TraceData -Methode.

Die folgende Tabelle zeigt die Zeichen, die in der XML-Ausgabe mit Escapezeichen versehen werden. Escaping erfolgt in allen Elementen und Attributen mit Ausnahme des UserData Elements, das vom Benutzer bereitgestellte, nicht gescapete Daten enthält. Das UserData -Element ist das Ergebnis von Aufrufen der TraceData -Methode.

Escapezeichen	Wert
&	&
<	<
>	>
"	"
\|'
0xD
0xA

Konstruktoren

EventSchemaTraceListener(String)	Initialisiert eine neue Instanz der EventSchemaTraceListener-Klasse, wobei die angegebene Datei als Empfänger der Debug- oder Ablaufverfolgungsausgabe verwendet wird.
EventSchemaTraceListener(String, String)	Initialisiert eine neue Instanz der EventSchemaTraceListener-Klasse mit dem angegebenen Namen und unter Verwendung der angegebenen Datei als Empfänger der Debug- oder Ablaufverfolgungsausgabe.
EventSchemaTraceListener(String, String, Int32)	Initialisiert eine neue Instanz der EventSchemaTraceListener-Klasse mit dem angegebenen Namen und der angegebenen Puffergröße unter Verwendung der angegebenen Datei als Empfänger der Debug- oder Ablaufverfolgungsausgabe.
EventSchemaTraceListener(String, String, Int32, TraceLogRetentionOption)	Initialisiert eine neue Instanz der EventSchemaTraceListener-Klasse mit dem angegebenen Namen und der angegebenen Puffergröße unter Verwendung der angegebenen Datei mit der angegebenen Protokollbeibehaltungsrichtlinie als Empfänger der Debug- oder Ablaufverfolgungsausgabe.
EventSchemaTraceListener(String, String, Int32, TraceLogRetentionOption, Int64)	Initialisiert eine neue Instanz der EventSchemaTraceListener-Klasse mit dem angegebenen Namen und der angegebenen Puffergröße unter Verwendung der angegebenen Datei mit der angegebenen Protokollbeibehaltungsrichtlinie und der maximalen Größe als Empfänger der Debug- oder Ablaufverfolgungsausgabe.
EventSchemaTraceListener(String, String, Int32, TraceLogRetentionOption, Int64, Int32)	Initialisiert eine neue Instanz der EventSchemaTraceListener-Klasse mit dem angegebenen Namen und der angegebenen Puffergröße unter Verwendung der angegebenen Datei mit der angegebenen Protokollbeibehaltungsrichtlinie, der maximalen Größe und der Dateianzahl als Empfänger der Debug- oder Ablaufverfolgungsausgabe.

Eigenschaften

Attributes	Ruft die benutzerdefinierten Attribute für Ablaufverfolgungslistener ab, die in der Anwendungskonfigurationsdatei definiert sind. (Geerbt von TraceListener)
BufferSize	Ruft die Größe des Ausgabepuffers ab.
Filter	Ruft den Ablaufverfolgungsfilter für den Ablaufverfolgungslistener ab oder legt diesen fest. (Geerbt von TraceListener)
IndentLevel	Ruft die Einzugsebene ab oder legt diese fest. (Geerbt von TraceListener)
IndentSize	Ruft die Anzahl der Leerzeichen in einem Einzug ab oder legt diese fest. (Geerbt von TraceListener)
IsThreadSafe	Ruft einen Wert ab, der angibt, ob der Ablaufverfolgungslistener threadsicher ist.
MaximumFileSize	Ruft die maximale Größe der Protokolldatei ab.
MaximumNumberOfFiles	Ruft die maximale Anzahl von Protokolldateien ab.
Name	Ruft einen Namen für diesen TraceListener ab oder legt diesen fest. (Geerbt von TraceListener)
NeedIndent	Ruft einen Wert ab, der einen Einzug für die Ausgabe angibt, oder legt diesen fest. (Geerbt von TraceListener)
TraceLogRetentionOption	Ruft die Beibehaltungsoption für das Ablaufverfolgungsprotokoll der Datei ab.
TraceOutputOptions	Ruft die Optionen für die Ablaufverfolgungsausgabe ab oder legt diese fest. (Geerbt von TraceListener)
Writer	Ruft den zugrunde liegenden TextWriter ab, der in die Protokolldatei schreibt, oder legt diesen fest.

Methoden

Close()	Schließt die Protokolldatei für diesen Listener, sodass dieser keine Ablaufverfolgungs- oder Debugausgaben mehr empfängt.
CreateObjRef(Type)	Erstellt ein Objekt mit allen relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind. (Geerbt von MarshalByRefObject)
Dispose()	Gibt alle vom TraceListener verwendeten Ressourcen frei. (Geerbt von TraceListener)
Dispose(Boolean)	Gibt dieses TextWriterTraceListener-Objekt frei. (Geerbt von TextWriterTraceListener)
Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
Fail(String)	Gibt eine Fehlermeldung an den Listener aus, den Sie beim Implementieren der TraceListener-Klasse erstellen. (Geerbt von TraceListener)
Fail(String, String)	Schreibt Fehlerinformationen in die Protokolldatei, einschließlich einer einfachen Fehlermeldung und einer ausführlichen Fehlermeldung.
Flush()	Bewirkt, dass gepufferte Daten in das Protokoll für diesen Listener geschrieben werden.
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetLifetimeService()	Veraltet. Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert. (Geerbt von MarshalByRefObject)
GetSupportedAttributes()	Ruft die vom Ablaufverfolgungslistener unterstützten benutzerdefinierten XML-Konfigurationsattribute ab.
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
InitializeLifetimeService()	Veraltet. Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab. (Geerbt von MarshalByRefObject)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
MemberwiseClone(Boolean)	Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts. (Geerbt von MarshalByRefObject)
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)
TraceData(TraceEventCache, String, TraceEventType, Int32, Object)	Schreibt Ablaufverfolgungsinformationen, ein einzelnes Datenobjekt sowie Ereignisinformationen in die Protokolldatei.
TraceData(TraceEventCache, String, TraceEventType, Int32, Object[])	Schreibt Ablaufverfolgungsinformationen, mehrere Datenobjekte und Ereignisinformationen in die Protokolldatei.
TraceEvent(TraceEventCache, String, TraceEventType, Int32)	Schreibt Ablaufverfolgungs- und Ereignisinformationen in die spezifische Ausgabe des Listeners. (Geerbt von TraceListener)
TraceEvent(TraceEventCache, String, TraceEventType, Int32, String)	Schreibt Ablaufverfolgungsinformationen, eine Meldung und Ereignisinformationen in die Protokolldatei.
TraceEvent(TraceEventCache, String, TraceEventType, Int32, String, Object[])	Schreibt Ablaufverfolgungsinformationen, eine formatierte Meldung und Ereignisinformationen in die Protokolldatei.
TraceTransfer(TraceEventCache, String, Int32, String, Guid)	Schreibt Ablaufverfolgungsinformationen, darunter die Identität einer verwandten Aktivität, eine Meldung sowie Ereignisinformationen, in die Protokolldatei.
Write(Object)	Schreibt den Wert der ToString()-Methode des Objekts in den Listener, den Sie beim Implementieren der TraceListener-Klasse erstellen. (Geerbt von TraceListener)
Write(Object, String)	Schreibt einen Kategorienamen und den Wert der ToString()-Methode eines Objekts in den Listener, den Sie beim Implementieren der TraceListener-Klasse erstellen. (Geerbt von TraceListener)
Write(String)	Schreibt eine Meldung ohne weitere Kontextinformationen in die Protokolldatei.
Write(String, String)	Schreibt einen Kategorienamen und eine Meldung in den Listener, den Sie beim Implementieren der TraceListener-Klasse erstellen. (Geerbt von TraceListener)
WriteIndent()	Schreibt den Einzug in den Listener, den sie bei der Implementierung dieser Klasse erstellen, und setzt die NeedIndent-Eigenschaft auf `false` zurück. (Geerbt von TraceListener)
WriteLine(Object)	Schreibt den Wert der ToString()-Methode des Objekts gefolgt von einem Zeilenabschluss in den Listener, den Sie beim Implementieren der TraceListener-Klasse erstellen. (Geerbt von TraceListener)
WriteLine(Object, String)	Schreibt einen Kategorienamen und den Wert der ToString()-Methode eines Objekts gefolgt von einem Zeilenabschluss in den Listener, den Sie beim Implementieren der TraceListener-Klasse erstellen. (Geerbt von TraceListener)
WriteLine(String)	Schreibt eine Meldung, gefolgt vom Abschlusszeichen der aktuellen Zeile und ohne weitere Kontextinformationen in die Protokolldatei.
WriteLine(String, String)	Schreibt einen Kategorienamen und eine Meldung gefolgt von einem Zeilenabschluss in den Listener, den Sie beim Implementieren der TraceListener-Klasse erstellen. (Geerbt von TraceListener)

Gilt für:

Freigeben über