Abonnieren und Verwenden von Verwaltungsereignissen

Der System.Management-Namespace stellt Einrichtungen zum Abonnieren von Verwaltungsereignissen zur Verfügung. WMI-Ereignisse sind Benachrichtigungen zu bestimmten Vorfällen im Betriebssystem, bzw. in Geräten oder Anwendungen in der verwalteten Umgebung. Verwaltungsclients können relevante Ereignisse abonnieren, indem eine Ereignisabfrage definiert wird, die sowohl den Typ der gewünschten Ereignisse als auch eine Reihe von Bedingungen angibt, mit denen die zurückgegebenen Ereignisse weiter gefiltert werden können. Der Ereignisverbrauch kann sowohl synchron als auch asynchron durchgeführt werden. Ausführliche Informationen zu Ereignissen in WMI finden Sie in der WMI-Dokumentation in MSDN.

Im folgenden Codebeispiel wird demonstriert, wie systeminterne WMI-Ereignisse abonniert und synchron verwendet werden. Das Beispiel erstellt eine Ereignisabfrage, verwendet diese zum Auslösen eines ManagementEventWatcher-Objekts und wartet anschließend auf die Rückgabe der Ereignisse, die den angegebenen Filterkriterien entsprechen.

using System;
using System.Management;

// This example shows synchronous consumption of events. The client 
// is blocked while waiting for events. See additional example for
// asynchronous event handling.

public class EventWatcherPolling {
   public static int Main(string[] args) {
      // Create event query to be notified within 1 second of 
      // a change in a service
      WqlEventQuery query = 
         new WqlEventQuery("__InstanceModificationEvent", 
                         new TimeSpan(0,0,1), 
                       "TargetInstance isa \"Win32_Service\"");

      // Initialize an event watcher and subscribe to events 
      // that match this query
      ManagementEventWatcher watcher = new ManagementEventWatcher(query);
      
      // Block until the next event occurs 
      // Note: this can be done in a loop if waiting for 
      //        more than one occurrence
      ManagementBaseObject e = watcher.WaitForNextEvent();

      //Display information from the event
      Console.WriteLine(
         "Service {0} has changed, State is {1}", 
          ((ManagementBaseObject)e["TargetInstance"])["Name"],
          ((ManagementBaseObject)e["TargetInstance"])["State"]);

      //Cancel the subscription
      watcher.Stop();
      return 0;
    }
}

[Visual Basic]
Imports System
Imports System.Management

' This example shows synchronous consumption of events. The client 
' is blocked while waiting for events. See additional example for 
' asynchronous event handling.

Public Class EventWatcherPolling   
   Overloads Public Shared Function Main(args() As String) As Integer
      ' Create event query to be notified within 1 second of 
      ' a change in a service
      Dim query As New WqlEventQuery( _
         "__InstanceModificationEvent", _
         New TimeSpan(0, 0, 1), _
         "TargetInstance isa ""Win32_Service""")

      ' Initialize an event watcher and subscribe to events 
      ' that match this query
      Dim watcher As New ManagementEventWatcher(query)

      'Block until the next event occurs 
      'Note: this can be done in a loop if waiting for more 
      '       than one occurrence
      Dim e As ManagementBaseObject = watcher.WaitForNextEvent()

      'Display information from the event
      Console.WriteLine( _
         "Service {0} has changed, State is {1}", _ 
         CType(e("TargetInstance"), ManagementBaseObject)("Name"), _
         CType(e("TargetInstance"), ManagementBaseObject)("State"))

      'Cancel the subscription
      watcher.Stop()
      Return 0
   End Function 'Main
End Class 'EventWatcherPolling

Im folgenden Codebeispiel werden Ereignisse asynchron verwendet. In diesem Fall verwendet das Beispiel Zeitgeberereignisse, d. h., das Beispiel richtet einen WMI-Zeitgeber ein, der jede Sekunde ein Ereignis auslöst, und entfernt diesen Zeitgeber, sobald er nicht mehr benötigt wird. Das ManagementEventWatcher-Objekt definiert verschiedene .NET Framework-Ereignisse, die ausgelöst werden, sobald WMI-Ereignisse übermittelt werden. Diesen Ereignissen werden Delegaten angefügt, um eingehende Daten zu behandeln.

using System;
using System.Management;

// This example shows asynchronous consumption of events. In this example 
// you are listening for timer events. The first part of the example sets 
// up the timer.

public class EventWatcherAsync {
    public static int Main(string[] args) {
      // Set up a timer to raise events every 1 second
      //=============================================
      ManagementClass timerClass = 
         new ManagementClass("__IntervalTimerInstruction");
      ManagementObject timer = timerClass.CreateInstance();
      timer["TimerId"] = "Timer1";
      timer["IntervalBetweenEvents"] = 1000;
      timer.Put();

        // Set up the event consumer
      //==========================
      // Create event query to receive timer events
      WqlEventQuery query = 
         new WqlEventQuery("__TimerEvent", "TimerId=\"Timer1\"");

      // Initialize an event watcher and subscribe to 
      // events that match this query
      ManagementEventWatcher watcher = new ManagementEventWatcher(query);

      // Set up a listener for events
      watcher.EventArrived += 
         new EventArrivedEventHandler((new EventHandler()).HandleEvent);

      // Start listening
      watcher.Start();

      // Do something in the meantime
      System.Threading.Thread.Sleep(10000);
      
      // Stop listening
      watcher.Stop();
      return 0;
   }
}

public class EventHandler {
   public void HandleEvent(object sender, EventArrivedEventArgs e)   {
      Console.WriteLine("Event arrived !");
   }
}

[Visual Basic]
Imports System
Imports System.Management

' This example shows asynchronous consumption of events. In this example 
' you are listening for timer events. The first part of the example sets 
' up the timer.

Public Class EventWatcherAsync  
   Overloads Public Shared Function Main(args() As String) As Integer
      ' Set up a timer to raise events every 1 second
      '=============================================
      Dim timerClass As New ManagementClass("__IntervalTimerInstruction")
      Dim timer As ManagementObject = timerClass.CreateInstance()
      timer("TimerId") = "Timer1"
      timer("IntervalBetweenEvents") = 1000
      timer.Put()

      ' Set up the event consumer
      '==========================
      ' Create event query to receive timer events
      Dim query As New WqlEventQuery("__TimerEvent", "TimerId=""Timer1""")

      ' Initialize an event watcher and subscribe to 
      ' events that match this query
      Dim watcher As New ManagementEventWatcher(query)

      ' Set up a listener for events
      Dim handler As New EventHandler()
      AddHandler watcher.EventArrived, AddressOf handler.HandleEvent      

      ' Start listening
      watcher.Start()

      ' Do something in the meantime
      System.Threading.Thread.Sleep(10000)

      ' Stop listening
      watcher.Stop()
      Return 0
   End Function
End Class

Public Class EventHandler
   Public Sub HandleEvent(sender As Object, e As EventArrivedEventArgs)
      Console.WriteLine("Event arrived !")
   End Sub 
End Class 

Siehe auch

Zugreifen auf Verwaltungsdaten mit Hilfe von System.Management | Abrufen von Verwaltungsobjektauflistungen | Abfragen von Verwaltungsdaten | Ausführen von Methoden für Verwaltungsobjekte | Remote- und Verbindungsoptionen | Verwenden von Objekten mit starkem Typ