EventSource.WriteEvent Méthode

Référence

Définition

Espace de noms:: System.Diagnostics.Tracing

Assembly:: System.Diagnostics.Tracing.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Écrit un événement à l’aide de l’identificateur d’événement et d’arguments facultatifs fournis.

Surcharges

WriteEvent(Int32, String, String, String)	Écrit un événement à l’aide de l’identificateur d’événement et des arguments de chaîne fournis.
WriteEvent(Int32, String, Int32, Int32)	Écrit un événement à l’aide de l’identificateur d’événement et d’arguments fournis.
WriteEvent(Int32, Int64, Int64, Int64)	Écrit un événement à l'aide de l'identificateur d'événement et des arguments d'une valeur de 64 octets fournis.
WriteEvent(Int32, Int32, Int32, Int32)	Écrit un événement à l’aide de l’identificateur d’événement et des arguments en entier d’une valeur de 32 octets fournis.
WriteEvent(Int32, String, String)	Écrit un événement à l’aide de l’identificateur d’événement et des arguments de chaîne fournis.
WriteEvent(Int32, String, Int64)	Écrit un événement à l’aide de l’identificateur d’événement et d’arguments fournis.
WriteEvent(Int32, String, Int32)	Écrit un événement à l’aide de l’identificateur d’événement et d’arguments fournis.
WriteEvent(Int32, Int64, String)	Écrit un événement à l’aide de l’identificateur d’événement et des arguments de chaînes et d’entiers 64 bits fournis.
WriteEvent(Int32, Int64, Int64)	Écrit un événement à l'aide de l'identificateur d'événement et des arguments d'une valeur de 64 octets fournis.
WriteEvent(Int32, Int32, Int32)	Écrit un événement à l’aide de l’identificateur d’événement et des arguments en entier d’une valeur de 32 octets fournis.
WriteEvent(Int32, Int32, String)	Écrit un événement à l'aide de l'identificateur d'événement et des arguments de chaînes et d'entiers 32 bits fournis.
WriteEvent(Int32, String)	Écrit un événement à l'aide de l'identificateur d'événement et de l'argument de chaîne fournis.
WriteEvent(Int32, Object[])	Écrit un événement à l’aide de l’identificateur d’événement et du tableau d’arguments fournis.
WriteEvent(Int32, Int64)	Écrit un événement à l'aide de l'identificateur d'événement et de l'argument en entier d'une valeur de 64 octets fournis.
WriteEvent(Int32, Int32)	Écrit un événement à l’aide de l’identificateur d’événement et de l’argument en entier d’une valeur de 32 octets fournis.
WriteEvent(Int32, EventSource+EventSourcePrimitive[])	Écrit un événement à l’aide de l’identificateur d’événement fourni et d’un nombre variable de primitives sources d’événements.
WriteEvent(Int32, Byte[])	Écrit un événement à l'aide de l'identificateur d'événement et de l'argument de tableau d'octets fournis.
WriteEvent(Int32)	Écrit un événement à l'aide de l'identificateur d'événement fourni.
WriteEvent(Int32, Int64, Byte[])	Écrit les données d’événements à l’aide de l’identificateur et des arguments de tableau de chaînes et d’entiers 64 bits spécifiés.

Remarques

La WriteEvent méthode fournit des surcharges avec des combinaisons d’arguments de chaîne et d’arguments entiers. Si aucune de ces combinaisons ne correspond aux paramètres de l’appel, le compilateur utilise la EventSource.WriteEvent(Int32, Object[]) surcharge, qui est considérablement plus lente que les autres surcharges. Pour plus d’informations, consultez la page de surcharge.

Dans tous les cas, le eventid paramètre doit être supérieur à 0 ou inférieur à 65535, sinon des erreurs peuvent se produire dans l’opération. Si des erreurs se produisent, vous pouvez obtenir plus d’informations sur la source de l’erreur en vérifiant le flux de sortie du débogueur, si vous avez un débogueur attaché aux événements de déclenchement du processus. Vous pouvez également rechercher les erreurs signalées dans le flux d’événements ETW, si vous avez un écouteur ETW sur la source d’événement où l’erreur se produit.

Lorsque vous implémentez une méthode identifiée en tant qu’événement ETW dans une EventSourceclasse dérivée. Vous devez appeler la méthode de classe WriteEvent de base en passant le EventId et les mêmes arguments que la méthode implémentée, comme dans l’exemple suivant.

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

Vous pouvez également créer une surcharge personnalisée à l’aide de la WriteEventCore méthode .

Important

Les paramètres d’événement avec un type de ne doivent pas inclure de string\0 caractères. Ils ne sont pas pris en charge et peuvent entraîner des problèmes pour les analyseurs de la charge utile de l’événement.

WriteEvent(Int32, String, String, String)

Source:: EventSource.cs

Source:: EventSource.cs

Source:: EventSource.cs

Écrit un événement à l’aide de l’identificateur d’événement et des arguments de chaîne fournis.

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)

Paramètres

eventId: Int32

Identificateur de l'événement. La valeur doit être comprise entre 0 et 65535.

arg1: String

Argument de chaîne.

arg2: String

Argument de chaîne.

arg3: String

Argument de chaîne.

Remarques

eventid doit être supérieur à 0 ou inférieur à 65535 ou des erreurs peuvent se produire dans l’opération. Si des erreurs se produisent, vous pouvez obtenir plus d’informations sur la source de l’erreur en vérifiant le flux de sortie du débogueur, si vous avez un débogueur attaché aux événements de déclenchement du processus. Vous pouvez également rechercher les erreurs signalées dans le flux d’événements ETW, si vous avez un écouteur ETW sur la source d’événement où l’erreur se produit.

Lorsque vous implémentez une méthode identifiée comme un événement ETW dans une EventSourceclasse dérivée. Vous devez appeler la méthode de classe WriteEvent de base en passant le EventId et les mêmes arguments que la méthode implémentée, comme dans l’exemple suivant.

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

S’applique à

WriteEvent(Int32, String, Int32, Int32)

Source:: EventSource.cs

Source:: EventSource.cs

Source:: EventSource.cs

Écrit un événement à l’aide de l’identificateur d’événement et d’arguments fournis.

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)

Paramètres

eventId: Int32

Identificateur de l'événement. La valeur doit être comprise entre 0 et 65535.

arg1: String

Argument de chaîne.

arg2: Int32

Argument entier 32 bits.

arg3: Int32

Argument entier 32 bits.

Remarques

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

S’applique à

WriteEvent(Int32, Int64, Int64, Int64)

Source:: EventSource.cs

Source:: EventSource.cs

Source:: EventSource.cs

Écrit un événement à l'aide de l'identificateur d'événement et des arguments d'une valeur de 64 octets fournis.

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)

Paramètres

eventId: Int32

Identificateur de l'événement. La valeur doit être comprise entre 0 et 65535.

arg1: Int64

Argument entier 64 bits.

arg2: Int64

Argument entier 64 bits.

arg3: Int64

Argument entier 64 bits.

Remarques

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

S’applique à

WriteEvent(Int32, Int32, Int32, Int32)

Source:: EventSource.cs

Source:: EventSource.cs

Source:: EventSource.cs

Écrit un événement à l’aide de l’identificateur d’événement et des arguments en entier d’une valeur de 32 octets fournis.

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)

Paramètres

eventId: Int32

Identificateur de l'événement. La valeur doit être comprise entre 0 et 65535.

arg1: Int32

Argument entier.

arg2: Int32

Argument entier.

arg3: Int32

Argument entier.

Remarques

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

S’applique à

WriteEvent(Int32, String, String)

Source:: EventSource.cs

Source:: EventSource.cs

Source:: EventSource.cs

Écrit un événement à l’aide de l’identificateur d’événement et des arguments de chaîne fournis.

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)

Paramètres

eventId: Int32

Identificateur de l'événement. La valeur doit être comprise entre 0 et 65535.

arg1: String

Argument de chaîne.

arg2: String

Argument de chaîne.

Remarques

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

S’applique à

WriteEvent(Int32, String, Int64)

Source:: EventSource.cs

Source:: EventSource.cs

Source:: EventSource.cs

Écrit un événement à l’aide de l’identificateur d’événement et d’arguments fournis.

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)

Paramètres

eventId: Int32

Identificateur de l'événement. La valeur doit être comprise entre 0 et 65535.

arg1: String

Argument de chaîne.

arg2: Int64

Argument entier 64 bits.

Remarques

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

S’applique à

WriteEvent(Int32, String, Int32)

Source:: EventSource.cs

Source:: EventSource.cs

Source:: EventSource.cs

Écrit un événement à l’aide de l’identificateur d’événement et d’arguments fournis.

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)

Paramètres

eventId: Int32

Identificateur de l'événement. La valeur doit être comprise entre 0 et 65535.

arg1: String

Argument de chaîne.

arg2: Int32

Argument entier 32 bits.

Remarques

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

S’applique à

WriteEvent(Int32, Int64, String)

Source:: EventSource.cs

Source:: EventSource.cs

Source:: EventSource.cs

Écrit un événement à l’aide de l’identificateur d’événement et des arguments de chaînes et d’entiers 64 bits fournis.

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)

Paramètres

eventId: Int32

Identificateur de l'événement. La valeur doit être comprise entre 0 et 65535.

arg1: Int64

Argument entier 64 bits.

arg2: String

Argument de chaîne.

Remarques

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

S’applique à

WriteEvent(Int32, Int64, Int64)

Source:: EventSource.cs

Source:: EventSource.cs

Source:: EventSource.cs

Écrit un événement à l'aide de l'identificateur d'événement et des arguments d'une valeur de 64 octets fournis.

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)

Paramètres

eventId: Int32

Identificateur de l'événement. La valeur doit être comprise entre 0 et 65535.

arg1: Int64

Argument entier 64 bits.

arg2: Int64

Argument entier 64 bits.

Remarques

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

S’applique à

WriteEvent(Int32, Int32, Int32)

Source:: EventSource.cs

Source:: EventSource.cs

Source:: EventSource.cs

Écrit un événement à l’aide de l’identificateur d’événement et des arguments en entier d’une valeur de 32 octets fournis.

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)

Paramètres

eventId: Int32

Identificateur de l'événement. La valeur doit être comprise entre 0 et 65535.

arg1: Int32

Argument entier.

arg2: Int32

Argument entier.

Remarques

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

S’applique à

WriteEvent(Int32, Int32, String)

Source:: EventSource.cs

Source:: EventSource.cs

Source:: EventSource.cs

Écrit un événement à l'aide de l'identificateur d'événement et des arguments de chaînes et d'entiers 32 bits fournis.

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)

Paramètres

eventId: Int32

Identificateur de l'événement. La valeur doit être comprise entre 0 et 65535.

arg1: Int32

Argument entier 32 bits.

arg2: String

Argument de chaîne.

S’applique à

WriteEvent(Int32, String)

Source:: EventSource.cs

Source:: EventSource.cs

Source:: EventSource.cs

Écrit un événement à l'aide de l'identificateur d'événement et de l'argument de chaîne fournis.

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)

Paramètres

eventId: Int32

Identificateur de l'événement. La valeur doit être comprise entre 0 et 65535.

arg1: String

Argument de chaîne.

Exemples

L’exemple suivant montre comment utiliser cette surcharge de méthode pour écrire un événement. Cet exemple de code fait partie d’un exemple plus grand fourni pour 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

Remarques

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

S’applique à

WriteEvent(Int32, Object[])

Source:: EventSource.cs

Source:: EventSource.cs

Source:: EventSource.cs

Écrit un événement à l’aide de l’identificateur d’événement et du tableau d’arguments fournis.

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

Paramètres

eventId: Int32

Identificateur de l'événement. La valeur doit être comprise entre 0 et 65535.

args: Object[]

Tableau d'objets .

Remarques

Par défaut, le compilateur appelle cette surcharge si les paramètres de l’appel ne correspondent pas à l’une des autres surcharges de méthode. Cette surcharge est beaucoup plus lente que les autres surcharges, car elle effectue les opérations suivantes :

Il alloue un tableau pour contenir l’argument variable.
Il caste chaque paramètre en objet (ce qui provoque des allocations pour les types primitifs).
Il affecte ces objets au tableau.
Il appelle la fonction, qui détermine ensuite le type de chaque argument afin qu’il puisse être sérialisé pour ETW.

La surcharge élevée liée à cette surcharge n’est pas significative lors du suivi d’événements à faible volume, car la méthode n’est utilisée que lorsque le fournisseur est activé. Toutefois, pour les événements à volume élevé, la surcharge de performances peut être importante. Vous pouvez éviter d’utiliser EventSource.WriteEvent pour les charges utiles à volume élevé en créant une surcharge plus rapide avec la WriteEventCore méthode .

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

S’applique à

WriteEvent(Int32, Int64)

Source:: EventSource.cs

Source:: EventSource.cs

Source:: EventSource.cs

Écrit un événement à l'aide de l'identificateur d'événement et de l'argument en entier d'une valeur de 64 octets fournis.

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)

Paramètres

eventId: Int32

Identificateur de l'événement. La valeur doit être comprise entre 0 et 65535.

arg1: Int64

Argument entier 64 bits.

Remarques

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

S’applique à

WriteEvent(Int32, Int32)

Source:: EventSource.cs

Source:: EventSource.cs

Source:: EventSource.cs

Écrit un événement à l’aide de l’identificateur d’événement et de l’argument en entier d’une valeur de 32 octets fournis.

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)

Paramètres

eventId: Int32

Identificateur de l'événement. La valeur doit être comprise entre 0 et 65535.

arg1: Int32

Argument entier.

Exemples

L’exemple suivant montre comment utiliser cette surcharge de méthode pour écrire un événement. Cet exemple de code fait partie d’un exemple plus grand fourni pour 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

Remarques

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

S’applique à

WriteEvent(Int32, EventSource+EventSourcePrimitive[])

Source:: EventSource.cs

Source:: EventSource.cs

Écrit un événement à l’aide de l’identificateur d’événement fourni et d’un nombre variable de primitives de source d’événement.

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

Paramètres

eventId: Int32

Identificateur de l'événement. La valeur doit être comprise entre 0 et 65535.

args: EventSource.EventSourcePrimitive[]

Primitives de la source d’événement.

Remarques

Il s’agit d’une assistance varargs pour l’écriture d’un événement. Il crée un tableau et boxe tous les arguments de sorte qu’il est relativement inefficace et ne doit être utilisé que pour des événements relativement rares (par exemple, moins de 100 par seconde). Si vos taux sont plus rapides que cela, utilisez WriteEventCore(Int32, Int32, EventSource+EventData*) pour créer des helpers rapides pour votre signature de méthode particulière. Même si vous l’utilisez pour des événements rares, cet appel doit être protégé par un IsEnabled() case activée afin que l’appel varargs ne soit pas effectué lorsque eventSource n’est pas actif.

S’applique à

WriteEvent(Int32, Byte[])

Source:: EventSource.cs

Source:: EventSource.cs

Source:: EventSource.cs

Écrit un événement à l'aide de l'identificateur d'événement et de l'argument de tableau d'octets fournis.

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

Paramètres

eventId: Int32

Identificateur de l'événement. La valeur doit être comprise entre 0 et 65535.

arg1: Byte[]

Argument de tableau d’octets.

Remarques

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

S’applique à

WriteEvent(Int32)

Source:: EventSource.cs

Source:: EventSource.cs

Source:: EventSource.cs

Écrit un événement à l'aide de l'identificateur d'événement fourni.

protected:
 void WriteEvent(int eventId);

protected void WriteEvent (int eventId);

member this.WriteEvent : int -> unit

Protected Sub WriteEvent (eventId As Integer)

Paramètres

eventId: Int32

Identificateur de l'événement. La valeur doit être comprise entre 0 et 65535.

Exemples

L’exemple suivant montre comment utiliser cette surcharge de méthode pour écrire un événement. Cet exemple de code fait partie d’un exemple plus grand fourni pour 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

Remarques

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

S’applique à

WriteEvent(Int32, Int64, Byte[])

Source:: EventSource.cs

Source:: EventSource.cs

Source:: EventSource.cs

Écrit les données d’événements à l’aide de l’identificateur et des arguments de tableau de chaînes et d’entiers 64 bits spécifiés.

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

Paramètres

eventId: Int32

Identificateur de l'événement. La valeur doit être comprise entre 0 et 65535.

arg1: Int64

Argument entier 64 bits.

arg2: Byte[]

Argument de tableau d’octets.

Remarques

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

S’applique à