EventSource.WriteEvent EventSource.WriteEvent EventSource.WriteEvent EventSource.WriteEvent Method

Definition

Writes an event by using the provided event identifier and optional arguments.

Overloads

WriteEvent(Int32, String, String, String) WriteEvent(Int32, String, String, String) WriteEvent(Int32, String, String, String) WriteEvent(Int32, String, String, String)

Writes an event by using the provided event identifier and string arguments.

WriteEvent(Int32, String, Int32, Int32) WriteEvent(Int32, String, Int32, Int32) WriteEvent(Int32, String, Int32, Int32) WriteEvent(Int32, String, Int32, Int32)

Writes an event by using the provided event identifier and arguments.

WriteEvent(Int32, Int64, Int64, Int64) WriteEvent(Int32, Int64, Int64, Int64) WriteEvent(Int32, Int64, Int64, Int64) WriteEvent(Int32, Int64, Int64, Int64)

Writes an event by using the provided event identifier and 64-bit arguments.

WriteEvent(Int32, Int32, Int32, Int32) WriteEvent(Int32, Int32, Int32, Int32) WriteEvent(Int32, Int32, Int32, Int32) WriteEvent(Int32, Int32, Int32, Int32)

Writes an event by using the provided event identifier and 32-bit integer arguments.

WriteEvent(Int32, String, String) WriteEvent(Int32, String, String) WriteEvent(Int32, String, String) WriteEvent(Int32, String, String)

Writes an event by using the provided event identifier and string arguments.

WriteEvent(Int32, String, Int64) WriteEvent(Int32, String, Int64) WriteEvent(Int32, String, Int64) WriteEvent(Int32, String, Int64)

Writes an event by using the provided event identifier and arguments.

WriteEvent(Int32, String, Int32) WriteEvent(Int32, String, Int32) WriteEvent(Int32, String, Int32) WriteEvent(Int32, String, Int32)

Writes an event by using the provided event identifier and arguments.

WriteEvent(Int32, Int64, String) WriteEvent(Int32, Int64, String) WriteEvent(Int32, Int64, String) WriteEvent(Int32, Int64, String)

Writes an event by using the provided event identifier and 64-bit integer, and string arguments.

WriteEvent(Int32, Int64, Int64) WriteEvent(Int32, Int64, Int64) WriteEvent(Int32, Int64, Int64) WriteEvent(Int32, Int64, Int64)

Writes an event by using the provided event identifier and 64-bit arguments.

WriteEvent(Int32, Int32, Int32) WriteEvent(Int32, Int32, Int32) WriteEvent(Int32, Int32, Int32) WriteEvent(Int32, Int32, Int32)

Writes an event by using the provided event identifier and 32-bit integer arguments.

WriteEvent(Int32, Int32, String) WriteEvent(Int32, Int32, String) WriteEvent(Int32, Int32, String) WriteEvent(Int32, Int32, String)

Writes an event by using the provided event identifier and 32-bit integer and string arguments.

WriteEvent(Int32, String) WriteEvent(Int32, String) WriteEvent(Int32, String) WriteEvent(Int32, String)

Writes an event by using the provided event identifier and string argument.

WriteEvent(Int32, Object[]) WriteEvent(Int32, Object[]) WriteEvent(Int32, Object[]) WriteEvent(Int32, Object[])

Writes an event by using the provided event identifier and array of arguments.

WriteEvent(Int32, Int64) WriteEvent(Int32, Int64) WriteEvent(Int32, Int64) WriteEvent(Int32, Int64)

Writes an event by using the provided event identifier and 64-bit integer argument.

WriteEvent(Int32, Int32) WriteEvent(Int32, Int32) WriteEvent(Int32, Int32) WriteEvent(Int32, Int32)

Writes an event by using the provided event identifier and 32-bit integer argument.

WriteEvent(Int32, Byte[]) WriteEvent(Int32, Byte[]) WriteEvent(Int32, Byte[]) WriteEvent(Int32, Byte[])

Writes an event by using the provided event identifier and byte array argument.

WriteEvent(Int32) WriteEvent(Int32) WriteEvent(Int32) WriteEvent(Int32)

Writes an event by using the provided event identifier.

WriteEvent(Int32, Int64, Byte[]) WriteEvent(Int32, Int64, Byte[]) WriteEvent(Int32, Int64, Byte[]) WriteEvent(Int32, Int64, Byte[])

Writes the event data using the specified indentifier and 64-bit integer and byte array arguments.

Remarks

The WriteEvent method provides overloads with combinations of string and integer arguments. If none of these combinations match the parameters for the call, the compiler uses the EventSource.WriteEvent(Int32, Object[]) overload, which is considerably slower than the other overloads. See the overload page for details.

In all cases, the eventid parameter should be greater than 0 or less than 65535 or errors can occur in the operation. If errors do occur, you can get more information about the source of the error by checking the output stream of the debugger, if you have a debugger attached to the process firing events. You can also look for errors reported in the ETW event stream, if you have an ETW listener on the event source where the error occurs.

When you implement a method that is identified as an ETW event in an EventSource-derived class. You must call the base class WriteEvent method passing the EventId and the same arguments as the implemented method similar to the following example.

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

You can also create a custom overload by using the WriteEventCore method.

WriteEvent(Int32, String, String, String) WriteEvent(Int32, String, String, String) WriteEvent(Int32, String, String, String) WriteEvent(Int32, String, String, String)

Writes an event by using the provided event identifier and string arguments.

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)

Parameters

eventId
Int32 Int32 Int32 Int32

The event identifier. This value should be between 0 and 65535.

arg1
String String String String

A string argument.

arg2
String String String String

A string argument.

arg3
String String String String

A string argument.

Remarks

eventid should be greater than 0 or less than 65535 or errors can occur in the operation. If errors do occur, you can get more information about the source of the error by checking the output stream of the debugger, if you have a debugger attached to the process firing events. You can also look for errors reported in the ETW event stream, if you have an ETW listener on the event source where the error occurs.

When you implement a method that is identified as an ETW event in an EventSource-derived class. You must call the base class WriteEvent method passing the EventId and the same arguments as the implemented method similar to the following example.

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

WriteEvent(Int32, String, Int32, Int32) WriteEvent(Int32, String, Int32, Int32) WriteEvent(Int32, String, Int32, Int32) WriteEvent(Int32, String, Int32, Int32)

Writes an event by using the provided event identifier and arguments.

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)

Parameters

eventId
Int32 Int32 Int32 Int32

The event identifier. This value should be between 0 and 65535.

arg1
String String String String

A string argument.

arg2
Int32 Int32 Int32 Int32

A 32 bit integer argument.

arg3
Int32 Int32 Int32 Int32

A 32 bit integer argument.

Remarks

eventid should be greater than 0 or less than 65535 or errors can occur in the operation. If errors do occur, you can get more information about the source of the error by checking the output stream of the debugger, if you have a debugger attached to the process firing events. You can also look for errors reported in the ETW event stream, if you have an ETW listener on the event source where the error occurs.

When you implement a method that is identified as an ETW event in an EventSource-derived class. You must call the base class WriteEvent method passing the EventId and the same arguments as the implemented method similar to the following example.

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

WriteEvent(Int32, Int64, Int64, Int64) WriteEvent(Int32, Int64, Int64, Int64) WriteEvent(Int32, Int64, Int64, Int64) WriteEvent(Int32, Int64, Int64, Int64)

Writes an event by using the provided event identifier and 64-bit arguments.

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)

Parameters

eventId
Int32 Int32 Int32 Int32

The event identifier. This value should be between 0 and 65535.

arg1
Int64 Int64 Int64 Int64

A 64 bit integer argument.

arg2
Int64 Int64 Int64 Int64

A 64 bit integer argument.

arg3
Int64 Int64 Int64 Int64

A 64 bit integer argument.

Remarks

eventid should be greater than 0 or less than 65535 or errors can occur in the operation. If errors do occur, you can get more information about the source of the error by checking the output stream of the debugger, if you have a debugger attached to the process firing events. You can also look for errors reported in the ETW event stream, if you have an ETW listener on the event source where the error occurs.

When you implement a method that is identified as an ETW event in an EventSource-derived class. You must call the base class WriteEvent method passing the EventId and the same arguments as the implemented method similar to the following example.

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

WriteEvent(Int32, Int32, Int32, Int32) WriteEvent(Int32, Int32, Int32, Int32) WriteEvent(Int32, Int32, Int32, Int32) WriteEvent(Int32, Int32, Int32, Int32)

Writes an event by using the provided event identifier and 32-bit integer arguments.

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)

Parameters

eventId
Int32 Int32 Int32 Int32

The event identifier. This value should be between 0 and 65535.

arg1
Int32 Int32 Int32 Int32

An integer argument.

arg2
Int32 Int32 Int32 Int32

An integer argument.

arg3
Int32 Int32 Int32 Int32

An integer argument.

Remarks

eventid should be greater than 0 or less than 65535 or errors can occur in the operation. If errors do occur, you can get more information about the source of the error by checking the output stream of the debugger, if you have a debugger attached to the process firing events. You can also look for errors reported in the ETW event stream, if you have an ETW listener on the event source where the error occurs.

When you implement a method that is identified as an ETW event in an EventSource-derived class. You must call the base class WriteEvent method passing the EventId and the same arguments as the implemented method similar to the following example.

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

WriteEvent(Int32, String, String) WriteEvent(Int32, String, String) WriteEvent(Int32, String, String) WriteEvent(Int32, String, String)

Writes an event by using the provided event identifier and string arguments.

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)

Parameters

eventId
Int32 Int32 Int32 Int32

The event identifier. This value should be between 0 and 65535.

arg1
String String String String

A string argument.

arg2
String String String String

A string argument.

Remarks

eventid should be greater than 0 or less than 65535 or errors can occur in the operation. If errors do occur, you can get more information about the source of the error by checking the output stream of the debugger, if you have a debugger attached to the process firing events. You can also look for errors reported in the ETW event stream, if you have an ETW listener on the event source where the error occurs.

When you implement a method that is identified as an ETW event in an EventSource-derived class. You must call the base class WriteEvent method passing the EventId and the same arguments as the implemented method similar to the following example.

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

WriteEvent(Int32, String, Int64) WriteEvent(Int32, String, Int64) WriteEvent(Int32, String, Int64) WriteEvent(Int32, String, Int64)

Writes an event by using the provided event identifier and arguments.

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)

Parameters

eventId
Int32 Int32 Int32 Int32

The event identifier. This value should be between 0 and 65535.

arg1
String String String String

A string argument.

arg2
Int64 Int64 Int64 Int64

A 64 bit integer argument.

Remarks

eventid should be greater than 0 or less than 65535 or errors can occur in the operation. If errors do occur, you can get more information about the source of the error by checking the output stream of the debugger, if you have a debugger attached to the process firing events. You can also look for errors reported in the ETW event stream, if you have an ETW listener on the event source where the error occurs.

When you implement a method that is identified as an ETW event in an EventSource-derived class. You must call the base class WriteEvent method passing the EventId and the same arguments as the implemented method similar to the following example.

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

WriteEvent(Int32, String, Int32) WriteEvent(Int32, String, Int32) WriteEvent(Int32, String, Int32) WriteEvent(Int32, String, Int32)

Writes an event by using the provided event identifier and arguments.

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)

Parameters

eventId
Int32 Int32 Int32 Int32

The event identifier. This value should be between 0 and 65535.

arg1
String String String String

A string argument.

arg2
Int32 Int32 Int32 Int32

A 32 bit integer argument.

Remarks

eventid should be greater than 0 or less than 65535 or errors can occur in the operation. If errors do occur, you can get more information about the source of the error by checking the output stream of the debugger, if you have a debugger attached to the process firing events. You can also look for errors reported in the ETW event stream, if you have an ETW listener on the event source where the error occurs.

When you implement a method that is identified as an ETW event in an EventSource-derived class. You must call the base class WriteEvent method passing the EventId and the same arguments as the implemented method similar to the following example.

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

WriteEvent(Int32, Int64, String) WriteEvent(Int32, Int64, String) WriteEvent(Int32, Int64, String) WriteEvent(Int32, Int64, String)

Writes an event by using the provided event identifier and 64-bit integer, and string arguments.

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)

Parameters

eventId
Int32 Int32 Int32 Int32

The event identifier. This value should be between 0 and 65535.

arg1
Int64 Int64 Int64 Int64

A 64-bit integer argument.

arg2
String String String String

A string argument.

Remarks

eventid should be greater than 0 or less than 65535 or errors can occur in the operation. If errors do occur, you can get more information about the source of the error by checking the output stream of the debugger, if you have a debugger attached to the process firing events. You can also look for errors reported in the ETW event stream, if you have an ETW listener on the event source where the error occurs.

When you implement a method that is identified as an ETW event in an EventSource-derived class. You must call the base class WriteEvent method passing the EventId and the same arguments as the implemented method similar to the following example.

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

WriteEvent(Int32, Int64, Int64) WriteEvent(Int32, Int64, Int64) WriteEvent(Int32, Int64, Int64) WriteEvent(Int32, Int64, Int64)

Writes an event by using the provided event identifier and 64-bit arguments.

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)

Parameters

eventId
Int32 Int32 Int32 Int32

The event identifier. This value should be between 0 and 65535.

arg1
Int64 Int64 Int64 Int64

A 64 bit integer argument.

arg2
Int64 Int64 Int64 Int64

A 64 bit integer argument.

Remarks

eventid should be greater than 0 or less than 65535 or errors can occur in the operation. If errors do occur, you can get more information about the source of the error by checking the output stream of the debugger, if you have a debugger attached to the process firing events. You can also look for errors reported in the ETW event stream, if you have an ETW listener on the event source where the error occurs.

When you implement a method that is identified as an ETW event in an EventSource-derived class. You must call the base class WriteEvent method passing the EventId and the same arguments as the implemented method similar to the following example.

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

WriteEvent(Int32, Int32, Int32) WriteEvent(Int32, Int32, Int32) WriteEvent(Int32, Int32, Int32) WriteEvent(Int32, Int32, Int32)

Writes an event by using the provided event identifier and 32-bit integer arguments.

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)

Parameters

eventId
Int32 Int32 Int32 Int32

The event identifier. This value should be between 0 and 65535.

arg1
Int32 Int32 Int32 Int32

An integer argument.

arg2
Int32 Int32 Int32 Int32

An integer argument.

Remarks

eventid should be greater than 0 or less than 65535 or errors can occur in the operation. If errors do occur, you can get more information about the source of the error by checking the output stream of the debugger, if you have a debugger attached to the process firing events. You can also look for errors reported in the ETW event stream, if you have an ETW listener on the event source where the error occurs.

When you implement a method that is identified as an ETW event in an EventSource-derived class. You must call the base class WriteEvent method passing the EventId and the same arguments as the implemented method similar to the following example.

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

WriteEvent(Int32, Int32, String) WriteEvent(Int32, Int32, String) WriteEvent(Int32, Int32, String) WriteEvent(Int32, Int32, String)

Writes an event by using the provided event identifier and 32-bit integer and string arguments.

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)

Parameters

eventId
Int32 Int32 Int32 Int32

The event identifier. This value should be between 0 and 65535.

arg1
Int32 Int32 Int32 Int32

A 32-bit integer argument.

arg2
String String String String

A string argument.

WriteEvent(Int32, String) WriteEvent(Int32, String) WriteEvent(Int32, String) WriteEvent(Int32, String)

Writes an event by using the provided event identifier and string argument.

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)

Parameters

eventId
Int32 Int32 Int32 Int32

The event identifier. This value should be between 0 and 65535.

arg1
String String String String

A string argument.

Examples

The following example shows how to use this method overload to write an event. This code example is part of a larger example provided for the EventSource class.

[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 'Failure

Remarks

eventid should be greater than 0 or less than 65535 or errors can occur in the operation. If errors do occur, you can get more information about the source of the error by checking the output stream of the debugger, if you have a debugger attached to the process firing events. You can also look for errors reported in the ETW event stream, if you have an ETW listener on the event source where the error occurs.

When you implement a method that is identified as an ETW event in an EventSource-derived class. You must call the base class WriteEvent method passing the EventId and the same arguments as the implemented method similar to the following example.

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

WriteEvent(Int32, Object[]) WriteEvent(Int32, Object[]) WriteEvent(Int32, Object[]) WriteEvent(Int32, Object[])

Writes an event by using the provided event identifier and array of arguments.

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

Parameters

eventId
Int32 Int32 Int32 Int32

The event identifier. This value should be between 0 and 65535.

args
Object[]

An array of objects.

Remarks

By default, the compiler calls this overload if the parameters for the call do not match one of the other method overloads. This overload is much slower than the other overloads, because it does the following:

  1. It allocates an array to hold the variable argument.

  2. It casts each parameter to an object (which causes allocations for primitive types).

  3. It assigns these objects to the array.

  4. It calls the function, which then determines the type of each argument so it can be serialized for ETW.

The high overhead for this overload is not significant when tracing low-volume events, because the method is used only when the provider is enabled. However, for high-volume events, the performance overhead can be significant. You can avoid using EventSource.WriteEvent for high-volume payloads by creating a new, faster overload with the WriteEventCore method.

eventid should be greater than 0 or less than 65535 or errors can occur in the operation. If errors do occur, you can get more information about the source of the error by checking the output stream of the debugger, if you have a debugger attached to the process firing events. You can also look for errors reported in the ETW event stream, if you have an ETW listener on the event source where the error occurs.

When you implement a method that is identified as an ETW event in an EventSource-derived class. You must call the base class WriteEvent method passing the EventId and the same arguments as the implemented method similar to the following example.

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

WriteEvent(Int32, Int64) WriteEvent(Int32, Int64) WriteEvent(Int32, Int64) WriteEvent(Int32, Int64)

Writes an event by using the provided event identifier and 64-bit integer argument.

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)

Parameters

eventId
Int32 Int32 Int32 Int32

The event identifier. This value should be between 0 and 65535.

arg1
Int64 Int64 Int64 Int64

A 64 bit integer argument.

Remarks

eventid should be greater than 0 or less than 65535 or errors can occur in the operation. If errors do occur, you can get more information about the source of the error by checking the output stream of the debugger, if you have a debugger attached to the process firing events. You can also look for errors reported in the ETW event stream, if you have an ETW listener on the event source where the error occurs.

When you implement a method that is identified as an ETW event in an EventSource-derived class. You must call the base class WriteEvent method passing the EventId and the same arguments as the implemented method similar to the following example.

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

WriteEvent(Int32, Int32) WriteEvent(Int32, Int32) WriteEvent(Int32, Int32) WriteEvent(Int32, Int32)

Writes an event by using the provided event identifier and 32-bit integer argument.

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)

Parameters

eventId
Int32 Int32 Int32 Int32

The event identifier. This value should be between 0 and 65535.

arg1
Int32 Int32 Int32 Int32

An integer argument.

Examples

The following example shows how to use this method overload to write an event. This code example is part of a larger example provided for the EventSource class.

[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 'PageStop

Remarks

eventid should be greater than 0 or less than 65535 or errors can occur in the operation. If errors do occur, you can get more information about the source of the error by checking the output stream of the debugger, if you have a debugger attached to the process firing events. You can also look for errors reported in the ETW event stream, if you have an ETW listener on the event source where the error occurs.

When you implement a method that is identified as an ETW event in an EventSource-derived class. You must call the base class WriteEvent method passing the EventId and the same arguments as the implemented method similar to the following example.

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

WriteEvent(Int32, Byte[]) WriteEvent(Int32, Byte[]) WriteEvent(Int32, Byte[]) WriteEvent(Int32, Byte[])

Writes an event by using the provided event identifier and byte array argument.

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

Parameters

eventId
Int32 Int32 Int32 Int32

The event identifier. This value should be between 0 and 65535.

arg1
Byte[]

A byte array argument.

Remarks

eventid should be greater than 0 or less than 65535 or errors can occur in the operation. If errors do occur, you can get more information about the source of the error by checking the output stream of the debugger, if you have a debugger attached to the process firing events. You can also look for errors reported in the ETW event stream, if you have an ETW listener on the event source where the error occurs.

When you implement a method that is identified as an ETW event in an EventSource-derived class. You must call the base class WriteEvent method passing the EventId and the same arguments as the implemented method similar to the following example.

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

WriteEvent(Int32) WriteEvent(Int32) WriteEvent(Int32) WriteEvent(Int32)

Writes an event by using the provided event identifier.

protected:
 void WriteEvent(int eventId);
protected void WriteEvent (int eventId);
member this.WriteEvent : int -> unit
Protected Sub WriteEvent (eventId As Integer)

Parameters

eventId
Int32 Int32 Int32 Int32

The event identifier. This value should be between 0 and 65535.

Examples

The following example shows how to use this method overload to write an event. This code example is part of a larger example provided for the EventSource class.

[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 'Failure

Remarks

eventid should be greater than 0 or less than 65535 or errors can occur in the operation. If errors do occur, you can get more information about the source of the error by checking the output stream of the debugger, if you have a debugger attached to the process firing events. You can also look for errors reported in the ETW event stream, if you have an ETW listener on the event source where the error occurs.

When you implement a method that is identified as an ETW event in an EventSource-derived class. You must call the base class WriteEvent method passing the EventId and the same arguments as the implemented method similar to the following example.

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

WriteEvent(Int32, Int64, Byte[]) WriteEvent(Int32, Int64, Byte[]) WriteEvent(Int32, Int64, Byte[]) WriteEvent(Int32, Int64, Byte[])

Writes the event data using the specified indentifier and 64-bit integer and byte array arguments.

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

Parameters

eventId
Int32 Int32 Int32 Int32

The event identifier. This value should be between 0 and 65535.

arg1
Int64 Int64 Int64 Int64

A 64-bit integer argument.

arg2
Byte[]

A byte array argument.

Remarks

eventid should be greater than 0 or less than 65535 or errors can occur in the operation. If errors do occur, you can get more information about the source of the error by checking the output stream of the debugger, if you have a debugger attached to the process firing events. You can also look for errors reported in the ETW event stream, if you have an ETW listener on the event source where the error occurs.

When you implement a method that is identified as an ETW event in an EventSource-derived class. You must call the base class WriteEvent method passing the EventId and the same arguments as the implemented method similar to the following example.

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

Applies to