EventSource.WriteEvent Methode

Definition

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, 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 aus 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, da im Vorgang Fehler 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 übergeben, ä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)

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);
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, 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 ein Debugger an die Prozessauslösungsereignisse 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 EventSourcevon abgeleiteten 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);  
}  

Gilt für:

WriteEvent(Int32, String, Int32, Int32)

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);
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, 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 ein Debugger an die Prozessauslösungsereignisse 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 EventSourcevon abgeleiteten 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);  
}  

Gilt für:

WriteEvent(Int32, Int64, Int64, Int64)

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, 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 ein Debugger an die Prozessauslösungsereignisse 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 EventSourcevon abgeleiteten 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);  
}  

Gilt für:

WriteEvent(Int32, Int32, Int32, Int32)

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, 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 ein Debugger an die Prozessauslösungsereignisse 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 EventSourcevon abgeleiteten 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);  
}  

Gilt für:

WriteEvent(Int32, String, String)

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);
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, 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 ein Debugger an die Prozessauslösungsereignisse 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 EventSourcevon abgeleiteten 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);  
}  

Gilt für:

WriteEvent(Int32, String, Int64)

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);
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, 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 ein Debugger an die Prozessauslösungsereignisse 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 -abgeleiteten EventSourceKlasse identifiziert wird. Sie müssen die Basisklassenmethode WriteEvent aufrufen und die EventId gleichen Argumente wie die implementierte Methode übergeben, ähnlich wie im folgenden Beispiel.

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

Gilt für:

WriteEvent(Int32, String, Int32)

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);
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, 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 übergeben, ähnlich wie im folgenden Beispiel.

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

Gilt für:

WriteEvent(Int32, Int64, String)

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);
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, 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 übergeben, ähnlich wie im folgenden Beispiel.

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

Gilt für:

WriteEvent(Int32, Int64, Int64)

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, 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 übergeben, ähnlich wie im folgenden Beispiel.

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

Gilt für:

WriteEvent(Int32, Int32, Int32)

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, 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 übergeben, ähnlich wie im folgenden Beispiel.

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

Gilt für:

WriteEvent(Int32, Int32, String)

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);
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.

Gilt für:

WriteEvent(Int32, String)

Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und Zeichenfolgenargument.

protected:
 void WriteEvent(int eventId, System::String ^ arg1);
protected void WriteEvent (int eventId, 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, 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 übergeben, ähnlich wie im folgenden Beispiel.

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

Gilt für:

WriteEvent(Int32, Object[])

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);
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. Sie wandelt jeden Parameter in ein -Objekt um (wodurch Zuordnungen für primitive Typen verursacht werden).

  3. Es weist diese Objekte dem Array zu.

  4. Sie ruft die Funktion auf, die dann den Typ der einzelnen Argumente 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 EventSource.WriteEvent für Nutzlasten mit hohem Volumen vermeiden, indem Sie eine neue, schnellere Überladung mit der WriteEventCore -Methode erstellen.

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 übergeben, ähnlich wie im folgenden Beispiel.

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

Gilt für:

WriteEvent(Int32, Int64)

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, 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 übergeben, ähnlich wie im folgenden Beispiel.

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

Gilt für:

WriteEvent(Int32, Int32)

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, 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 übergeben, ähnlich wie im folgenden Beispiel.

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

Gilt für:

WriteEvent(Int32, Byte[])

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);
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, 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 übergeben, ähnlich wie im folgenden Beispiel.

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

Gilt für:

WriteEvent(Int32)

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, 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 übergeben, ähnlich wie im folgenden Beispiel.

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

Gilt für:

WriteEvent(Int32, Int64, Byte[])

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);
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, 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 übergeben, ähnlich wie im folgenden Beispiel.

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

Gilt für: