EventSource.WriteEvent Metodo

Origine:

EventSource.cs

Origine:

EventSource.cs

Origine:

EventSource.cs

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)

Parametri

Commenti

eventid deve essere maggiore di 0 o minore di 65535 o errori può verificarsi nell'operazione. Se si verificano errori, è possibile ottenere altre informazioni sull'origine dell'errore controllando il flusso di output del debugger, se si dispone di un debugger collegato agli eventi di attivazione del processo. È anche possibile cercare errori segnalati nel flusso di eventi ETW, se si dispone di un listener ETW nell'origine evento in cui si verifica l'errore.

Quando si implementa un metodo identificato come evento ETW in una EventSourceclasse derivata. È necessario chiamare il metodo della classe WriteEvent di base passando gli EventId argomenti e gli stessi argomenti del metodo implementato simile all'esempio seguente.

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

Origine:

EventSource.cs

Origine:

EventSource.cs

Origine:

EventSource.cs

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)

Parametri

Commenti

eventid deve essere maggiore di 0 o minore di 65535 o errori può verificarsi nell'operazione. Se si verificano errori, è possibile ottenere altre informazioni sull'origine dell'errore controllando il flusso di output del debugger, se si dispone di un debugger collegato agli eventi di attivazione del processo. È anche possibile cercare errori segnalati nel flusso di eventi ETW, se si dispone di un listener ETW nell'origine evento in cui si verifica l'errore.

Quando si implementa un metodo identificato come evento ETW in una EventSourceclasse derivata. È necessario chiamare il metodo della classe WriteEvent di base passando gli EventId argomenti e gli stessi argomenti del metodo implementato simile all'esempio seguente.

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

Origine:

EventSource.cs

Origine:

EventSource.cs

Origine:

EventSource.cs

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)

Parametri

Commenti

eventid deve essere maggiore di 0 o minore di 65535 o errori può verificarsi nell'operazione. Se si verificano errori, è possibile ottenere altre informazioni sull'origine dell'errore controllando il flusso di output del debugger, se si dispone di un debugger collegato agli eventi di attivazione del processo. È anche possibile cercare errori segnalati nel flusso di eventi ETW, se si dispone di un listener ETW nell'origine evento in cui si verifica l'errore.

Quando si implementa un metodo identificato come evento ETW in una EventSourceclasse derivata. È necessario chiamare il metodo della classe WriteEvent di base passando gli EventId argomenti e gli stessi argomenti del metodo implementato simile all'esempio seguente.

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

Origine:

EventSource.cs

Origine:

EventSource.cs

Origine:

EventSource.cs

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)

Parametri

Commenti

eventid deve essere maggiore di 0 o minore di 65535 o errori può verificarsi nell'operazione. Se si verificano errori, è possibile ottenere altre informazioni sull'origine dell'errore controllando il flusso di output del debugger, se si dispone di un debugger collegato agli eventi di attivazione del processo. È anche possibile cercare errori segnalati nel flusso di eventi ETW, se si dispone di un listener ETW nell'origine evento in cui si verifica l'errore.

Quando si implementa un metodo identificato come evento ETW in una EventSourceclasse derivata. È necessario chiamare il metodo della classe WriteEvent di base passando gli EventId argomenti e gli stessi argomenti del metodo implementato simile all'esempio seguente.

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

Origine:

EventSource.cs

Origine:

EventSource.cs

Origine:

EventSource.cs

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)

Parametri

Commenti

eventid deve essere maggiore di 0 o minore di 65535 o errori può verificarsi nell'operazione. Se si verificano errori, è possibile ottenere altre informazioni sull'origine dell'errore controllando il flusso di output del debugger, se si dispone di un debugger collegato agli eventi di attivazione del processo. È anche possibile cercare errori segnalati nel flusso di eventi ETW, se si dispone di un listener ETW nell'origine evento in cui si verifica l'errore.

Quando si implementa un metodo identificato come evento ETW in una EventSourceclasse derivata. È necessario chiamare il metodo della classe WriteEvent di base passando gli EventId argomenti e gli stessi argomenti del metodo implementato simile all'esempio seguente.

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

Origine:

EventSource.cs

Origine:

EventSource.cs

Origine:

EventSource.cs

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)

Parametri

Commenti

eventid deve essere maggiore di 0 o minore di 65535 o errori può verificarsi nell'operazione. Se si verificano errori, è possibile ottenere altre informazioni sull'origine dell'errore controllando il flusso di output del debugger, se si dispone di un debugger collegato agli eventi di attivazione del processo. È anche possibile cercare errori segnalati nel flusso di eventi ETW, se si dispone di un listener ETW nell'origine evento in cui si verifica l'errore.

Quando si implementa un metodo identificato come evento ETW in una EventSourceclasse derivata. È necessario chiamare il metodo della classe WriteEvent di base passando gli EventId argomenti e gli stessi argomenti del metodo implementato simile all'esempio seguente.

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

Origine:

EventSource.cs

Origine:

EventSource.cs

Origine:

EventSource.cs

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)

Parametri

Commenti

eventid deve essere maggiore di 0 o minore di 65535 o errori può verificarsi nell'operazione. Se si verificano errori, è possibile ottenere altre informazioni sull'origine dell'errore controllando il flusso di output del debugger, se si dispone di un debugger collegato agli eventi di attivazione del processo. È anche possibile cercare errori segnalati nel flusso di eventi ETW, se si dispone di un listener ETW nell'origine evento in cui si verifica l'errore.

Quando si implementa un metodo identificato come evento ETW in una EventSourceclasse derivata. È necessario chiamare il metodo della classe WriteEvent di base passando gli EventId argomenti e gli stessi argomenti del metodo implementato simile all'esempio seguente.

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

Origine:

EventSource.cs

Origine:

EventSource.cs

Origine:

EventSource.cs

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)

Parametri

Commenti

eventid deve essere maggiore di 0 o minore di 65535 o errori può verificarsi nell'operazione. Se si verificano errori, è possibile ottenere altre informazioni sull'origine dell'errore controllando il flusso di output del debugger, se si dispone di un debugger collegato agli eventi di attivazione del processo. È anche possibile cercare errori segnalati nel flusso di eventi ETW, se si dispone di un listener ETW nell'origine evento in cui si verifica l'errore.

Quando si implementa un metodo identificato come evento ETW in una EventSourceclasse derivata. È necessario chiamare il metodo della classe WriteEvent di base passando gli EventId argomenti e gli stessi argomenti del metodo implementato simile all'esempio seguente.

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

Origine:

EventSource.cs

Origine:

EventSource.cs

Origine:

EventSource.cs

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)

Parametri

Commenti

eventid deve essere maggiore di 0 o minore di 65535 o errori può verificarsi nell'operazione. Se si verificano errori, è possibile ottenere altre informazioni sull'origine dell'errore controllando il flusso di output del debugger, se si dispone di un debugger collegato agli eventi di attivazione del processo. È anche possibile cercare errori segnalati nel flusso di eventi ETW, se si dispone di un listener ETW nell'origine evento in cui si verifica l'errore.

Quando si implementa un metodo identificato come evento ETW in una EventSourceclasse derivata. È necessario chiamare il metodo della classe WriteEvent di base passando gli EventId argomenti e gli stessi argomenti del metodo implementato simile all'esempio seguente.

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

Origine:

EventSource.cs

Origine:

EventSource.cs

Origine:

EventSource.cs

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)

Parametri

Commenti

eventid deve essere maggiore di 0 o minore di 65535 o errori può verificarsi nell'operazione. Se si verificano errori, è possibile ottenere altre informazioni sull'origine dell'errore controllando il flusso di output del debugger, se si dispone di un debugger collegato agli eventi di attivazione del processo. È anche possibile cercare errori segnalati nel flusso di eventi ETW, se si dispone di un listener ETW nell'origine evento in cui si verifica l'errore.

Quando si implementa un metodo identificato come evento ETW in una EventSourceclasse derivata. È necessario chiamare il metodo della classe WriteEvent di base passando gli EventId argomenti e gli stessi argomenti del metodo implementato simile all'esempio seguente.

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

Origine:

EventSource.cs

Origine:

EventSource.cs

Origine:

EventSource.cs

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)

Parametri

Origine:

EventSource.cs

Origine:

EventSource.cs

Origine:

EventSource.cs

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)

Parametri

Esempio

Nell'esempio seguente viene illustrato come usare questo overload del metodo per scrivere un evento. Questo esempio di codice fa parte di un esempio più grande fornito per la EventSource classe.

[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

Commenti

eventid deve essere maggiore di 0 o minore di 65535 o errori può verificarsi nell'operazione. Se si verificano errori, è possibile ottenere altre informazioni sull'origine dell'errore controllando il flusso di output del debugger, se si dispone di un debugger collegato agli eventi di attivazione del processo. È anche possibile cercare errori segnalati nel flusso di eventi ETW, se si dispone di un listener ETW nell'origine evento in cui si verifica l'errore.

Quando si implementa un metodo identificato come evento ETW in una EventSourceclasse derivata. È necessario chiamare il metodo della classe WriteEvent di base passando gli EventId argomenti e gli stessi argomenti del metodo implementato simile all'esempio seguente.

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

Origine:

EventSource.cs

Origine:

EventSource.cs

Origine:

EventSource.cs

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

Parametri

Commenti

Per impostazione predefinita, il compilatore chiama questo overload se i parametri per la chiamata non corrispondono a uno degli altri overload del metodo. Questo overload è molto più lento rispetto agli altri overload, perché esegue le operazioni seguenti:

1. Alloca una matrice per contenere l'argomento variabile.

2. Esegue il cast di ogni parametro in un oggetto che causa allocazioni per i tipi primitivi.

3. Assegna questi oggetti alla matrice.

4. Chiama la funzione, che determina quindi il tipo di ogni argomento in modo che possa essere serializzato per ETW.

Il sovraccarico elevato per questo overload non è significativo quando si tracciano eventi a basso volume, perché il metodo viene usato solo quando il provider è abilitato. Tuttavia, per gli eventi ad alto volume, il sovraccarico delle prestazioni può essere significativo. È possibile evitare di usare EventSource.WriteEvent per i payload di volume elevato creando un nuovo overload più veloce con il WriteEventCore metodo .

eventid deve essere maggiore di 0 o minore di 65535 o errori può verificarsi nell'operazione. Se si verificano errori, è possibile ottenere altre informazioni sull'origine dell'errore controllando il flusso di output del debugger, se si dispone di un debugger collegato agli eventi di attivazione del processo. È anche possibile cercare errori segnalati nel flusso di eventi ETW, se si dispone di un listener ETW nell'origine evento in cui si verifica l'errore.

Quando si implementa un metodo identificato come evento ETW in una EventSourceclasse derivata. È necessario chiamare il metodo della classe WriteEvent di base passando gli EventId argomenti e gli stessi argomenti del metodo implementato simile all'esempio seguente.

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

Origine:

EventSource.cs

Origine:

EventSource.cs

Origine:

EventSource.cs

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)

Parametri

Commenti

eventid deve essere maggiore di 0 o minore di 65535 o errori può verificarsi nell'operazione. Se si verificano errori, è possibile ottenere altre informazioni sull'origine dell'errore controllando il flusso di output del debugger, se si dispone di un debugger collegato agli eventi di attivazione del processo. È anche possibile cercare errori segnalati nel flusso di eventi ETW, se si dispone di un listener ETW nell'origine evento in cui si verifica l'errore.

Quando si implementa un metodo identificato come evento ETW in una EventSourceclasse derivata. È necessario chiamare il metodo della classe WriteEvent di base passando gli EventId argomenti e gli stessi argomenti del metodo implementato simile all'esempio seguente.

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

Origine:

EventSource.cs

Origine:

EventSource.cs

Origine:

EventSource.cs

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)

Parametri

Esempio

Nell'esempio seguente viene illustrato come usare questo overload del metodo per scrivere un evento. Questo esempio di codice fa parte di un esempio più grande fornito per la EventSource classe.

[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

Commenti

eventid deve essere maggiore di 0 o minore di 65535 o errori può verificarsi nell'operazione. Se si verificano errori, è possibile ottenere altre informazioni sull'origine dell'errore controllando il flusso di output del debugger, se si dispone di un debugger collegato agli eventi di attivazione del processo. È anche possibile cercare errori segnalati nel flusso di eventi ETW, se si dispone di un listener ETW nell'origine evento in cui si verifica l'errore.

Quando si implementa un metodo identificato come evento ETW in una EventSourceclasse derivata. È necessario chiamare il metodo della classe WriteEvent di base passando gli EventId argomenti e gli stessi argomenti del metodo implementato simile all'esempio seguente.

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

Origine:

EventSource.cs

Origine:

EventSource.cs

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

Parametri

Commenti

Si tratta di un helper varargs per la scrittura di un evento. Crea una matrice e una casella tutti gli argomenti in modo che sia relativamente inefficiente e deve essere usato solo per eventi relativamente rari (ad esempio, meno di 100 al secondo). Se le tariffe sono più veloci di quelle, usare WriteEventCore(Int32, Int32, EventSource+EventData*) per creare helper veloci per la firma del metodo specifico. Anche se si usa questo per eventi rari, questa chiamata deve essere protetta da un IsEnabled() controllo in modo che la chiamata varargs non venga eseguita quando EventSource non è attivo.

Origine:

EventSource.cs

Origine:

EventSource.cs

Origine:

EventSource.cs

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

Parametri

Commenti

eventid deve essere maggiore di 0 o minore di 65535 o errori può verificarsi nell'operazione. Se si verificano errori, è possibile ottenere altre informazioni sull'origine dell'errore controllando il flusso di output del debugger, se si dispone di un debugger collegato agli eventi di attivazione del processo. È anche possibile cercare errori segnalati nel flusso di eventi ETW, se si dispone di un listener ETW nell'origine evento in cui si verifica l'errore.

Quando si implementa un metodo identificato come evento ETW in una EventSourceclasse derivata. È necessario chiamare il metodo della classe WriteEvent di base passando gli EventId argomenti e gli stessi argomenti del metodo implementato simile all'esempio seguente.

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

Origine:

EventSource.cs

Origine:

EventSource.cs

Origine:

EventSource.cs

protected:
 void WriteEvent(int eventId);

protected void WriteEvent (int eventId);

member this.WriteEvent : int -> unit

Protected Sub WriteEvent (eventId As Integer)

Parametri

Esempio

Nell'esempio seguente viene illustrato come usare questo overload del metodo per scrivere un evento. Questo esempio di codice fa parte di un esempio più grande fornito per la EventSource classe.

[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

Commenti

eventid deve essere maggiore di 0 o minore di 65535 o errori può verificarsi nell'operazione. Se si verificano errori, è possibile ottenere altre informazioni sull'origine dell'errore controllando il flusso di output del debugger, se si dispone di un debugger collegato agli eventi di attivazione del processo. È anche possibile cercare errori segnalati nel flusso di eventi ETW, se si dispone di un listener ETW nell'origine evento in cui si verifica l'errore.

Quando si implementa un metodo identificato come evento ETW in una EventSourceclasse derivata. È necessario chiamare il metodo della classe WriteEvent di base passando gli EventId argomenti e gli stessi argomenti del metodo implementato simile all'esempio seguente.

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

Origine:

EventSource.cs

Origine:

EventSource.cs

Origine:

EventSource.cs

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

Parametri

Commenti

eventid deve essere maggiore di 0 o minore di 65535 o errori può verificarsi nell'operazione. Se si verificano errori, è possibile ottenere altre informazioni sull'origine dell'errore controllando il flusso di output del debugger, se si dispone di un debugger collegato agli eventi di attivazione del processo. È anche possibile cercare errori segnalati nel flusso di eventi ETW, se si dispone di un listener ETW nell'origine evento in cui si verifica l'errore.

Quando si implementa un metodo identificato come evento ETW in una EventSourceclasse derivata. È necessario chiamare il metodo della classe WriteEvent di base passando gli EventId argomenti e gli stessi argomenti del metodo implementato simile all'esempio seguente.

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