EventSource.WriteEvent Metodo

Source:

EventSource.cs

Source:

EventSource.cs

Source:

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 possono verificarsi errori nell'operazione. Se si verificano errori, è possibile ottenere altre informazioni sull'origine dell'errore controllando il flusso di output del debugger, se è associato un debugger agli eventi di generazione del processo. È anche possibile cercare gli 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 da . È necessario chiamare il metodo della classe WriteEvent base passando gli EventId stessi argomenti del metodo implementato in modo simile all'esempio seguente.

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

Source:

EventSource.cs

Source:

EventSource.cs

Source:

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 possono verificarsi errori nell'operazione. Se si verificano errori, è possibile ottenere altre informazioni sull'origine dell'errore controllando il flusso di output del debugger, se è associato un debugger agli eventi di generazione del processo. È anche possibile cercare gli 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 da . È necessario chiamare il metodo della classe WriteEvent base passando gli EventId stessi argomenti del metodo implementato in modo simile all'esempio seguente.

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

Source:

EventSource.cs

Source:

EventSource.cs

Source:

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 possono verificarsi errori nell'operazione. Se si verificano errori, è possibile ottenere altre informazioni sull'origine dell'errore controllando il flusso di output del debugger, se è associato un debugger agli eventi di generazione del processo. È anche possibile cercare gli 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 da . È necessario chiamare il metodo della classe WriteEvent base passando gli EventId stessi argomenti del metodo implementato in modo simile all'esempio seguente.

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

Source:

EventSource.cs

Source:

EventSource.cs

Source:

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 possono verificarsi errori nell'operazione. Se si verificano errori, è possibile ottenere altre informazioni sull'origine dell'errore controllando il flusso di output del debugger, se è associato un debugger agli eventi di generazione del processo. È anche possibile cercare gli 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 da . È necessario chiamare il metodo della classe WriteEvent base passando gli EventId stessi argomenti del metodo implementato in modo simile all'esempio seguente.

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

Source:

EventSource.cs

Source:

EventSource.cs

Source:

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 possono verificarsi errori nell'operazione. Se si verificano errori, è possibile ottenere altre informazioni sull'origine dell'errore controllando il flusso di output del debugger, se è associato un debugger agli eventi di generazione del processo. È anche possibile cercare gli 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 da . È necessario chiamare il metodo della classe WriteEvent base passando gli EventId stessi argomenti del metodo implementato in modo simile all'esempio seguente.

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

Source:

EventSource.cs

Source:

EventSource.cs

Source:

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 possono verificarsi errori nell'operazione. Se si verificano errori, è possibile ottenere altre informazioni sull'origine dell'errore controllando il flusso di output del debugger, se è associato un debugger agli eventi di generazione del processo. È anche possibile cercare gli 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 da . È necessario chiamare il metodo della classe WriteEvent base passando gli EventId stessi argomenti del metodo implementato in modo simile all'esempio seguente.

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

Source:

EventSource.cs

Source:

EventSource.cs

Source:

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 possono verificarsi errori nell'operazione. Se si verificano errori, è possibile ottenere altre informazioni sull'origine dell'errore controllando il flusso di output del debugger, se è associato un debugger agli eventi di generazione del processo. È anche possibile cercare gli 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 da . È necessario chiamare il metodo della classe WriteEvent base passando gli EventId stessi argomenti del metodo implementato in modo simile all'esempio seguente.

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

Source:

EventSource.cs

Source:

EventSource.cs

Source:

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 possono verificarsi errori nell'operazione. Se si verificano errori, è possibile ottenere altre informazioni sull'origine dell'errore controllando il flusso di output del debugger, se è associato un debugger agli eventi di generazione del processo. È anche possibile cercare gli 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 da . È necessario chiamare il metodo della classe WriteEvent base passando gli EventId stessi argomenti del metodo implementato in modo simile all'esempio seguente.

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

Source:

EventSource.cs

Source:

EventSource.cs

Source:

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 possono verificarsi errori nell'operazione. Se si verificano errori, è possibile ottenere altre informazioni sull'origine dell'errore controllando il flusso di output del debugger, se è associato un debugger agli eventi di generazione del processo. È anche possibile cercare gli 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 da . È necessario chiamare il metodo della classe WriteEvent base passando gli EventId stessi argomenti del metodo implementato in modo simile all'esempio seguente.

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

Source:

EventSource.cs

Source:

EventSource.cs

Source:

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 possono verificarsi errori nell'operazione. Se si verificano errori, è possibile ottenere altre informazioni sull'origine dell'errore controllando il flusso di output del debugger, se è associato un debugger agli eventi di generazione del processo. È anche possibile cercare gli 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 da . È necessario chiamare il metodo della classe WriteEvent base passando gli EventId stessi argomenti del metodo implementato in modo simile all'esempio seguente.

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

Source:

EventSource.cs

Source:

EventSource.cs

Source:

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

Source:

EventSource.cs

Source:

EventSource.cs

Source:

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ù ampio 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 possono verificarsi errori nell'operazione. Se si verificano errori, è possibile ottenere altre informazioni sull'origine dell'errore controllando il flusso di output del debugger, se è associato un debugger agli eventi di generazione del processo. È anche possibile cercare gli 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 da . È necessario chiamare il metodo della classe WriteEvent base passando gli EventId stessi argomenti del metodo implementato in modo simile all'esempio seguente.

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

Source:

EventSource.cs

Source:

EventSource.cs

Source:

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 della variabile.

2. Esegue il cast di ogni parametro a 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 serializzata per ETW.

L'overhead elevato per questo overload non è significativo quando si tracciano eventi con volume ridotto, perché il metodo viene usato solo quando il provider è abilitato. Tuttavia, per gli eventi con volumi elevati, l'overhead delle prestazioni può essere significativo. È possibile evitare di usare EventSource.WriteEvent per i payload con volumi elevati creando un nuovo overload più veloce con il WriteEventCore metodo .

eventid deve essere maggiore di 0 o minore di 65535 o possono verificarsi errori nell'operazione. Se si verificano errori, è possibile ottenere altre informazioni sull'origine dell'errore controllando il flusso di output del debugger, se è associato un debugger agli eventi di generazione del processo. È anche possibile cercare gli 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 da . È necessario chiamare il metodo della classe WriteEvent base passando gli EventId stessi argomenti del metodo implementato in modo simile all'esempio seguente.

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

Source:

EventSource.cs

Source:

EventSource.cs

Source:

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 possono verificarsi errori nell'operazione. Se si verificano errori, è possibile ottenere altre informazioni sull'origine dell'errore controllando il flusso di output del debugger, se è associato un debugger agli eventi di generazione del processo. È anche possibile cercare gli 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 da . È necessario chiamare il metodo della classe WriteEvent base passando gli EventId stessi argomenti del metodo implementato in modo simile all'esempio seguente.

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

Source:

EventSource.cs

Source:

EventSource.cs

Source:

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ù ampio 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 possono verificarsi errori nell'operazione. Se si verificano errori, è possibile ottenere altre informazioni sull'origine dell'errore controllando il flusso di output del debugger, se è associato un debugger agli eventi di generazione del processo. È anche possibile cercare gli 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 da . È necessario chiamare il metodo della classe WriteEvent base passando gli EventId stessi argomenti del metodo implementato in modo simile all'esempio seguente.

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

Source:

EventSource.cs

Source:

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 di tutti gli argomenti, quindi è relativamente inefficiente e deve essere usata solo per eventi relativamente rari (ad esempio, meno di 100 al secondo). Se le tariffe sono più veloci, usare WriteEventCore(Int32, Int32, EventSource+EventData*) per creare helper veloci per la firma del metodo specifico. Anche se si usa questa opzione 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.

Source:

EventSource.cs

Source:

EventSource.cs

Source:

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 possono verificarsi errori nell'operazione. Se si verificano errori, è possibile ottenere altre informazioni sull'origine dell'errore controllando il flusso di output del debugger, se è associato un debugger agli eventi di generazione del processo. È anche possibile cercare gli 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 da . È necessario chiamare il metodo della classe WriteEvent base passando gli EventId stessi argomenti del metodo implementato in modo simile all'esempio seguente.

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

Source:

EventSource.cs

Source:

EventSource.cs

Source:

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ù ampio 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 possono verificarsi errori nell'operazione. Se si verificano errori, è possibile ottenere altre informazioni sull'origine dell'errore controllando il flusso di output del debugger, se è associato un debugger agli eventi di generazione del processo. È anche possibile cercare gli 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 da . È necessario chiamare il metodo della classe WriteEvent base passando gli EventId stessi argomenti del metodo implementato in modo simile all'esempio seguente.

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

Source:

EventSource.cs

Source:

EventSource.cs

Source:

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 possono verificarsi errori nell'operazione. Se si verificano errori, è possibile ottenere altre informazioni sull'origine dell'errore controllando il flusso di output del debugger, se è associato un debugger agli eventi di generazione del processo. È anche possibile cercare gli 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 da . È necessario chiamare il metodo della classe WriteEvent base passando gli EventId stessi argomenti del metodo implementato in modo simile all'esempio seguente.

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