EventLog.EntryWritten Événement

Définition

Espace de noms:

System.Diagnostics

Assembly:

System.Diagnostics.EventLog.dll

Paquet:

System.Diagnostics.EventLog v8.0.0

Source:

EventLog.cs

Se produit quand une entrée est écrite dans un journal des événements sur l'ordinateur local.

public:
 event System::Diagnostics::EntryWrittenEventHandler ^ EntryWritten;

public event System.Diagnostics.EntryWrittenEventHandler EntryWritten;

member this.EntryWritten : System.Diagnostics.EntryWrittenEventHandler 

Public Custom Event EntryWritten As EntryWrittenEventHandler 

Type d'événement

EntryWrittenEventHandler

Exemples

L’exemple suivant gère un événement écrit d’entrée.

#using <System.dll>

using namespace System;
using namespace System::Diagnostics;
using namespace System::Threading;
ref class MySample
{
private:

   // This member is used to wait for events.
   static AutoResetEvent^ signal;

public:
   static void main()
   {
      signal = gcnew AutoResetEvent( false );
      EventLog^ myNewLog = gcnew EventLog;
      myNewLog->Source = "testEventLogEvent";
      myNewLog->EntryWritten += gcnew EntryWrittenEventHandler( MyOnEntryWritten );
      myNewLog->EnableRaisingEvents = true;
      myNewLog->WriteEntry("Test message", EventLogEntryType::Information);
      signal->WaitOne();
   }

   static void MyOnEntryWritten( Object^ /*source*/, EntryWrittenEventArgs^ /*e*/ )
   {
      Console::WriteLine("In event handler");
      signal->Set();
   }

};

int main()
{
   MySample::main();
}

using System;
using System.Diagnostics;
using System.Threading;

class MySample{

    // This member is used to wait for events.
    static AutoResetEvent signal;

    public static void Main(){

        signal = new AutoResetEvent(false);
        EventLog myNewLog = new EventLog("Application", ".", "testEventLogEvent");

        myNewLog.EntryWritten += new EntryWrittenEventHandler(MyOnEntryWritten);
        myNewLog.EnableRaisingEvents = true;
        myNewLog.WriteEntry("Test message", EventLogEntryType.Information);
        signal.WaitOne();
    }

    public static void MyOnEntryWritten(object source, EntryWrittenEventArgs e){
        Console.WriteLine("In event handler");
        signal.Set();
    }
}

Option Explicit On 
Option Strict On

Imports System.Diagnostics
Imports System.Threading


Class MySample

    ' This member is used to wait for events.
    Private Shared signal As AutoResetEvent


    Public Shared Sub Main()

        signal = New AutoResetEvent(False)
        Dim myNewLog As New EventLog("Application", ".", "testEventLogEvent")

        AddHandler myNewLog.EntryWritten, AddressOf MyOnEntryWritten
        myNewLog.EnableRaisingEvents = True
        myNewLog.WriteEntry("Test message", EventLogEntryType.Information)

        signal.WaitOne()
    End Sub


    Public Shared Sub MyOnEntryWritten(ByVal [source] As Object, ByVal e As EntryWrittenEventArgs)
        Console.WriteLine("In event handler")
        signal.Set()
    End Sub
End Class

Remarques

Pour obtenir des notifications d’événements, vous devez définir sur EnableRaisingEventstrue. Vous ne pouvez recevoir des notifications d’événement que lorsque les entrées sont écrites sur l’ordinateur local. Vous ne pouvez pas recevoir de notifications pour les entrées écrites sur des ordinateurs distants.

Lorsque vous créez un délégué EntryWritten, vous identifiez la méthode qui gérera l'événement. Pour associer l'événement au gestionnaire d'événements, ajoutez une instance du délégué à l'événement. Le gestionnaire d’événements est appelé chaque fois que l’événement se produit, jusqu’à ce que vous supprimiez le délégué. Pour plus d’informations sur la gestion des événements avec des délégués, consultez Gestion et déclenchement d’événements.

Le système répond uniquement si WriteEntry le dernier événement d’écriture s’est produit au moins six secondes auparavant. Cela implique que vous ne recevrez qu’une EntryWritten seule notification d’événement dans un intervalle de six secondes, même si plusieurs modifications du journal des événements se produisent. Si vous insérez un intervalle de veille suffisamment long (environ 10 secondes) entre les appels à WriteEntry, vous êtes moins susceptible de manquer un événement. Toutefois, si les événements d’écriture se produisent plus fréquemment, vous risquez de ne pas recevoir la notification d’événement avant l’intervalle suivant. En règle générale, les notifications d’événements manqués ne sont pas perdues, mais retardées.

Voir aussi

• EnableRaisingEvents