EventSchemaTraceListener Klasse

Definition

Leitet die Ablaufverfolgungs- oder Debugausgabe von End-to-End-Ereignissen an eine XML-codierte, schemakompatible Protokolldatei weiter.Directs tracing or debugging output of end-to-end events to an XML-encoded, schema-compliant log file.

public ref class EventSchemaTraceListener : System::Diagnostics::TextWriterTraceListener
public class EventSchemaTraceListener : System.Diagnostics.TextWriterTraceListener
type EventSchemaTraceListener = class
    inherit TextWriterTraceListener
Public Class EventSchemaTraceListener
Inherits TextWriterTraceListener
Vererbung

Beispiele

Im folgenden Codebeispiel wird die Verwendung der EventSchemaTraceListener -Klasse veranschaulicht.The following code example demonstrates how to use the EventSchemaTraceListener class.


///////////////////////////////////////////////////////////////////////
//
// 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 stellt die Ablauf Verfolgung von End-to-End-Schema kompatiblen Ereignissen bereit.The EventSchemaTraceListener class provides tracing of end-to-end schema-compliant events. Sie können die End-to-End-Ablauf Verfolgung für ein System mit heterogenen Komponenten verwenden, AppDomaindie Thread-, Prozess-und Computer Grenzen überschreiten.You can use end-to-end tracing for a system that has heterogeneous components that cross thread, AppDomain, process, and computer boundaries. Ein standardisiertes Ereignis Schema (siehe Ereignis Darstellung fürEreignisconsumer) wurde definiert, um die Ablauf Verfolgung über diese Grenzen hinweg zu ermöglichen.A standardized event schema (see Event Representation for Event Consumers) has been defined to enable tracing across these boundaries. Das Schema ermöglicht das Hinzufügen von benutzerdefinierten, Schema kompatiblen Elementen.The schema enables the addition of custom, schema-compliant elements. Sie können das Service Trace Viewer-Tool (SvcTraceViewer. exe) verwenden, um die Ereignisdaten anzuzeigen.You can use the Service Trace Viewer Tool (SvcTraceViewer.exe) to display the event data.

EventSchemaTraceListenerwird für die Protokollierung der Leistung mit impliziter Unterstützung für die Ablauf Verfolgung ohne Sperre optimiertEventSchemaTraceListener is tuned for logging performance with implicit support for lock-free tracing.

Die EventSchemaTraceListener -Klasse konvertiert Ablaufverfolgungs-und Debuginformationen in einen XML-codierten Textstream.The EventSchemaTraceListener class converts tracing and debugging information into an XML-encoded text stream. Die Beschreibung der XML-Ausgabe wird in den Tabellen weiter unten in diesem Abschnitt angezeigt.The description of the XML output is shown in the tables later in this section.

Sie können ein EventSchemaTraceListener Objekt über die Anwendungs Konfigurationsdatei aktivieren oder deaktivieren und dann das konfigurierte EventSchemaTraceListener Objekt in der Anwendung verwenden.You can enable or disable an EventSchemaTraceListener object through the application configuration file, and then use the configured EventSchemaTraceListener object in your application. Alternativ können Sie ein EventSchemaTraceListener Objekt im Code erstellen.Alternately, you can create an EventSchemaTraceListener object in your code. Es wird empfohlen, Ablaufverfolgungslistener über die Anwendungs Konfigurationsdatei zu aktivierenWe recommend that you enable trace listeners through the application configuration file. Informationen zur Verwendung von Konfigurationsdateien für die Ablauf Verfolgung und das Debuggen finden Sie unter Schema für Ablauf Verfolgungs -und Debugeinstellungen.For information about the use of configuration files for tracing and debugging, see Trace and Debug Settings Schema.

Um ein EventSchemaTraceListener Objekt zu konfigurieren, ändern Sie die Konfigurationsdatei, die dem Namen der Anwendung entspricht.To configure an EventSchemaTraceListener object, modify the configuration file that corresponds to the name of your application. In dieser Datei können Sie die Eigenschaften für einen Listener hinzufügen, entfernen oder festlegen.In this file, you can add, remove, or set the properties for a listener. Die Konfigurationsdatei sollte wie folgt formatiert werden:The configuration file should be formatted as follows:

<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 Filter die-Eigenschaft von der TraceListenerBasisklasse.The EventSchemaTraceListener class inherits the Filter property from the base class TraceListener. Die Filter -Eigenschaft ermöglicht eine zusätzliche Ebene der Ablauf Verfolgungs Ausgabe Filterung beim Listener.The Filter property allows for an additional level of trace output filtering at the listener. Wenn ein Filter vorhanden ist, wird Trace die- ShouldTrace Methode des-Ablaufverfolgungslistener aufgerufen, um zu bestimmen, ob die Ablauf Verfolgung ausgegeben werden soll.If a filter is present, the Trace methods of the trace listener call the ShouldTrace method of the filter to determine whether to emit the trace.

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.If an attempt is made to write to a file that is being used or is unavailable, a GUID suffix is automatically added to the file name.

Hinweis

Listenermethoden sollen von Methoden der DebugKlassen, Traceund TraceSource aufgerufen werden.Listener methods are intended to be called by methods of the Debug, Trace, and TraceSource classes. Die Listenermethoden können nicht direkt aus dem Anwendungscode aufgerufen werden.Do not call the listener methods directly from application code. Der EventSchemaTraceListener Listener ist hauptsächlich für die Verwendung durch TraceSource die-Klasse bestimmt.The EventSchemaTraceListener listener is primarily intended for use by the TraceSource class.

In der folgenden Tabelle werden die Elemente und Attribute der XML-Ausgabe beschrieben.The following table describes the elements and attributes of the XML output.

ElementElement AttributeAttributes AusgabeOutput HinweiseNotes
CallStack KeineNone Hängt davon ab, ob das Callstack -Flag in TraceOutputOptions der-Eigenschaft vorhanden ist.Depends on the presence of the Callstack flag in the TraceOutputOptions property. Sonderzeichen, z. b. > oder <, werden durch Escapesequenzen ersetzt.Special characters such as > or < are replaced with escape sequences. Siehe die Zeichen Übersetzungstabelle mit Escapezeichen in der nächsten Tabelle.See the escaped character translation table in the next table.
Computer KeineNone Immer vorhanden.Always present. Dieses Element stellt den Wert MachineName der-Eigenschaft dar.This element represents the value of the MachineName property.
Correlation ActivityID Immer vorhanden.Always present. Wenn ActivityID nicht angegeben wird, ist der Standardwert eine leere Guid.If ActivityID is not specified, the default is an empty GUID.
RelatedActivityID Hängt davon ab, ob der relatedActivityId -Parameter Trace im Methoden aufrufvorhanden ist.Depends on the presence of the relatedActivityId parameter in the Trace method call. Das RelatedActivityID -Attribut entspricht dem relatedActivityId -Parameter der TraceTransfer -Methode.The RelatedActivityID attribute corresponds to the relatedActivityId parameter of the TraceTransfer method.
Data KeineNone Immer vorhanden.Always present. Dieses Element stellt Parameter Eingabe (data) dar.This element represents parameter input (data). Ein-Element wird für jedes Datenobjekt bereitgestellt.One element is provided for each data object. Im Fall von Ereignisprotokollen enthält das Data -Element geschützte XML-Daten.In the case of event logs, the Data element contains escaped XML data. Im Fall von Datenprotokollen enthält das Data -Elementdaten ohne Escapezeichen.In the case of data logs, the Data element contains unescaped data. Die Ausgabe des Daten Protokolls verwendet ToString die-Methode der über gebenden Datenobjekte.The data log output uses the ToString method of the passed-in data objects.
Event KeineNone Immer vorhanden.Always present. Dieses Element enthält ein Ablauf Verfolgungs Ereignis.This element contains a trace event.
EventData KeineNone Für Ereignisprotokolle vorhanden.Present for event logs. Dieses Element stellt Parameter Eingaben (message, args) dar.This element represents parameter input (message, args). Sie enthält Data Elemente mit Escapezeichen, die durch den Aufruf der TraceEvent -Methode erstellt werden.It contains Data elements with escaped XML data that is created by calling the TraceEvent method.
EventID KeineNone Immer vorhanden.Always present. Dieses Element stellt Parameter Eingabe (id) dar.This element represents parameter input (id).
Execution ProcessID Hängt davon ab, ob das ProcessId -Flag in TraceOutputOptions der-Eigenschaft vorhanden ist.Depends on the presence of the ProcessId flag in the TraceOutputOptions property. Das ProcessID -Attribut wird in der TraceEventCacheangegeben.The ProcessID attribute is specified in the TraceEventCache. Wenn ProcessID die Betriebssysteme Microsoft Windows 98 und Windows Millennium Edition größer als 2.147.483.647 sind, handelt es sich um eine positive Darstellung einer negativen Zahl, die konvertiert werden muss, um die richtige Prozess-ID zu erhalten.On the Microsoft Windows 98 and Windows Millennium Edition operating systems, if ProcessID is larger than 2,147,483,647, it is a positive representation of a negative number and should be converted to obtain the correct process identifier.
ThreadID Vorhanden, ProcessID wenn vorhanden ist.Present when ProcessID is present. Das ThreadID -Attribut wird in der TraceEventCacheangegeben.The ThreadID attribute is specified in the TraceEventCache.
Level KeineNone Immer vorhanden.Always present. Dieses Element stellt Parameter Eingaben (den numerischen Wert von eventType) dar.This element represents parameter input (the numeric value of eventType). Parameter Werte, die größer als 255 sind, werden als Ebene 8 ausgegeben, die TraceEventType.Informationdarstellt.Parameter values that are larger than 255 are output as a level 8, which represents TraceEventType.Information. Typen von Ablaufverfolgungsereignissen Critical, Error, Warning, Information, und Verbose werden Sie als Ebenen 1, 2, 4, 8 und 10, ausgegeben bzw.Trace event types Critical, Error, Warning, Information, and Verbose are output as levels 1, 2, 4, 8, and 10, respectively.
LogicalOperationStack KeineNone Hängt davon ab, ob das LogicalOperationStack -Flag in TraceOutputOptions der-Eigenschaft vorhanden ist.Depends on the presence of the LogicalOperationStack flag in the TraceOutputOptions property. Es kann nur ein logischer Vorgang vorhanden sein.Only one logical operation can exist. Daher werden die Werte als LogicalOperation Knoten unter dem LogicalOperationStack -Element geschrieben.Therefore, the values are written as LogicalOperation nodes under the LogicalOperationStack element.
OpCode KeineNone Vorhanden, Level wenn größer als 255 ist.Present when Level is greater than 255. Dieses Element stellt Ablauf Verfolgungs Ereignis Typen dar, die numerische Werte größer als 255 aufweisen.This element represents Trace event types that have numeric values greater than 255. Start, Stop, Suspend, Resume, oder Transfer werden Sie als Ebenen 1, 2, 4, 8 und 10, ausgegeben bzw.Start, Stop, Suspend, Resume, or Transfer are output as levels 1, 2, 4, 8, and 10, respectively.
Provider GUID Immer vorhanden.Always present. Immer leer.Always empty.
RenderingInfo Culture Immer vorhanden.Always present. Dieses Attribut stellt eine Ressourcen Zeichenfolge für den Ereignistyp dar.This attribute represents a resource string for the event type. Es ist immer "en-en\".It is always "en-EN\".
System Name Immer vorhanden.Always present.
TimeCreated SystemTime Hängt davon ab, ob das DateTime -Flag in TraceOutputOptions der-Eigenschaft vorhanden ist.Depends on the presence of the DateTime flag in the TraceOutputOptions property. Die Zeit ist der Wert TraceEventCache.DateTime der Eigenschaft.The time is the value of the TraceEventCache.DateTime property. Diese Eigenschaft wird als koordinierte Weltzeit ausgedrückt.This property is expressed as Coordinated Universal Time
TimeStamp KeineNone Hängt davon ab, ob das Timestamp -Flag in TraceOutputOptions der-Eigenschaft vorhanden ist.Depends on the presence of the Timestamp flag in the TraceOutputOptions property. Dieses Element wird in der TraceEventCacheangegeben.This element is specified in the TraceEventCache.
UserData KeineNone Für Datenprotokolle vorhanden.Present for data logs. Dieses Element enthält Data Elemente mit nicht mit Escapezeichen versehenen, vom TraceData Benutzer bereitgestellten Daten aus einer Methode.This element contains Data elements with unescaped, user-provided data from a TraceData method.

Die folgende Tabelle zeigt die Zeichen, die in der XML-Ausgabe mit Escapezeichen versehen werden.The following table shows the characters that are escaped in the XML output. Escapezeichen treten in allen Elementen und Attributen außer dem UserData -Element auf, das vom Benutzer bereitgestellte Daten ohne Escapezeichen enthält.Escaping occurs in all the elements and attributes except for the UserData element, which contains user-provided, unescaped data. Das UserData -Element ist das Ergebnis von Aufrufen der TraceData -Methode.The UserData element is a result of calls to the TraceData method.

EscapezeichenEscaped character WertValue
& &
< <
> >
"" "
|'
0xD0xD &#xD;&#xD;
0xA0xA &#xA;&#xA;

Konstruktoren

EventSchemaTraceListener(String)

Initialisiert eine neue Instanz der EventSchemaTraceListener-Klasse, wobei die angegebene Datei als Empfänger der Debug- oder Ablaufverfolgungsausgabe verwendet wird.Initializes a new instance of the EventSchemaTraceListener class, using the specified file as the recipient of debugging and tracing output.

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.Initializes a new instance of the EventSchemaTraceListener class with the specified name, using the specified file as the recipient of debugging and tracing output.

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.Initializes a new instance of the EventSchemaTraceListener class with the specified name and specified buffer size, using the specified file as the recipient of debugging and tracing output.

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.Initializes a new instance of the EventSchemaTraceListener class with the specified name and specified buffer size, using the specified file with the specified log retention policy as the recipient of the debugging and tracing output.

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.Initializes a new instance of the EventSchemaTraceListener class with the specified name and specified buffer size, using the specified file with the specified log retention policy and maximum size as the recipient of the debugging and tracing output.

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.Initializes a new instance of the EventSchemaTraceListener class with the specified name and specified buffer size, using the specified file with the specified log retention policy, maximum size, and file count as the recipient of the debugging and tracing output.

Eigenschaften

Attributes

Ruft die benutzerdefinierten Attribute für Ablaufverfolgungslistener ab, die in der Anwendungskonfigurationsdatei definiert sind.Gets the custom trace listener attributes defined in the application configuration file.

(Geerbt von TraceListener)
BufferSize

Ruft die Größe des Ausgabepuffers ab.Gets the size of the output buffer.

Filter

Ruft den Ablaufverfolgungsfilter für den Ablaufverfolgungslistener ab oder legt diesen fest.Gets or sets the trace filter for the trace listener.

(Geerbt von TraceListener)
IndentLevel

Ruft die Einzugsebene ab oder legt diese fest.Gets or sets the indent level.

(Geerbt von TraceListener)
IndentSize

Ruft die Anzahl der Leerzeichen in einem Einzug ab oder legt diese fest.Gets or sets the number of spaces in an indent.

(Geerbt von TraceListener)
IsThreadSafe

Ruft einen Wert ab, der angibt, ob der Ablaufverfolgungslistener threadsicher ist.Gets a value indicating whether the trace listener is thread safe.

MaximumFileSize

Ruft die maximale Größe der Protokolldatei ab.Gets the maximum size of the log file.

MaximumNumberOfFiles

Ruft die maximale Anzahl von Protokolldateien ab.Gets the maximum number of log files.

Name

Ruft einen Namen für diesen TraceListener ab oder legt diesen fest.Gets or sets a name for this TraceListener.

(Geerbt von TraceListener)
NeedIndent

Ruft einen Wert ab, der einen Einzug für die Ausgabe angibt, oder legt diesen fest.Gets or sets a value indicating whether to indent the output.

(Geerbt von TraceListener)
TraceLogRetentionOption

Ruft die Beibehaltungsoption für das Ablaufverfolgungsprotokoll der Datei ab.Gets the trace log retention option for the file.

TraceOutputOptions

Ruft die Optionen für die Ablaufverfolgungsausgabe ab oder legt diese fest.Gets or sets the trace output options.

(Geerbt von TraceListener)
Writer

Ruft den zugrunde liegenden TextWriter ab, der in die Protokolldatei schreibt, oder legt diesen fest.Gets or sets the underlying text writer that writes to the log file.

Methoden

Close()

Schließt die Protokolldatei für diesen Listener, sodass dieser keine Ablaufverfolgungs- oder Debugausgaben mehr empfängt.Closes the log file for this listener so that it no longer receives tracing or debugging output.

CreateObjRef(Type)

Erstellt ein Objekt mit allen relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Geerbt von MarshalByRefObject)
Dispose()

Veröffentlicht alle durch den TraceListener verwendeten Ressourcen.Releases all resources used by the TraceListener.

(Geerbt von TraceListener)
Dispose(Boolean)

Gibt dieses TextWriterTraceListener-Objekt frei.Disposes this TextWriterTraceListener object.

(Geerbt von TextWriterTraceListener)
Equals(Object)

Ermittelt, ob das angegebene Objekt und das aktuelle Objekt gleich sind.Determines whether the specified object is equal to the current object.

(Geerbt von Object)
Fail(String)

Gibt eine Fehlermeldung an den Listener aus, den Sie beim Implementieren der TraceListener-Klasse erstellen.Emits an error message to the listener you create when you implement the TraceListener class.

(Geerbt von TraceListener)
Fail(String, String)

Schreibt Fehlerinformationen in die Protokolldatei, einschließlich einer einfachen Fehlermeldung und einer ausführlichen Fehlermeldung.Writes error information, including a basic error message and a detailed error message, to the log file.

Flush()

Bewirkt, dass gepufferte Daten in das Protokoll für diesen Listener geschrieben werden.Causes buffered data to be written to the log for this listener.

GetHashCode()

Dient als die Standard-HashfunktionServes as the default hash function.

(Geerbt von Object)
GetLifetimeService()

Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Geerbt von MarshalByRefObject)
GetSupportedAttributes()

Ruft die vom Ablaufverfolgungslistener unterstützten benutzerdefinierten XML-Konfigurationsattribute ab.Gets the custom XML configuration attributes that the trace listener supports.

GetType()

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

(Geerbt von Object)
InitializeLifetimeService()

Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab.Obtains a lifetime service object to control the lifetime policy for this instance.

(Geerbt von MarshalByRefObject)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Geerbt von Object)
MemberwiseClone(Boolean)

Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts.Creates a shallow copy of the current MarshalByRefObject object.

(Geerbt von MarshalByRefObject)
ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.Returns a string that represents the current object.

(Geerbt von Object)
TraceData(TraceEventCache, String, TraceEventType, Int32, Object)

Schreibt Ablaufverfolgungsinformationen, ein einzelnes Datenobjekt sowie Ereignisinformationen in die Protokolldatei.Writes trace information, a single data object, and event information to the log file.

TraceData(TraceEventCache, String, TraceEventType, Int32, Object[])

Schreibt Ablaufverfolgungsinformationen, mehrere Datenobjekte und Ereignisinformationen in die Protokolldatei.Writes trace information, multiple data objects, and event information to the log file.

TraceEvent(TraceEventCache, String, TraceEventType, Int32)

Schreibt Ablaufverfolgungs- und Ereignisinformationen in die spezifische Ausgabe des Listeners.Writes trace and event information to the listener specific output.

(Geerbt von TraceListener)
TraceEvent(TraceEventCache, String, TraceEventType, Int32, String)

Schreibt Ablaufverfolgungsinformationen, eine Meldung und Ereignisinformationen in die Protokolldatei.Writes trace information, a message, and event information to the log file.

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

Schreibt Ablaufverfolgungsinformationen, eine formatierte Meldung und Ereignisinformationen in die Protokolldatei.Writes trace information, a formatted message, and event information to the log file.

TraceTransfer(TraceEventCache, String, Int32, String, Guid)

Schreibt Ablaufverfolgungsinformationen, darunter die Identität einer verwandten Aktivität, eine Meldung sowie Ereignisinformationen, in die Protokolldatei.Writes trace information, including the identity of a related activity, a message, and event information, to the log file.

Write(Object)

Schreibt den Wert der ToString()-Methode des Objekts in den Listener, den Sie beim Implementieren der TraceListener-Klasse erstellen.Writes the value of the object's ToString() method to the listener you create when you implement the TraceListener class.

(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.Writes a category name and the value of the object's ToString() method to the listener you create when you implement the TraceListener class.

(Geerbt von TraceListener)
Write(String)

Schreibt eine Meldung ohne weitere Kontextinformationen in die Protokolldatei.Writes a message to the log file without providing any additional context information.

Write(String, String)

Schreibt einen Kategorienamen und eine Meldung in den Listener, den Sie beim Implementieren der TraceListener-Klasse erstellen.Writes a category name and a message to the listener you create when you implement the TraceListener class.

(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.Writes the indent to the listener you create when you implement this class, and resets the NeedIndent property to false.

(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.Writes the value of the object's ToString() method to the listener you create when you implement the TraceListener class, followed by a line terminator.

(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.Writes a category name and the value of the object's ToString() method to the listener you create when you implement the TraceListener class, followed by a line terminator.

(Geerbt von TraceListener)
WriteLine(String)

Schreibt eine Meldung, gefolgt vom Abschlusszeichen der aktuellen Zeile und ohne weitere Kontextinformationen in die Protokolldatei.Writes a message followed by the current line terminator to the log file without providing any additional context information.

WriteLine(String, String)

Schreibt einen Kategorienamen und eine Meldung gefolgt von einem Zeilenabschluss in den Listener, den Sie beim Implementieren der TraceListener-Klasse erstellen.Writes a category name and a message to the listener you create when you implement the TraceListener class, followed by a line terminator.

(Geerbt von TraceListener)

Gilt für: