EventSource.WriteEvent Méthode

Définition

Espace de noms:

System.Diagnostics.Tracing

Assembly:

System.Diagnostics.Tracing.dll

É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 chaîne et entier. 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 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);
}

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. Il s’agit de caractères non 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

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

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

WriteEvent(Int32, String, Int32, Int32)

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

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

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

WriteEvent(Int32, Int64, Int64, Int64)

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

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

WriteEvent(Int32, Int32, Int32, Int32)

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

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

WriteEvent(Int32, String, String)

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

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

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

WriteEvent(Int32, String, Int64)

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

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

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

WriteEvent(Int32, String, Int32)

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

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

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

WriteEvent(Int32, Int64, String)

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

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

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 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(Int64 arg1, string arg2)
{
    base.WriteEvent(2, arg1, arg2);
}

WriteEvent(Int32, Int64, Int64)

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

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

WriteEvent(Int32, Int32, Int32)

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

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 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(int arg1, int arg2, int arg3)
{
    base.WriteEvent(2, arg1);
}

WriteEvent(Int32, Int32, String)

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

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.

WriteEvent(Int32, String)

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

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

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

WriteEvent(Int32, Object[])

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

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 :

1. Il alloue un tableau pour contenir l’argument de variable.

2. Il caste chaque paramètre en objet (ce qui provoque des allocations pour les types primitifs).

3. Il affecte ces objets au tableau.

4. 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 pour cette surcharge n’est pas significative lors du suivi des événements à faible volume, car la méthode est utilisée uniquement lorsque le fournisseur est activé. Toutefois, pour les événements de 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 nouvelle surcharge plus rapide avec la WriteEventCore méthode .

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

WriteEvent(Int32, Int64)

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

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

WriteEvent(Int32, Int32)

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

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 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(int  arg1)
{
    base.WriteEvent(2, arg1);
}

WriteEvent(Int32, EventSource+EventSourcePrimitive[])

Source:

EventSource.cs

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

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énements.

Remarques

Il s’agit d’un varargs helper pour l’écriture d’un événement. Il crée un tableau et boxe tous les arguments afin qu’il soit relativement inefficace et ne doit être utilisé que pour des événements relativement rares (par exemple, moins de 100 par seconde). Si vos tarifs sont plus rapides que cela, utilisez WriteEventCore(Int32, Int32, EventSource+EventData*) pour créer des assistances 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.

WriteEvent(Int32, Byte[])

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

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

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(byte[] arg1)
{
    base.WriteEvent(2, arg1);
}

WriteEvent(Int32)

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

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

WriteEvent(Int32, Int64, Byte[])

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

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

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(Int64 arg1, Byte[] arg2)
{
    base.WriteEvent(2, arg1, arg2);
}