ManagementOperationObserver Konstruktor
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Initialisiert eine neue Instanz der ManagementOperationObserver-Klasse. Dies ist der parameterlose Konstruktor.
public:
ManagementOperationObserver();
public ManagementOperationObserver ();
Public Sub New ()
Beispiele
Im folgenden Beispiel wird veranschaulicht, wie eine asynchrone instance-Enumeration ausgeführt wird. Im Beispiel wird die ManagementOperationObserver -Klasse verwendet, um Verwaltungsinformationen und -ereignisse asynchron zu behandeln.
using System;
using System.Management;
// This example demonstrates how
// to perform an asynchronous instance enumeration.
public class EnumerateInstancesAsync
{
public EnumerateInstancesAsync()
{
// Enumerate asynchronously using Object Searcher
// ===============================================
// Instantiate an object searcher with the query
ManagementObjectSearcher searcher =
new ManagementObjectSearcher(new
SelectQuery("Win32_Service"));
// Create a results watcher object,
// and handler for results and completion
ManagementOperationObserver results = new
ManagementOperationObserver();
// Attach handler to events for results and completion
results.ObjectReady += new
ObjectReadyEventHandler(this.NewObject);
results.Completed += new
CompletedEventHandler(this.Done);
// Call the asynchronous overload of Get()
// to start the enumeration
searcher.Get(results);
// Do something else while results
// arrive asynchronously
while (!this.Completed)
{
System.Threading.Thread.Sleep (1000);
}
this.Reset();
}
private bool isCompleted = false;
private void NewObject(object sender,
ObjectReadyEventArgs obj)
{
Console.WriteLine("Service : {0}, State = {1}",
obj.NewObject["Name"],
obj.NewObject["State"]);
}
private bool Completed
{
get
{
return isCompleted;
}
}
private void Reset()
{
isCompleted = false;
}
private void Done(object sender,
CompletedEventArgs obj)
{
isCompleted = true;
}
public static void Main()
{
EnumerateInstancesAsync example =
new EnumerateInstancesAsync();
return;
}
}
Imports System.Management
' This example demonstrates how
' to perform an asynchronous instance enumeration.
Public Class EnumerateInstancesAsync
Public Sub New()
Me.isCompleted = False
' Enumerate asynchronously using Object Searcher
' ===============================================
' Instantiate an object searcher with the query
Dim searcher As ManagementObjectSearcher
searcher = New ManagementObjectSearcher( _
New SelectQuery("Win32_Service"))
' Create a results watcher object,
' and handler for results and completion
Dim results As ManagementOperationObserver
results = New ManagementOperationObserver
' Attach handler to events for
' results and completion
AddHandler results.ObjectReady, _
AddressOf Me.NewObject
AddHandler results.Completed, _
AddressOf Me.Done
' Call the asynchronous overload of
' Get() to start the enumeration
searcher.Get(results)
' Do something else while results
' arrive(asynchronously)
Do While (Me.Completed.Equals(False))
System.Threading.Thread.Sleep(1000)
Loop
Me.Reset()
End Sub
Private isCompleted As Boolean
Private Sub NewObject(ByVal sender As Object, _
ByVal e As ObjectReadyEventArgs)
Console.WriteLine("Service : {0}, State = {1}", _
e.NewObject("Name"), e.NewObject("State"))
End Sub
Private ReadOnly Property Completed() As Boolean
Get
Return isCompleted
End Get
End Property
Private Sub Reset()
isCompleted = False
End Sub
Private Sub Done(ByVal sender As Object, _
ByVal e As CompletedEventArgs)
isCompleted = True
End Sub
Public Shared Function _
Main(ByVal args() As String) As Integer
Dim example As New EnumerateInstancesAsync
Return 0
End Function
End Class
Hinweise
.NET Framework-Sicherheit
Volle Vertrauenswürdigkeit für den unmittelbaren Aufrufer. Dieser Member kann von nur teilweise vertrauenswürdigem Code nicht verwendet werden. Weitere Informationen finden Sie unter Verwenden von Bibliotheken aus teilweise vertrauenswürdigem Code.