EventSource.WriteEvent Méthode

Définition

Espace de noms:

System.Diagnostics.Tracing

Assemblys:

netstandard.dll, System.Diagnostics.Tracing.dll

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

Surcharges

Nom	Description
WriteEvent(Int32, String, Int32)	Écrit un événement à l’aide de l’identificateur d’événement et des arguments fournis.
WriteEvent(Int32, String, Int64)	Écrit un événement à l’aide de l’identificateur d’événement et des arguments 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)	Écrit un événement à l’aide de l’identificateur d’événement et de l’argument de chaîne fournis.
WriteEvent(Int32, Int64, Int64, Int64)	Écrit un événement à l’aide de l’identificateur d’événement fourni et des arguments 64 bits.
WriteEvent(Int32, String, Int32, Int32)	Écrit un événement à l’aide de l’identificateur d’événement et des arguments fournis.
WriteEvent(Int32, Int64, String)	Écrit un événement à l’aide de l’identificateur d’événement fourni et de l’entier 64 bits et des arguments de chaîne.
WriteEvent(Int32, Int32, Int32, Int32)	Écrit un événement à l’aide de l’identificateur d’événement fourni et des arguments entiers 32 bits.
WriteEvent(Int32, Int64, Int64)	Écrit un événement à l’aide de l’identificateur d’événement fourni et des arguments 64 bits.
WriteEvent(Int32, Object[])	Écrit un événement à l’aide de l’identificateur d’événement fourni et du tableau d’arguments.
WriteEvent(Int32, Int32, String)	Écrit un événement à l’aide de l’identificateur d’événement fourni et des arguments d’entier et de chaîne 32 bits.
WriteEvent(Int32, Int32, Int32)	Écrit un événement à l’aide de l’identificateur d’événement fourni et des arguments entiers 32 bits.
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, Int64)	Écrit un événement à l’aide de l’identificateur d’événement fourni et de l’argument entier 64 bits.
WriteEvent(Int32, Int32)	Écrit un événement à l’aide de l’identificateur d’événement fourni et de l’argument entier 32 bits.
WriteEvent(Int32, EventSource+EventSourcePrimitive[])	É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.
WriteEvent(Int32, Byte[])	Écrit un événement à l’aide de l’identificateur d’événement fourni et de l’argument de tableau d’octets.
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énement à l’aide de l’identificateur spécifié et des arguments de tableau d’octets et entiers 64 bits.

Remarques

La WriteEvent méthode fournit des surcharges avec des combinaisons d’arguments de chaîne et d’entier. Si aucune de ces combinaisons ne correspond aux paramètres de l’appel, le compilateur utilise la EventSource.WriteEvent(Int32, Object[]) surcharge, ce qui est beaucoup plus lent 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 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 des erreurs signalées dans le flux d’événements ETW, si vous disposez d’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 qui transmet les EventId arguments et les mêmes arguments que la méthode implémentée semblable à 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 caractères ne doivent pas inclure \0 de string caractères. Ils ne sont pas pris en charge et peuvent provoquer des problèmes pour les analyseurs de la charge utile de l’événement.

WriteEvent(Int32, String, Int32)

Source:

EventSource.cs

Écrit un événement à l’aide de l’identificateur d’événement et des 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 d’événement. Cette 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 des erreurs signalées dans le flux d’événements ETW, si vous disposez d’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 qui transmet les EventId arguments et les mêmes arguments que la méthode implémentée semblable à 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 des 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 d’événement. Cette 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 des erreurs signalées dans le flux d’événements ETW, si vous disposez d’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 qui transmet les EventId arguments et les mêmes arguments que la méthode implémentée semblable à 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 d’événement. Cette 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 des erreurs signalées dans le flux d’événements ETW, si vous disposez d’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 qui transmet les EventId arguments et les mêmes arguments que la méthode implémentée semblable à l’exemple suivant.

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

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 d’événement. Cette 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 classe EventSource .

[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 des erreurs signalées dans le flux d’événements ETW, si vous disposez d’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 qui transmet les EventId arguments et les mêmes arguments que la méthode implémentée semblable à 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 fourni et des arguments 64 bits.

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 d’événement. Cette 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 des erreurs signalées dans le flux d’événements ETW, si vous disposez d’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 qui transmet les EventId arguments et les mêmes arguments que la méthode implémentée semblable à 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 des 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 d’événement. Cette 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 des erreurs signalées dans le flux d’événements ETW, si vous disposez d’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 qui transmet les EventId arguments et les mêmes arguments que la méthode implémentée semblable à 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 fourni et de l’entier 64 bits et des arguments de chaîne.

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 d’événement. Cette 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 des erreurs signalées dans le flux d’événements ETW, si vous disposez d’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 qui transmet les EventId arguments et les mêmes arguments que la méthode implémentée semblable à l’exemple suivant.

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

WriteEvent(Int32, Int32, Int32, Int32)

Source:

EventSource.cs

Écrit un événement à l’aide de l’identificateur d’événement fourni et des arguments entiers 32 bits.

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 d’événement. Cette 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 des erreurs signalées dans le flux d’événements ETW, si vous disposez d’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 qui transmet les EventId arguments et les mêmes arguments que la méthode implémentée semblable à l’exemple suivant.

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

WriteEvent(Int32, Int64, Int64)

Source:

EventSource.cs

Écrit un événement à l’aide de l’identificateur d’événement fourni et des arguments 64 bits.

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 d’événement. Cette 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 des erreurs signalées dans le flux d’événements ETW, si vous disposez d’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 qui transmet les EventId arguments et les mêmes arguments que la méthode implémentée semblable à 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 fourni et du tableau d’arguments.

protected:
 void WriteEvent(int eventId, ... cli::array <System::Object ^> ^ args);

[System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("EventSource will serialize the whole object graph. Trimmer will not safely handle this case because properties may be trimmed. This can be suppressed if the object is a primitive type")]
protected void WriteEvent(int eventId, params object?[] args);

[<System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("EventSource will serialize the whole object graph. Trimmer will not safely handle this case because properties may be trimmed. This can be suppressed if the object is a primitive type")>]
member this.WriteEvent : int * obj[] -> unit

Protected Sub WriteEvent (eventId As Integer, ParamArray args As Object())

Paramètres

eventId

Int32

Identificateur d’événement. Cette valeur doit être comprise entre 0 et 65535.

args

Object[]

Tableau d'objets .

Attributs

RequiresUnreferencedCodeAttribute

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 convertit 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’elle puisse être sérialisée 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 à 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 et 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 des erreurs signalées dans le flux d’événements ETW, si vous disposez d’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 qui transmet les EventId arguments et les mêmes arguments que la méthode implémentée semblable à l’exemple suivant.

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

WriteEvent(Int32, Int32, String)

Source:

EventSource.cs

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

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 d’événement. Cette valeur doit être comprise entre 0 et 65535.

arg1

Int32

Argument entier 32 bits.

arg2

String

Argument de chaîne.

WriteEvent(Int32, Int32, Int32)

Source:

EventSource.cs

Écrit un événement à l’aide de l’identificateur d’événement fourni et des arguments entiers 32 bits.

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 d’événement. Cette 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 des erreurs signalées dans le flux d’événements ETW, si vous disposez d’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 qui transmet les EventId arguments et les mêmes arguments que la méthode implémentée semblable à l’exemple suivant.

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

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 d’événement. Cette 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 des erreurs signalées dans le flux d’événements ETW, si vous disposez d’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 qui transmet les EventId arguments et les mêmes arguments que la méthode implémentée semblable à 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 fourni et de l’argument entier 64 bits.

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 d’événement. Cette 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 des erreurs signalées dans le flux d’événements ETW, si vous disposez d’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 qui transmet les EventId arguments et les mêmes arguments que la méthode implémentée semblable à 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 fourni et de l’argument entier 32 bits.

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 d’événement. Cette 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 classe EventSource .

[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 des erreurs signalées dans le flux d’événements ETW, si vous disposez d’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 qui transmet les EventId arguments et les mêmes arguments que la méthode implémentée semblable à 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 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 d’événement. Cette valeur doit être comprise entre 0 et 65535.

args

EventSource.EventSourcePrimitive[]

Primitives de la source d’événement.

Remarques

Il s’agit d’un assistance varargs pour écrire 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 utilisez ceci pour des événements rares, cet appel doit être protégé par une IsEnabled() vérification 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 fourni et de l’argument de tableau d’octets.

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 d’événement. Cette 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 des erreurs signalées dans le flux d’événements ETW, si vous disposez d’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 qui transmet les EventId arguments et les mêmes arguments que la méthode implémentée semblable à 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 d’événement. Cette 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 classe EventSource .

[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 des erreurs signalées dans le flux d’événements ETW, si vous disposez d’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 qui transmet les EventId arguments et les mêmes arguments que la méthode implémentée semblable à 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énement à l’aide de l’identificateur spécifié et des arguments de tableau d’octets et entiers 64 bits.

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 d’événement. Cette 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 des erreurs signalées dans le flux d’événements ETW, si vous disposez d’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 qui transmet les EventId arguments et les mêmes arguments que la méthode implémentée semblable à l’exemple suivant.

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