EventSource.WriteEvent Methode

Definition

Namespace:

System.Diagnostics.Tracing

Assembly:

System.Diagnostics.Tracing.dll

Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und optionalen Argumenten.

Überlädt

WriteEvent(Int32, String, String, String)	Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und Zeichenfolgenargumente.
WriteEvent(Int32, String, Int32, Int32)	Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und Argumente.
WriteEvent(Int32, Int64, Int64, Int64)	Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und 64-Bit-Argumente.
WriteEvent(Int32, Int32, Int32, Int32)	Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und 32-Bit-Ganzzahl-Argumente.
WriteEvent(Int32, String, String)	Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und Zeichenfolgenargumente.
WriteEvent(Int32, String, Int64)	Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und Argumente.
WriteEvent(Int32, String, Int32)	Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und Argumente.
WriteEvent(Int32, Int64, String)	Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und den 64-Bit-Ganzzahl- und Zeichenfolgenargumenten.
WriteEvent(Int32, Int64, Int64)	Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und 64-Bit-Argumente.
WriteEvent(Int32, Int32, Int32)	Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und 32-Bit-Ganzzahl-Argumente.
WriteEvent(Int32, Int32, String)	Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und den 32-Bit-Ganzzahl- und Zeichenfolgenargumenten.
WriteEvent(Int32, String)	Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und Zeichenfolgenargument.
WriteEvent(Int32, Object[])	Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und Argumentarrays.
WriteEvent(Int32, Int64)	Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und 64-Bit-Ganzzahl-Arguments.
WriteEvent(Int32, Int32)	Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und 32-Bit-Ganzzahl-Arguments.
WriteEvent(Int32, EventSource+EventSourcePrimitive[])	Schreibt ein Ereignis unter Verwendung des angegebenen Ereignisbezeichners und einer variablen Anzahl von Ereignisquellgrundtypen.
WriteEvent(Int32, Byte[])	Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und Bytearray-Arguments.
WriteEvent(Int32)	Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichner.
WriteEvent(Int32, Int64, Byte[])	Schreibt die Ereignisdaten mithilfe des bereitgestellten Bezeichners und den 64-Bit-Ganzzahl- und Bytearray-Argumenten.

Hinweise

Die WriteEvent -Methode stellt Überladungen mit Kombinationen von Zeichenfolgen- und ganzzahligen Argumenten bereit. Wenn keine dieser Kombinationen mit den Parametern für den Aufruf übereinstimmt, verwendet der Compiler die EventSource.WriteEvent(Int32, Object[]) -Überladung, die erheblich langsamer ist als die anderen Überladungen. Weitere Informationen finden Sie auf der Überladungsseite.

In allen Fällen sollte der eventid Parameter größer als 0 oder kleiner als 65535 sein, andernfalls können Fehler im Vorgang auftreten. Wenn Fehler auftreten, können Sie weitere Informationen zur Fehlerquelle erhalten, indem Sie den Ausgabedatenstrom des Debuggers überprüfen, wenn an die Prozessauslösungsereignisse ein Debugger angefügt ist. Sie können auch nach Fehlern suchen, die im ETW-Ereignisdatenstrom gemeldet wurden, wenn Sie über einen ETW-Listener für die Ereignisquelle verfügen, in der der Fehler auftritt.

Wenn Sie eine Methode implementieren, die als ETW-Ereignis in einer EventSourceabgeleiteten Klasse identifiziert wird. Sie müssen die Basisklassenmethode WriteEvent aufrufen und die gleichen Argumente wie die implementierte Methode übergeben EventId , ähnlich wie im folgenden Beispiel.

[Event(2, Level = EventLevel.Informational)]
public void Info1(string arg1)
{
    base.WriteEvent(2, arg1);
}

Sie können auch eine benutzerdefinierte Überladung erstellen, indem Sie die WriteEventCore -Methode verwenden.

Wichtig

Ereignisparameter mit einem Typ von string sollten keine Zeichen enthalten \0 . Sie sind nicht unterstützte Zeichen und können Probleme für Parser der Ereignisnutzlast verursachen.

WriteEvent(Int32, String, String, String)

Quelle:

EventSource.cs

Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und Zeichenfolgenargumente.

protected:
 void WriteEvent(int eventId, System::String ^ arg1, System::String ^ arg2, System::String ^ arg3);

protected void WriteEvent (int eventId, string? arg1, string? arg2, string? arg3);

member this.WriteEvent : int * string * string * string -> unit

Protected Sub WriteEvent (eventId As Integer, arg1 As String, arg2 As String, arg3 As String)

Parameter

eventId

Int32

Der Ereignisbezeichner. Dieser Wert muss zwischen 0 und 65535 liegen.

arg1

String

Ein Zeichenfolgenargument.

arg2

String

Ein Zeichenfolgenargument.

arg3

String

Ein Zeichenfolgenargument.

Hinweise

eventid sollte größer als 0 oder kleiner als 65535 sein, da fehler im Vorgang auftreten können. Wenn Fehler auftreten, können Sie weitere Informationen zur Fehlerquelle abrufen, indem Sie den Ausgabestream des Debuggers überprüfen, wenn ein Debugger an die Prozessauslösungsereignisse angefügt ist. Sie können auch nach Fehlern suchen, die im ETW-Ereignisstream gemeldet wurden, wenn Sie über einen ETW-Listener für die Ereignisquelle verfügen, in der der Fehler auftritt.

Wenn Sie eine Methode implementieren, die als ETW-Ereignis in einer -abgeleiteten EventSourceKlasse identifiziert wird. Sie müssen die Basisklassenmethode WriteEvent aufrufen und die EventId gleichen Argumente wie die implementierte Methode wie im folgenden Beispiel übergeben.

[Event(2, Level = EventLevel.Informational)]
public void Info1(string arg1)
{
    base.WriteEvent(2, arg1);
}

WriteEvent(Int32, String, Int32, Int32)

Quelle:

EventSource.cs

Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und Argumente.

protected:
 void WriteEvent(int eventId, System::String ^ arg1, int arg2, int arg3);

protected void WriteEvent (int eventId, string? arg1, int arg2, int arg3);

member this.WriteEvent : int * string * int * int -> unit

Protected Sub WriteEvent (eventId As Integer, arg1 As String, arg2 As Integer, arg3 As Integer)

Parameter

eventId

Int32

Der Ereignisbezeichner. Dieser Wert muss zwischen 0 und 65535 liegen.

arg1

String

Ein Zeichenfolgenargument.

arg2

Int32

Ein 32-Bit-Ganzzahlargument.

arg3

Int32

Ein 32-Bit-Ganzzahlargument.

Hinweise

eventid sollte größer als 0 oder kleiner als 65535 sein, da fehler im Vorgang auftreten können. Wenn Fehler auftreten, können Sie weitere Informationen zur Fehlerquelle abrufen, indem Sie den Ausgabestream des Debuggers überprüfen, wenn ein Debugger an die Prozessauslösungsereignisse angefügt ist. Sie können auch nach Fehlern suchen, die im ETW-Ereignisstream gemeldet wurden, wenn Sie über einen ETW-Listener für die Ereignisquelle verfügen, in der der Fehler auftritt.

Wenn Sie eine Methode implementieren, die als ETW-Ereignis in einer -abgeleiteten EventSourceKlasse identifiziert wird. Sie müssen die Basisklassenmethode WriteEvent aufrufen und die EventId gleichen Argumente wie die implementierte Methode wie im folgenden Beispiel übergeben.

[Event(2, Level = EventLevel.Informational)]
public void Info1(string arg1)
{
    base.WriteEvent(2, arg1);
}

WriteEvent(Int32, Int64, Int64, Int64)

Quelle:

EventSource.cs

Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und 64-Bit-Argumente.

protected:
 void WriteEvent(int eventId, long arg1, long arg2, long arg3);

protected void WriteEvent (int eventId, long arg1, long arg2, long arg3);

member this.WriteEvent : int * int64 * int64 * int64 -> unit

Protected Sub WriteEvent (eventId As Integer, arg1 As Long, arg2 As Long, arg3 As Long)

Parameter

eventId

Int32

Der Ereignisbezeichner. Dieser Wert muss zwischen 0 und 65535 liegen.

arg1

Int64

Ein 64-Bit-Ganzzahlargument.

arg2

Int64

Ein 64-Bit-Ganzzahlargument.

arg3

Int64

Ein 64-Bit-Ganzzahlargument.

Hinweise

eventid sollte größer als 0 oder kleiner als 65535 sein, da fehler im Vorgang auftreten können. Wenn Fehler auftreten, können Sie weitere Informationen zur Fehlerquelle abrufen, indem Sie den Ausgabestream des Debuggers überprüfen, wenn ein Debugger an die Prozessauslösungsereignisse angefügt ist. Sie können auch nach Fehlern suchen, die im ETW-Ereignisstream gemeldet wurden, wenn Sie über einen ETW-Listener für die Ereignisquelle verfügen, in der der Fehler auftritt.

Wenn Sie eine Methode implementieren, die als ETW-Ereignis in einer -abgeleiteten EventSourceKlasse identifiziert wird. Sie müssen die Basisklassenmethode WriteEvent aufrufen und die EventId gleichen Argumente wie die implementierte Methode wie im folgenden Beispiel übergeben.

[Event(2, Level = EventLevel.Informational)]
public void Info1(string arg1)
{
    base.WriteEvent(2, arg1);
}

WriteEvent(Int32, Int32, Int32, Int32)

Quelle:

EventSource.cs

Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und 32-Bit-Ganzzahl-Argumente.

protected:
 void WriteEvent(int eventId, int arg1, int arg2, int arg3);

protected void WriteEvent (int eventId, int arg1, int arg2, int arg3);

member this.WriteEvent : int * int * int * int -> unit

Protected Sub WriteEvent (eventId As Integer, arg1 As Integer, arg2 As Integer, arg3 As Integer)

Parameter

eventId

Int32

Der Ereignisbezeichner. Dieser Wert muss zwischen 0 und 65535 liegen.

arg1

Int32

Ein ganzzahliges Argument.

arg2

Int32

Ein ganzzahliges Argument.

arg3

Int32

Ein ganzzahliges Argument.

Hinweise

eventid sollte größer als 0 oder kleiner als 65535 sein, da fehler im Vorgang auftreten können. Wenn Fehler auftreten, können Sie weitere Informationen zur Fehlerquelle abrufen, indem Sie den Ausgabestream des Debuggers überprüfen, wenn ein Debugger an die Prozessauslösungsereignisse angefügt ist. Sie können auch nach Fehlern suchen, die im ETW-Ereignisstream gemeldet wurden, wenn Sie über einen ETW-Listener für die Ereignisquelle verfügen, in der der Fehler auftritt.

Wenn Sie eine Methode implementieren, die als ETW-Ereignis in einer -abgeleiteten EventSourceKlasse identifiziert wird. Sie müssen die Basisklassenmethode WriteEvent aufrufen und die EventId gleichen Argumente wie die implementierte Methode wie im folgenden Beispiel übergeben.

[Event(2, Level = EventLevel.Informational)]
public void Info1(string arg1)
{
    base.WriteEvent(2, arg1);
}

WriteEvent(Int32, String, String)

Quelle:

EventSource.cs

Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und Zeichenfolgenargumente.

protected:
 void WriteEvent(int eventId, System::String ^ arg1, System::String ^ arg2);

protected void WriteEvent (int eventId, string? arg1, string? arg2);

member this.WriteEvent : int * string * string -> unit

Protected Sub WriteEvent (eventId As Integer, arg1 As String, arg2 As String)

Parameter

eventId

Int32

Der Ereignisbezeichner. Dieser Wert muss zwischen 0 und 65535 liegen.

arg1

String

Ein Zeichenfolgenargument.

arg2

String

Ein Zeichenfolgenargument.

Hinweise

eventid sollte größer als 0 oder kleiner als 65535 sein, da fehler im Vorgang auftreten können. Wenn Fehler auftreten, können Sie weitere Informationen zur Fehlerquelle abrufen, indem Sie den Ausgabestream des Debuggers überprüfen, wenn ein Debugger an die Prozessauslösungsereignisse angefügt ist. Sie können auch nach Fehlern suchen, die im ETW-Ereignisstream gemeldet wurden, wenn Sie über einen ETW-Listener für die Ereignisquelle verfügen, in der der Fehler auftritt.

Wenn Sie eine Methode implementieren, die als ETW-Ereignis in einer -abgeleiteten EventSourceKlasse identifiziert wird. Sie müssen die Basisklassenmethode WriteEvent aufrufen und die EventId gleichen Argumente wie die implementierte Methode wie im folgenden Beispiel übergeben.

[Event(2, Level = EventLevel.Informational)]
public void Info1(string arg1)
{
    base.WriteEvent(2, arg1);
}

WriteEvent(Int32, String, Int64)

Quelle:

EventSource.cs

Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und Argumente.

protected:
 void WriteEvent(int eventId, System::String ^ arg1, long arg2);

protected void WriteEvent (int eventId, string? arg1, long arg2);

member this.WriteEvent : int * string * int64 -> unit

Protected Sub WriteEvent (eventId As Integer, arg1 As String, arg2 As Long)

Parameter

eventId

Int32

Der Ereignisbezeichner. Dieser Wert muss zwischen 0 und 65535 liegen.

arg1

String

Ein Zeichenfolgenargument.

arg2

Int64

Ein 64-Bit-Ganzzahlargument.

Hinweise

eventid sollte größer als 0 oder kleiner als 65535 sein, da fehler im Vorgang auftreten können. Wenn Fehler auftreten, können Sie weitere Informationen zur Fehlerquelle erhalten, indem Sie den Ausgabedatenstrom des Debuggers überprüfen, wenn an die Prozessauslösungsereignisse ein Debugger angefügt ist. Sie können auch nach Fehlern suchen, die im ETW-Ereignisdatenstrom gemeldet wurden, wenn Sie über einen ETW-Listener für die Ereignisquelle verfügen, in der der Fehler auftritt.

Wenn Sie eine Methode implementieren, die als ETW-Ereignis in einer EventSourceabgeleiteten Klasse identifiziert wird. Sie müssen die Basisklassenmethode WriteEvent aufrufen und die gleichen Argumente wie die implementierte Methode übergeben EventId , ähnlich wie im folgenden Beispiel.

[Event(2, Level = EventLevel.Informational)]
public void Info1(string arg1)
{
    base.WriteEvent(2, arg1);
}

WriteEvent(Int32, String, Int32)

Quelle:

EventSource.cs

Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und Argumente.

protected:
 void WriteEvent(int eventId, System::String ^ arg1, int arg2);

protected void WriteEvent (int eventId, string? arg1, int arg2);

member this.WriteEvent : int * string * int -> unit

Protected Sub WriteEvent (eventId As Integer, arg1 As String, arg2 As Integer)

Parameter

eventId

Int32

Der Ereignisbezeichner. Dieser Wert muss zwischen 0 und 65535 liegen.

arg1

String

Ein Zeichenfolgenargument.

arg2

Int32

Ein 32-Bit-Ganzzahlargument.

Hinweise

eventid sollte größer als 0 oder kleiner als 65535 sein, andernfalls können Fehler im Vorgang auftreten. Wenn Fehler auftreten, können Sie weitere Informationen zur Fehlerquelle erhalten, indem Sie den Ausgabedatenstrom des Debuggers überprüfen, wenn an die Prozessauslösungsereignisse ein Debugger angefügt ist. Sie können auch nach Fehlern suchen, die im ETW-Ereignisdatenstrom gemeldet wurden, wenn Sie über einen ETW-Listener für die Ereignisquelle verfügen, in der der Fehler auftritt.

Wenn Sie eine Methode implementieren, die als ETW-Ereignis in einer EventSourceabgeleiteten Klasse identifiziert wird. Sie müssen die Basisklassenmethode WriteEvent aufrufen und die gleichen Argumente wie die implementierte Methode übergeben EventId , ähnlich wie im folgenden Beispiel.

[Event(2, Level = EventLevel.Informational)]
public void Info1(string arg1)
{
    base.WriteEvent(2, arg1);
}

WriteEvent(Int32, Int64, String)

Quelle:

EventSource.cs

Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und den 64-Bit-Ganzzahl- und Zeichenfolgenargumenten.

protected:
 void WriteEvent(int eventId, long arg1, System::String ^ arg2);

protected void WriteEvent (int eventId, long arg1, string? arg2);

member this.WriteEvent : int * int64 * string -> unit

Protected Sub WriteEvent (eventId As Integer, arg1 As Long, arg2 As String)

Parameter

eventId

Int32

Der Ereignisbezeichner. Dieser Wert muss zwischen 0 und 65535 liegen.

arg1

Int64

Ein 64-Bit-Ganzzahlargument.

arg2

String

Ein Zeichenfolgenargument.

Hinweise

eventid sollte größer als 0 oder kleiner als 65535 sein, andernfalls können Fehler im Vorgang auftreten. Wenn Fehler auftreten, können Sie weitere Informationen zur Fehlerquelle erhalten, indem Sie den Ausgabedatenstrom des Debuggers überprüfen, wenn an die Prozessauslösungsereignisse ein Debugger angefügt ist. Sie können auch nach Fehlern suchen, die im ETW-Ereignisdatenstrom gemeldet wurden, wenn Sie über einen ETW-Listener für die Ereignisquelle verfügen, in der der Fehler auftritt.

Wenn Sie eine Methode implementieren, die als ETW-Ereignis in einer EventSourceabgeleiteten Klasse identifiziert wird. Sie müssen die Basisklassenmethode WriteEvent aufrufen und die gleichen Argumente wie die implementierte Methode übergeben EventId , ähnlich wie im folgenden Beispiel.

[Event(2, Level = EventLevel.Informational)]
public void Info1(Int64 arg1, string arg2)
{
    base.WriteEvent(2, arg1, arg2);
}

WriteEvent(Int32, Int64, Int64)

Quelle:

EventSource.cs

Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und 64-Bit-Argumente.

protected:
 void WriteEvent(int eventId, long arg1, long arg2);

protected void WriteEvent (int eventId, long arg1, long arg2);

member this.WriteEvent : int * int64 * int64 -> unit

Protected Sub WriteEvent (eventId As Integer, arg1 As Long, arg2 As Long)

Parameter

eventId

Int32

Der Ereignisbezeichner. Dieser Wert muss zwischen 0 und 65535 liegen.

arg1

Int64

Ein 64-Bit-Ganzzahlargument.

arg2

Int64

Ein 64-Bit-Ganzzahlargument.

Hinweise

eventid sollte größer als 0 oder kleiner als 65535 sein, andernfalls können Fehler im Vorgang auftreten. Wenn Fehler auftreten, können Sie weitere Informationen zur Fehlerquelle erhalten, indem Sie den Ausgabedatenstrom des Debuggers überprüfen, wenn an die Prozessauslösungsereignisse ein Debugger angefügt ist. Sie können auch nach Fehlern suchen, die im ETW-Ereignisdatenstrom gemeldet wurden, wenn Sie über einen ETW-Listener für die Ereignisquelle verfügen, in der der Fehler auftritt.

Wenn Sie eine Methode implementieren, die als ETW-Ereignis in einer EventSourceabgeleiteten Klasse identifiziert wird. Sie müssen die Basisklassenmethode WriteEvent aufrufen und die gleichen Argumente wie die implementierte Methode übergeben EventId , ähnlich wie im folgenden Beispiel.

[Event(2, Level = EventLevel.Informational)]
public void Info1(string arg1)
{
    base.WriteEvent(2, arg1);
}

WriteEvent(Int32, Int32, Int32)

Quelle:

EventSource.cs

Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und 32-Bit-Ganzzahl-Argumente.

protected:
 void WriteEvent(int eventId, int arg1, int arg2);

protected void WriteEvent (int eventId, int arg1, int arg2);

member this.WriteEvent : int * int * int -> unit

Protected Sub WriteEvent (eventId As Integer, arg1 As Integer, arg2 As Integer)

Parameter

eventId

Int32

Der Ereignisbezeichner. Dieser Wert muss zwischen 0 und 65535 liegen.

arg1

Int32

Ein ganzzahliges Argument.

arg2

Int32

Ein ganzzahliges Argument.

Hinweise

eventid sollte größer als 0 oder kleiner als 65535 sein, andernfalls können Fehler im Vorgang auftreten. Wenn Fehler auftreten, können Sie weitere Informationen zur Fehlerquelle erhalten, indem Sie den Ausgabedatenstrom des Debuggers überprüfen, wenn an die Prozessauslösungsereignisse ein Debugger angefügt ist. Sie können auch nach Fehlern suchen, die im ETW-Ereignisdatenstrom gemeldet wurden, wenn Sie über einen ETW-Listener für die Ereignisquelle verfügen, in der der Fehler auftritt.

Wenn Sie eine Methode implementieren, die als ETW-Ereignis in einer EventSourceabgeleiteten Klasse identifiziert wird. Sie müssen die Basisklassenmethode WriteEvent aufrufen und die gleichen Argumente wie die implementierte Methode übergeben EventId , ähnlich wie im folgenden Beispiel.

[Event(2, Level = EventLevel.Informational)]
public void Info1(int arg1, int arg2, int arg3)
{
    base.WriteEvent(2, arg1);
}

WriteEvent(Int32, Int32, String)

Quelle:

EventSource.cs

Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und den 32-Bit-Ganzzahl- und Zeichenfolgenargumenten.

protected:
 void WriteEvent(int eventId, int arg1, System::String ^ arg2);

protected void WriteEvent (int eventId, int arg1, string? arg2);

member this.WriteEvent : int * int * string -> unit

Protected Sub WriteEvent (eventId As Integer, arg1 As Integer, arg2 As String)

Parameter

eventId

Int32

Der Ereignisbezeichner. Dieser Wert muss zwischen 0 und 65535 liegen.

arg1

Int32

Ein 32-Bit-Ganzzahlargument.

arg2

String

Ein Zeichenfolgenargument.

WriteEvent(Int32, String)

Quelle:

EventSource.cs

Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und Zeichenfolgenargument.

protected:
 void WriteEvent(int eventId, System::String ^ arg1);

protected void WriteEvent (int eventId, string? arg1);

member this.WriteEvent : int * string -> unit

Protected Sub WriteEvent (eventId As Integer, arg1 As String)

Parameter

eventId

Int32

Der Ereignisbezeichner. Dieser Wert muss zwischen 0 und 65535 liegen.

arg1

String

Ein Zeichenfolgenargument.

Beispiele

Das folgende Beispiel zeigt, wie Sie diese Methodenüberladung verwenden, um ein Ereignis zu schreiben. Dieses Codebeispiel ist Teil eines größeren Beispiels, das für die EventSource-Klasse bereitgestellt wird.

[Event(1, Message = "Application Failure: {0}", Level = EventLevel.Error, Keywords = Keywords.Diagnostic)]
public void Failure(string message) { WriteEvent(1, message); }

<[Event](1, Message:="Application Failure: {0}", Level:=EventLevel.Error, Keywords:=Keywords.Diagnostic)> _
Public Sub Failure(ByVal message As String)
    WriteEvent(1, message)
End Sub

Hinweise

eventid sollte größer als 0 oder kleiner als 65535 sein, andernfalls können Fehler im Vorgang auftreten. Wenn Fehler auftreten, können Sie weitere Informationen zur Fehlerquelle erhalten, indem Sie den Ausgabedatenstrom des Debuggers überprüfen, wenn an die Prozessauslösungsereignisse ein Debugger angefügt ist. Sie können auch nach Fehlern suchen, die im ETW-Ereignisdatenstrom gemeldet wurden, wenn Sie über einen ETW-Listener für die Ereignisquelle verfügen, in der der Fehler auftritt.

Wenn Sie eine Methode implementieren, die als ETW-Ereignis in einer EventSourceabgeleiteten Klasse identifiziert wird. Sie müssen die Basisklassenmethode WriteEvent aufrufen und die gleichen Argumente wie die implementierte Methode übergeben EventId , ähnlich wie im folgenden Beispiel.

[Event(2, Level = EventLevel.Informational)]
public void Info1(string arg1)
{
    base.WriteEvent(2, arg1);
}

WriteEvent(Int32, Object[])

Quelle:

EventSource.cs

Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und Argumentarrays.

protected:
 void WriteEvent(int eventId, ... cli::array <System::Object ^> ^ args);

protected void WriteEvent (int eventId, params object?[] args);

member this.WriteEvent : int * obj[] -> unit

Protected Sub WriteEvent (eventId As Integer, ParamArray args As Object())

Parameter

eventId

Int32

Der Ereignisbezeichner. Dieser Wert muss zwischen 0 und 65535 liegen.

args

Object[]

Ein Array von -Objekten.

Hinweise

Standardmäßig ruft der Compiler diese Überladung auf, wenn die Parameter für den Aufruf nicht mit einer der anderen Methodenüberladungen übereinstimmen. Diese Überladung ist viel langsamer als die anderen Überladungen, da sie folgendes ausführt:

1. Es ordnet ein Array zu, das das Variablenargument enthält.

2. Jeder Parameter wird in ein -Objekt umgewandelt (wodurch Zuordnungen für primitive Typen verursacht werden).

3. Diese Objekte werden dem Array zugewiesen.

4. Sie ruft die -Funktion auf, die dann den Typ jedes Arguments bestimmt, damit es für ETW serialisiert werden kann.

Der hohe Mehraufwand für diese Überladung ist bei der Ablaufverfolgung von Ereignissen mit geringem Volumen nicht signifikant, da die -Methode nur verwendet wird, wenn der Anbieter aktiviert ist. Bei Ereignissen mit hohem Volumen kann der Leistungsaufwand jedoch erheblich sein. Sie können die Verwendung für EventSource.WriteEvent Nutzlasten mit hohem Volumen vermeiden, indem Sie mit der WriteEventCore -Methode eine neue, schnellere Überladung erstellen.

eventid sollte größer als 0 oder kleiner als 65535 sein, andernfalls können Fehler im Vorgang auftreten. Wenn Fehler auftreten, können Sie weitere Informationen zur Fehlerquelle erhalten, indem Sie den Ausgabedatenstrom des Debuggers überprüfen, wenn an die Prozessauslösungsereignisse ein Debugger angefügt ist. Sie können auch nach Fehlern suchen, die im ETW-Ereignisdatenstrom gemeldet wurden, wenn Sie über einen ETW-Listener für die Ereignisquelle verfügen, in der der Fehler auftritt.

Wenn Sie eine Methode implementieren, die als ETW-Ereignis in einer EventSourceabgeleiteten Klasse identifiziert wird. Sie müssen die Basisklassenmethode WriteEvent aufrufen und die gleichen Argumente wie die implementierte Methode übergeben EventId , ähnlich wie im folgenden Beispiel.

[Event(2, Level = EventLevel.Informational)]
public void Info1(string arg1)
{
    base.WriteEvent(2, arg1);
}

WriteEvent(Int32, Int64)

Quelle:

EventSource.cs

Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und 64-Bit-Ganzzahl-Arguments.

protected:
 void WriteEvent(int eventId, long arg1);

protected void WriteEvent (int eventId, long arg1);

member this.WriteEvent : int * int64 -> unit

Protected Sub WriteEvent (eventId As Integer, arg1 As Long)

Parameter

eventId

Int32

Der Ereignisbezeichner. Dieser Wert muss zwischen 0 und 65535 liegen.

arg1

Int64

Ein 64-Bit-Ganzzahlargument.

Hinweise

eventid sollte größer als 0 oder kleiner als 65535 sein, andernfalls können Fehler im Vorgang auftreten. Wenn Fehler auftreten, können Sie weitere Informationen zur Fehlerquelle erhalten, indem Sie den Ausgabedatenstrom des Debuggers überprüfen, wenn an die Prozessauslösungsereignisse ein Debugger angefügt ist. Sie können auch nach Fehlern suchen, die im ETW-Ereignisdatenstrom gemeldet wurden, wenn Sie über einen ETW-Listener für die Ereignisquelle verfügen, in der der Fehler auftritt.

Wenn Sie eine Methode implementieren, die als ETW-Ereignis in einer EventSourceabgeleiteten Klasse identifiziert wird. Sie müssen die Basisklassenmethode WriteEvent aufrufen und die gleichen Argumente wie die implementierte Methode übergeben EventId , ähnlich wie im folgenden Beispiel.

[Event(2, Level = EventLevel.Informational)]
public void Info1(string arg1)
{
    base.WriteEvent(2, arg1);
}

WriteEvent(Int32, Int32)

Quelle:

EventSource.cs

Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und 32-Bit-Ganzzahl-Arguments.

protected:
 void WriteEvent(int eventId, int arg1);

protected void WriteEvent (int eventId, int arg1);

member this.WriteEvent : int * int -> unit

Protected Sub WriteEvent (eventId As Integer, arg1 As Integer)

Parameter

eventId

Int32

Der Ereignisbezeichner. Dieser Wert muss zwischen 0 und 65535 liegen.

arg1

Int32

Ein ganzzahliges Argument.

Beispiele

Das folgende Beispiel zeigt, wie Sie diese Methodenüberladung verwenden, um ein Ereignis zu schreiben. Dieses Codebeispiel ist Teil eines größeren Beispiels, das für die EventSource-Klasse bereitgestellt wird.

[Event(4, Opcode = EventOpcode.Stop, Task = Tasks.Page, Keywords = Keywords.Page, Level = EventLevel.Informational)]
public void PageStop(int ID) { if (IsEnabled()) WriteEvent(4, ID); }

<[Event](4, Opcode:=EventOpcode.Stop, Task:=Tasks.Page, Keywords:=Keywords.Page, Level:=EventLevel.Informational)> _
Public Sub PageStop(ByVal ID As Integer)
    If IsEnabled() Then
        WriteEvent(4, ID)
    End If
End Sub

Hinweise

eventid sollte größer als 0 oder kleiner als 65535 sein, andernfalls können Fehler im Vorgang auftreten. Wenn Fehler auftreten, können Sie weitere Informationen zur Fehlerquelle erhalten, indem Sie den Ausgabedatenstrom des Debuggers überprüfen, wenn an die Prozessauslösungsereignisse ein Debugger angefügt ist. Sie können auch nach Fehlern suchen, die im ETW-Ereignisdatenstrom gemeldet wurden, wenn Sie über einen ETW-Listener für die Ereignisquelle verfügen, in der der Fehler auftritt.

Wenn Sie eine Methode implementieren, die als ETW-Ereignis in einer EventSourceabgeleiteten Klasse identifiziert wird. Sie müssen die Basisklassenmethode WriteEvent aufrufen und die gleichen Argumente wie die implementierte Methode übergeben EventId , ähnlich wie im folgenden Beispiel.

[Event(2, Level = EventLevel.Informational)]
public void Info1(int  arg1)
{
    base.WriteEvent(2, arg1);
}

WriteEvent(Int32, EventSource+EventSourcePrimitive[])

Quelle:

EventSource.cs

Schreibt ein Ereignis unter Verwendung des angegebenen Ereignisbezeichners und einer variablen Anzahl von Ereignisquellgrundtypen.

protected:
 void WriteEvent(int eventId, ... cli::array <System::Diagnostics::Tracing::EventSource::EventSourcePrimitive> ^ args);

protected void WriteEvent (int eventId, params System.Diagnostics.Tracing.EventSource.EventSourcePrimitive[] args);

member this.WriteEvent : int * System.Diagnostics.Tracing.EventSource.EventSourcePrimitive[] -> unit

Protected Sub WriteEvent (eventId As Integer, ParamArray args As EventSource.EventSourcePrimitive())

Parameter

eventId

Int32

Der Ereignisbezeichner. Dieser Wert muss zwischen 0 und 65535 liegen.

args

EventSource.EventSourcePrimitive[]

Die Ereignisquellengrundtypen.

Hinweise

Dies ist ein varargs-Hilfsprogramm zum Schreiben eines Ereignisses. Es erstellt ein Array und boxt alle Argumente, sodass es relativ ineffizient ist und nur für relativ seltene Ereignisse (z. B. weniger als 100 pro Sekunde) verwendet werden sollte. Wenn Ihre Raten schneller sind, verwenden Sie WriteEventCore(Int32, Int32, EventSource+EventData*) , um schnelle Hilfsprogramme für Ihre spezielle Methodensignatur zu erstellen. Selbst wenn Sie dies für seltene Ereignisse verwenden, sollte dieser Aufruf durch eine IsEnabled() Überprüfung geschützt werden, damit der varargs-Aufruf nicht erfolgt, wenn die EventSource nicht aktiv ist.

WriteEvent(Int32, Byte[])

Quelle:

EventSource.cs

Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und Bytearray-Arguments.

protected:
 void WriteEvent(int eventId, cli::array <System::Byte> ^ arg1);

protected void WriteEvent (int eventId, byte[]? arg1);

member this.WriteEvent : int * byte[] -> unit

Protected Sub WriteEvent (eventId As Integer, arg1 As Byte())

Parameter

eventId

Int32

Der Ereignisbezeichner. Dieser Wert muss zwischen 0 und 65535 liegen.

arg1

Byte[]

Ein Bytearray-Argument.

Hinweise

eventid sollte größer als 0 oder kleiner als 65535 sein, andernfalls können Fehler im Vorgang auftreten. Wenn Fehler auftreten, können Sie weitere Informationen zur Fehlerquelle erhalten, indem Sie den Ausgabedatenstrom des Debuggers überprüfen, wenn an die Prozessauslösungsereignisse ein Debugger angefügt ist. Sie können auch nach Fehlern suchen, die im ETW-Ereignisdatenstrom gemeldet wurden, wenn Sie über einen ETW-Listener für die Ereignisquelle verfügen, in der der Fehler auftritt.

Wenn Sie eine Methode implementieren, die als ETW-Ereignis in einer EventSourceabgeleiteten Klasse identifiziert wird. Sie müssen die Basisklassenmethode WriteEvent aufrufen und die gleichen Argumente wie die implementierte Methode übergeben EventId , ähnlich wie im folgenden Beispiel.

[Event(2, Level = EventLevel.Informational)]
public void Info1(byte[] arg1)
{
    base.WriteEvent(2, arg1);
}

WriteEvent(Int32)

Quelle:

EventSource.cs

Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichner.

protected:
 void WriteEvent(int eventId);

protected void WriteEvent (int eventId);

member this.WriteEvent : int -> unit

Protected Sub WriteEvent (eventId As Integer)

Parameter

eventId

Int32

Der Ereignisbezeichner. Dieser Wert muss zwischen 0 und 65535 liegen.

Beispiele

Das folgende Beispiel zeigt, wie Sie diese Methodenüberladung verwenden, um ein Ereignis zu schreiben. Dieses Codebeispiel ist Teil eines größeren Beispiels, das für die EventSource-Klasse bereitgestellt wird.

[Event(1, Message = "Application Failure: {0}", Level = EventLevel.Error, Keywords = Keywords.Diagnostic)]
public void Failure(string message) { WriteEvent(1, message); }

<[Event](1, Message:="Application Failure: {0}", Level:=EventLevel.Error, Keywords:=Keywords.Diagnostic)> _
Public Sub Failure(ByVal message As String)
    WriteEvent(1, message)
End Sub

Hinweise

eventid sollte größer als 0 oder kleiner als 65535 sein, andernfalls können Fehler im Vorgang auftreten. Wenn Fehler auftreten, können Sie weitere Informationen zur Fehlerquelle erhalten, indem Sie den Ausgabedatenstrom des Debuggers überprüfen, wenn an die Prozessauslösungsereignisse ein Debugger angefügt ist. Sie können auch nach Fehlern suchen, die im ETW-Ereignisdatenstrom gemeldet wurden, wenn Sie über einen ETW-Listener für die Ereignisquelle verfügen, in der der Fehler auftritt.

Wenn Sie eine Methode implementieren, die als ETW-Ereignis in einer EventSourceabgeleiteten Klasse identifiziert wird. Sie müssen die Basisklassenmethode WriteEvent aufrufen und die gleichen Argumente wie die implementierte Methode übergeben EventId , ähnlich wie im folgenden Beispiel.

[Event(2, Level = EventLevel.Informational)]
public void Info1(string arg1)
{
    base.WriteEvent(2, arg1);
}

WriteEvent(Int32, Int64, Byte[])

Quelle:

EventSource.cs

Schreibt die Ereignisdaten mithilfe des bereitgestellten Bezeichners und den 64-Bit-Ganzzahl- und Bytearray-Argumenten.

protected:
 void WriteEvent(int eventId, long arg1, cli::array <System::Byte> ^ arg2);

protected void WriteEvent (int eventId, long arg1, byte[]? arg2);

member this.WriteEvent : int * int64 * byte[] -> unit

Protected Sub WriteEvent (eventId As Integer, arg1 As Long, arg2 As Byte())

Parameter

eventId

Int32

Der Ereignisbezeichner. Dieser Wert muss zwischen 0 und 65535 liegen.

arg1

Int64

Ein 64-Bit-Ganzzahlargument.

arg2

Byte[]

Ein Bytearray-Argument.

Hinweise

eventid sollte größer als 0 oder kleiner als 65535 sein, andernfalls können Fehler im Vorgang auftreten. Wenn Fehler auftreten, können Sie weitere Informationen zur Fehlerquelle erhalten, indem Sie den Ausgabedatenstrom des Debuggers überprüfen, wenn an die Prozessauslösungsereignisse ein Debugger angefügt ist. Sie können auch nach Fehlern suchen, die im ETW-Ereignisdatenstrom gemeldet wurden, wenn Sie über einen ETW-Listener für die Ereignisquelle verfügen, in der der Fehler auftritt.

Wenn Sie eine Methode implementieren, die als ETW-Ereignis in einer EventSourceabgeleiteten Klasse identifiziert wird. Sie müssen die Basisklassenmethode WriteEvent aufrufen und die gleichen Argumente wie die implementierte Methode übergeben EventId , ähnlich wie im folgenden Beispiel.

[Event(2, Level = EventLevel.Informational)]
public void Info1(Int64 arg1, Byte[] arg2)
{
    base.WriteEvent(2, arg1, arg2);
}