EventSource.WriteEvent Metodo

Definizione

Spazio dei nomi:

System.Diagnostics.Tracing

Assembly:

System.Diagnostics.Tracing.dll

Scrive un evento usando l'identificatore evento fornito e gli argomenti facoltativi.

Overload

WriteEvent(Int32, String, String, String)	Scrive un evento usando l'identificatore evento fornito e gli argomenti di stringa.
WriteEvent(Int32, String, Int32, Int32)	Scrive un evento usando l'identificatore evento fornito e gli argomenti.
WriteEvent(Int32, Int64, Int64, Int64)	Scrive un evento usando l'identificatore evento fornito e gli argomenti a 64 bit.
WriteEvent(Int32, Int32, Int32, Int32)	Scrive un evento usando l'identificatore evento fornito e gli argomenti interi a 32 bit.
WriteEvent(Int32, String, String)	Scrive un evento usando l'identificatore evento fornito e gli argomenti di stringa.
WriteEvent(Int32, String, Int64)	Scrive un evento usando l'identificatore evento fornito e gli argomenti.
WriteEvent(Int32, String, Int32)	Scrive un evento usando l'identificatore evento fornito e gli argomenti.
WriteEvent(Int32, Int64, String)	Scrive un evento usando l'identificatore evento fornito e gli argomenti di stringa e interi a 64 bit.
WriteEvent(Int32, Int64, Int64)	Scrive un evento usando l'identificatore evento fornito e gli argomenti a 64 bit.
WriteEvent(Int32, Int32, Int32)	Scrive un evento usando l'identificatore evento fornito e gli argomenti interi a 32 bit.
WriteEvent(Int32, Int32, String)	Scrive un evento usando l'identificatore evento fornito e gli argomenti di stringa e interi a 32 bit.
WriteEvent(Int32, String)	Scrive un evento usando l'identificatore evento fornito e gli argomenti di stringa.
WriteEvent(Int32, Object[])	Scrive un evento usando l'identificatore evento fornito e gli array di argomenti.
WriteEvent(Int32, Int64)	Scrive un evento usando l'identificatore evento fornito e un argomento di intero a 64 bit.
WriteEvent(Int32, Int32)	Scrive un evento usando l'identificatore evento fornito e un argomento di intero a 32 bit.
WriteEvent(Int32, EventSource+EventSourcePrimitive[])	Scrive un evento usando l'identificatore di evento specificato e un numero variabile di primitive di origine evento.
WriteEvent(Int32, Byte[])	Scrive un evento usando l'identificatore evento fornito e gli argomenti di matrice di byte.
WriteEvent(Int32)	Scrive un evento usando l'identificatore evento fornito.
WriteEvent(Int32, Int64, Byte[])	Scrive i dati dell'evento usando l'identificatore e gli argomenti di matrice di byte e di interi a 64 bit specificati.

Commenti

Il WriteEvent metodo fornisce overload con combinazioni di argomenti stringa e integer. Se nessuna di queste combinazioni corrisponde ai parametri per la chiamata, il compilatore usa l'overload EventSource.WriteEvent(Int32, Object[]) , che è notevolmente più lento rispetto agli altri overload. Per informazioni dettagliate, vedere la pagina di overload.

In tutti i casi, il eventid parametro 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);
}

È anche possibile creare un overload personalizzato usando il WriteEventCore metodo .

Importante

I parametri di evento con un tipo di string non devono includere \0 caratteri. Sono caratteri non supportati e possono causare problemi per i parser del payload dell'evento.

WriteEvent(Int32, String, String, String)

Origine:

EventSource.cs

Scrive un evento usando l'identificatore evento fornito e gli argomenti di stringa.

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)

Parametri

eventId

Int32

Identificatore dell'evento. Questo valore dovrebbe essere compreso tra 0 e 65535.

arg1

String

Argomento stringa.

arg2

String

Argomento stringa.

arg3

String

Argomento stringa.

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

WriteEvent(Int32, String, Int32, Int32)

Origine:

EventSource.cs

Scrive un evento usando l'identificatore evento fornito e gli argomenti.

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)

Parametri

eventId

Int32

Identificatore dell'evento. Questo valore dovrebbe essere compreso tra 0 e 65535.

arg1

String

Argomento stringa.

arg2

Int32

Argomento di intero a 32 bit.

arg3

Int32

Argomento di intero a 32 bit.

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

WriteEvent(Int32, Int64, Int64, Int64)

Origine:

EventSource.cs

Scrive un evento usando l'identificatore evento fornito e gli argomenti a 64 bit.

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

eventId

Int32

Identificatore dell'evento. Questo valore dovrebbe essere compreso tra 0 e 65535.

arg1

Int64

Argomento di intero a 64 bit.

arg2

Int64

Argomento di intero a 64 bit.

arg3

Int64

Argomento di intero a 64 bit.

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

WriteEvent(Int32, Int32, Int32, Int32)

Origine:

EventSource.cs

Scrive un evento usando l'identificatore evento fornito e gli argomenti interi a 32 bit.

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

eventId

Int32

Identificatore dell'evento. Questo valore dovrebbe essere compreso tra 0 e 65535.

arg1

Int32

Argomento di intero.

arg2

Int32

Argomento di intero.

arg3

Int32

Argomento di intero.

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

WriteEvent(Int32, String, String)

Origine:

EventSource.cs

Scrive un evento usando l'identificatore evento fornito e gli argomenti di stringa.

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)

Parametri

eventId

Int32

Identificatore dell'evento. Questo valore dovrebbe essere compreso tra 0 e 65535.

arg1

String

Argomento stringa.

arg2

String

Argomento stringa.

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

WriteEvent(Int32, String, Int64)

Origine:

EventSource.cs

Scrive un evento usando l'identificatore evento fornito e gli argomenti.

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)

Parametri

eventId

Int32

Identificatore dell'evento. Questo valore dovrebbe essere compreso tra 0 e 65535.

arg1

String

Argomento stringa.

arg2

Int64

Argomento di intero a 64 bit.

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

WriteEvent(Int32, String, Int32)

Origine:

EventSource.cs

Scrive un evento usando l'identificatore evento fornito e gli argomenti.

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)

Parametri

eventId

Int32

Identificatore dell'evento. Questo valore dovrebbe essere compreso tra 0 e 65535.

arg1

String

Argomento stringa.

arg2

Int32

Argomento di intero a 32 bit.

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

WriteEvent(Int32, Int64, String)

Origine:

EventSource.cs

Scrive un evento usando l'identificatore evento fornito e gli argomenti di stringa e interi a 64 bit.

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)

Parametri

eventId

Int32

Identificatore dell'evento. Questo valore dovrebbe essere compreso tra 0 e 65535.

arg1

Int64

Argomento di intero a 64 bit.

arg2

String

Argomento stringa.

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

WriteEvent(Int32, Int64, Int64)

Origine:

EventSource.cs

Scrive un evento usando l'identificatore evento fornito e gli argomenti a 64 bit.

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

eventId

Int32

Identificatore dell'evento. Questo valore dovrebbe essere compreso tra 0 e 65535.

arg1

Int64

Argomento di intero a 64 bit.

arg2

Int64

Argomento di intero a 64 bit.

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

WriteEvent(Int32, Int32, Int32)

Origine:

EventSource.cs

Scrive un evento usando l'identificatore evento fornito e gli argomenti interi a 32 bit.

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

eventId

Int32

Identificatore dell'evento. Questo valore dovrebbe essere compreso tra 0 e 65535.

arg1

Int32

Argomento di intero.

arg2

Int32

Argomento di intero.

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

WriteEvent(Int32, Int32, String)

Origine:

EventSource.cs

Scrive un evento usando l'identificatore evento fornito e gli argomenti di stringa e interi a 32 bit.

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)

Parametri

eventId

Int32

Identificatore dell'evento. Questo valore dovrebbe essere compreso tra 0 e 65535.

arg1

Int32

Argomento di intero a 32 bit.

arg2

String

Argomento stringa.

WriteEvent(Int32, String)

Origine:

EventSource.cs

Scrive un evento usando l'identificatore evento fornito e gli argomenti di stringa.

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)

Parametri

eventId

Int32

Identificatore dell'evento. Questo valore dovrebbe essere compreso tra 0 e 65535.

arg1

String

Argomento stringa.

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

WriteEvent(Int32, Object[])

Origine:

EventSource.cs

Scrive un evento usando l'identificatore evento fornito e gli array di argomenti.

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

Parametri

eventId

Int32

Identificatore dell'evento. Questo valore dovrebbe essere compreso tra 0 e 65535.

args

Object[]

Matrice di oggetti.

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

WriteEvent(Int32, Int64)

Origine:

EventSource.cs

Scrive un evento usando l'identificatore evento fornito e un argomento di intero a 64 bit.

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

eventId

Int32

Identificatore dell'evento. Questo valore dovrebbe essere compreso tra 0 e 65535.

arg1

Int64

Argomento di intero a 64 bit.

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

WriteEvent(Int32, Int32)

Origine:

EventSource.cs

Scrive un evento usando l'identificatore evento fornito e un argomento di intero a 32 bit.

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

eventId

Int32

Identificatore dell'evento. Questo valore dovrebbe essere compreso tra 0 e 65535.

arg1

Int32

Argomento di intero.

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

WriteEvent(Int32, EventSource+EventSourcePrimitive[])

Origine:

EventSource.cs

Scrive un evento usando l'identificatore di evento specificato e un numero variabile di primitive di origine evento.

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

eventId

Int32

Identificatore dell'evento. Questo valore dovrebbe essere compreso tra 0 e 65535.

args

EventSource.EventSourcePrimitive[]

Primitive di origine evento.

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.

WriteEvent(Int32, Byte[])

Origine:

EventSource.cs

Scrive un evento usando l'identificatore evento fornito e gli argomenti di matrice di byte.

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

Parametri

eventId

Int32

Identificatore dell'evento. Questo valore dovrebbe essere compreso tra 0 e 65535.

arg1

Byte[]

Argomento della matrice di byte.

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

WriteEvent(Int32)

Origine:

EventSource.cs

Scrive un evento usando l'identificatore evento fornito.

protected:
 void WriteEvent(int eventId);

protected void WriteEvent (int eventId);

member this.WriteEvent : int -> unit

Protected Sub WriteEvent (eventId As Integer)

Parametri

eventId

Int32

Identificatore dell'evento. Questo valore dovrebbe essere compreso tra 0 e 65535.

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

WriteEvent(Int32, Int64, Byte[])

Origine:

EventSource.cs

Scrive i dati dell'evento usando l'identificatore e gli argomenti di matrice di byte e di interi a 64 bit specificati.

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

Parametri

eventId

Int32

Identificatore dell'evento. Questo valore dovrebbe essere compreso tra 0 e 65535.

arg1

Int64

Argomento di intero a 64 bit.

arg2

Byte[]

Argomento della matrice di byte.

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