public static void AddRemoveUSBHandler(EventArrivedEventHandler usb)
{
ManagementEventWatcher w = null;
WqlEventQuery q;
ManagementScope scope = new ManagementScope("root\\CIMV2");
scope.Options.EnablePrivileges = true;
try
{
q = new WqlEventQuery();
q.EventClassName = "__InstanceDeletionEvent";
q.WithinInterval = new TimeSpan(0, 0, 3);
q.Condition = "TargetInstance ISA 'Win32_USBControllerdevice'";
w = new ManagementEventWatcher(scope, q);
w.EventArrived += usb;
w.Start();
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine(e.ToString());
if (w != null)
{
w.Stop();
}
}
}
public static ManagementEventWatcher GetWatcher(EventArrivedEventHandler handler)
{
WqlEventQuery query = new WqlEventQuery("__InstanceCreationEvent", new TimeSpan(0, 0, 1), "TargetInstance isa \"Win32_Process\"");
ManagementEventWatcher watcher = new ManagementEventWatcher(query);
watcher.EventArrived += new EventArrivedEventHandler(handler);
return watcher;
}
public Boolean AddUSBEventWatcher(EventArrivedEventHandler usbInsertHandler, EventArrivedEventHandler usbRemoveHandler, TimeSpan withinInterval)
{
try
{
ManagementScope Scope = new ManagementScope("root\\CIMV2");
Scope.Options.EnablePrivileges = true;
if (usbInsertHandler != null)
{
WqlEventQuery InsertQuery = new WqlEventQuery("__InstanceCreationEvent", withinInterval, "TargetInstance isa 'Win32_USBControllerDevice'");
insertWatcher = new ManagementEventWatcher(Scope, InsertQuery);
insertWatcher.EventArrived += usbInsertHandler;
insertWatcher.Start();
}
if (usbRemoveHandler != null)
{
WqlEventQuery RemoveQuery = new WqlEventQuery("__InstanceDeletionEvent", withinInterval, "TargetInstance isa 'Win32_USBControllerDevice'");
removeWatcher = new ManagementEventWatcher(Scope, RemoveQuery);
removeWatcher.EventArrived += usbRemoveHandler;
removeWatcher.Start();
}
return true;
}
catch (Exception)
{
RemoveUSBEventWatcher();
return false;
}
}
public bool AddUSBEventWatcher(EventArrivedEventHandler usbInsertHandler, EventArrivedEventHandler usbRemoveHandler, TimeSpan withinInterval)
{
try
{
ManagementScope scope = new ManagementScope(@"root\CIMV2")
{
Options = { EnablePrivileges = true }
};
if (usbInsertHandler != null)
{
WqlEventQuery query = new WqlEventQuery("__InstanceCreationEvent", withinInterval, "TargetInstance isa 'Win32_USBControllerDevice'");
this.insertWatcher = new ManagementEventWatcher(scope, query);
this.insertWatcher.EventArrived += usbInsertHandler;
this.insertWatcher.Start();
}
if (usbRemoveHandler != null)
{
WqlEventQuery query2 = new WqlEventQuery("__InstanceDeletionEvent", withinInterval, "TargetInstance isa 'Win32_USBControllerDevice'");
this.removeWatcher = new ManagementEventWatcher(scope, query2);
this.removeWatcher.EventArrived += usbRemoveHandler;
this.removeWatcher.Start();
}
return(true);
}
catch (Exception exception)
{
LogHelper.LogError(exception);
this.RemoveUSBEventWatcher();
return(false);
}
}
private ManagementEventWatcher InitializeHandler(EventArrivedEventHandler eventArrived, ManagementEventWatcher eventWatcher,
string eventClassName)
{
var managementScope = new ManagementScope("root\\CIMV2")
{
Options = { EnablePrivileges = true }
};
try
{
var wqlEventQuery = new WqlEventQuery
{
EventClassName = eventClassName,
WithinInterval = new TimeSpan(0, 0, 3),
Condition = "TargetInstance ISA 'Win32_USBControllerdevice'"
};
eventWatcher = new ManagementEventWatcher(managementScope, wqlEventQuery);
eventWatcher.EventArrived += eventArrived;
}
catch (Exception e)
{
MessageBox.Show(e.Message);
eventWatcher.Stop();
}
return(eventWatcher);
}
public Boolean AddUSBEventWatcher(EventArrivedEventHandler usbInsertHandler, EventArrivedEventHandler usbRemoveHandler, TimeSpan withinInterval)
{
try
{
ManagementScope Scope = new ManagementScope("root\\CIMV2");
Scope.Options.EnablePrivileges = true;
if (usbInsertHandler != null)
{
WqlEventQuery InsertQuery = new WqlEventQuery("__InstanceCreationEvent", withinInterval, "TargetInstance isa 'Win32_USBControllerDevice'");
insertWatcher = new ManagementEventWatcher(Scope, InsertQuery);
insertWatcher.EventArrived += usbInsertHandler;
insertWatcher.Start();
}
if (usbRemoveHandler != null)
{
WqlEventQuery RemoveQuery = new WqlEventQuery("__InstanceDeletionEvent", withinInterval, "TargetInstance isa 'Win32_USBControllerDevice'");
removeWatcher = new ManagementEventWatcher(Scope, RemoveQuery);
removeWatcher.EventArrived += usbRemoveHandler;
removeWatcher.Start();
}
return(true);
}
catch (Exception)
{
RemoveUSBEventWatcher();
return(false);
}
}
public WmiListener ListenForEvent(string eventname, EventArrivedEventHandler handler)
{
ManagementEventWatcher ev = GetListenerEvent(eventname);
ev.EventArrived += handler;
return(new WmiListener(ev));
}
public DriveWatcher(EventArrivedEventHandler createHandler, EventArrivedEventHandler deleteHandler)
{
try
{
_createWatcher = new ManagementEventWatcher(newCreateQuery());
_createWatcher.EventArrived += createHandler;
_createWatcher.Start();
}
catch (Exception ex)
{
string errlog = DateTime.Now + @" -Fail _createWatcher - " + ex.ToString() + "\r\n";
EventLog.Write(errlog);
}
try
{
_deleteWatcher = new ManagementEventWatcher(newdeleteQuery());
_deleteWatcher.EventArrived += deleteHandler;
_deleteWatcher.Start();
}
catch (Exception ex)
{
string errlog = DateTime.Now + @" -Fail _deleteWatcher - " + ex.ToString() + "\r\n";
EventLog.Write(errlog);
}
}
public bool AddUSBEventWatcher(EventArrivedEventHandler usbInsertHandler,
EventArrivedEventHandler usbRemoveHandler, TimeSpan withinInterval)
{
try
{
ManagementScope scope = new ManagementScope("root\\CIMV2");
scope.Options.EnablePrivileges = true;
if (usbInsertHandler != null)
{
WqlEventQuery wqlEventQuery = new WqlEventQuery("__InstanceCreationEvent", withinInterval,
"TargetInstance isa 'Win32_USBControllerDevice'");
this.insertWatcher = new ManagementEventWatcher(scope, (EventQuery)wqlEventQuery);
this.insertWatcher.EventArrived += usbInsertHandler;
}
if (usbRemoveHandler != null)
{
WqlEventQuery wqlEventQuery = new WqlEventQuery("__InstanceDeletionEvent", withinInterval,
"TargetInstance isa 'Win32_USBControllerDevice'");
this.removeWatcher = new ManagementEventWatcher(scope, (EventQuery)wqlEventQuery);
this.removeWatcher.EventArrived += usbRemoveHandler;
}
return(true);
}
catch (Exception ex)
{
HuionLog.saveLog("usb", ex.Message);
this.RemoveUSBEventWatcher();
return(false);
}
}
public void Start()
{
_eventArrivedEventHandler = new EventArrivedEventHandler(Watcher_DriveChangedEvent);
_watcher.EventArrived += _eventArrivedEventHandler;
_watcher.Query = _query;
_watcher.Start();
_watcher.WaitForNextEvent();
}
private ManagementEventWatcher StartManagementEventWatcher(string eventType, EventArrivedEventHandler handler)
{
var watcher = new ManagementEventWatcher($"SELECT * FROM {eventType} WITHIN 2 WHERE TargetInstance ISA 'Win32_PnPEntity' AND TargetInstance.DeviceID LIKE 'USB%'");
watcher.EventArrived += handler;
watcher.Start();
return(watcher);
}
public WmiWatchListener Watch(EventArrivedEventHandler handler)
{
WqlEventQuery eq = new WqlEventQuery("CitrixXenStoreWatchEvent", String.Format("EventId=\"{0}\"", name));
ManagementEventWatcher ev = new ManagementEventWatcher(WmiBase.Singleton.Scope, eq);
ev.EventArrived += handler;
return(new WmiWatchListener(wmisession, ev, name));
}
public static ManagementEventWatcher GetWatcher(EventArrivedEventHandler handler)
{
WqlEventQuery query = new WqlEventQuery("__InstanceModificationEvent", new TimeSpan(0, 0, 1),
"TargetInstance isa 'Win32_LocalTime' AND TargetInstance.Second = 0");
ManagementEventWatcher watcher = new ManagementEventWatcher(query);
watcher.EventArrived += new EventArrivedEventHandler(handler);
return watcher;
}
public void StartListeningForDeviceEvents(EventArrivedEventHandler handler)
{
if (deviceConnectedWatcher == null)
{
deviceConnectedWatcher = StartManagementEventWatcher("__InstanceCreationEvent", handler);
}
if (deviceDisconnectedWatcher == null)
{
deviceDisconnectedWatcher = StartManagementEventWatcher("__InstanceDeletionEvent", handler);
}
}
public void MonitorProcessExit(EventArrivedEventHandler handler)
{
var watcher = new ManagementEventWatcher(
new WqlEventQuery(
"__InstanceDeletionEvent",
new TimeSpan(0, 0, 1),
_eventQueryCondition));
watcher.Start();
watcher.EventArrived += handler;
}
public static ManagementEventWatcher GetWatcher(EventArrivedEventHandler handler)
{
//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_LocalTime' AND TargetInstance.Second = 0");
//Initialize an event watcher and subscribe to events that match this query
ManagementEventWatcher watcher = new ManagementEventWatcher(query);
//Attach the arrived property to EventArrivedEventHandler method with the required handler to allow watcher object communicate to the application
watcher.EventArrived += new EventArrivedEventHandler(handler);
return watcher;
}
// this method will capture every process start
public void MonitorProcesses()
{
//start monitoring for processes
// create event query to be notified within 1 second of a change in a service
EventArrivedEventHandler eventHandler = new EventArrivedEventHandler(ProcessStartEvent);
eventWatcher = new ManagementEventWatcher();//creating a management event watcher
WqlEventQuery eventQuery = new WqlEventQuery("__InstanceCreationEvent", new TimeSpan(0, 0, 1), "TargetInstance isa \"Win32_Process\"");
eventWatcher.Query = eventQuery;
eventWatcher.EventArrived += eventHandler;
eventWatcher.Start();
}
private static void StartWMIReceiveEvent(EventArrivedEventHandler WMIHandleEvent)
{
try
{
WMIEC.watcher = new ManagementEventWatcher(new ManagementScope("\\\\.\\Root\\WMI"), (EventQuery) new WqlEventQuery("SELECT * FROM AcpiTest_EventULong"));
WMIEC.watcher.EventArrived += WMIHandleEvent;
WMIEC.watcher.Start();
}
catch (ManagementException ex)
{
Log.s(LOG_LEVEL.ERROR, string.Format("WMIEC|StartWMIReceiveEvent : An error occurred while trying to receive an event: " + ex.Message));
}
}
/// <summary>
/// Detect Usb devices that inserted or removed
/// </summary>
/// <param name="deviceInsertedEvent">EventHandler for inserted devices as EventArrivedEventHandler</param>
/// <param name="deviceRemovedEvent">EventHandler for removed devices as EventArrivedEventHandler</param>
public DetectUSBDrive(EventArrivedEventHandler deviceInsertedEvent, EventArrivedEventHandler deviceRemovedEvent)
{
WqlEventQuery insertQuery = new WqlEventQuery("SELECT * FROM __InstanceCreationEvent WITHIN 2 WHERE TargetInstance ISA 'Win32_USBHub'");
insertWatcher = new ManagementEventWatcher(insertQuery);
insertWatcher.EventArrived += new EventArrivedEventHandler(deviceInsertedEvent);
insertWatcher.Start();
WqlEventQuery removeQuery = new WqlEventQuery("SELECT * FROM __InstanceDeletionEvent WITHIN 2 WHERE TargetInstance ISA 'Win32_USBHub'");
removeWatcher = new ManagementEventWatcher(removeQuery);
removeWatcher.EventArrived += new EventArrivedEventHandler(deviceRemovedEvent);
removeWatcher.Start();
}
public Watcher(EventArrivedEventHandler insert, EventArrivedEventHandler remove)
{
WqlEventQuery insertQuery = new WqlEventQuery("SELECT * FROM Win32_VolumeChangeEvent WHERE EventType = 2");
insertWatcher = new ManagementEventWatcher(insertQuery);
insertWatcher.EventArrived += new EventArrivedEventHandler(insert);
insertWatcher.Start();
WqlEventQuery removeQuery = new WqlEventQuery("SELECT * FROM Win32_VolumeChangeEvent WHERE EventType = 3");
removeWatcher = new ManagementEventWatcher(removeQuery);
removeWatcher.EventArrived += new EventArrivedEventHandler(remove);
removeWatcher.Start();
}
private void GetManagementEventWatcher(WqlEventQuery q, EventArrivedEventHandler EventArrived)
{
try
{
var w = new ManagementEventWatcher(new ManagementScope(@"\\localhost\root\cimv2"), q);
w.EventArrived += EventArrived;
w.Start();
this._watchers.Add(w);
}
catch(Exception e)
{
//some logging
}
}
private void Init(string processName)
{
Query.QueryLanguage = "WQL";
if (string.IsNullOrEmpty(processName))
{
Query.QueryString = WMI_OPER_EVENT_QUERY;
}
else
{
Query.QueryString =
string.Format(WMI_OPER_EVENT_QUERY_WITH_PROC, processName);
}
EventArrived += new EventArrivedEventHandler(OnEventArrived);
}
/// <summary>
/// 添加通讯端口监控事件
/// </summary>
/// <param name="insertHandler">插入事件</param>
/// <param name="removeHandler">移除事件</param>
/// <param name="interval">扫描周期，事件单位是秒</param>
/// <returns></returns>
private Boolean AddWatcherCommEvent(EventArrivedEventHandler insertHandler, EventArrivedEventHandler removeHandler, TimeSpan interval)
{
try
{
ManagementScope Scope = new ManagementScope("root\\CIMV2");
Scope.Options.EnablePrivileges = true;
//---USB插入监视
if (insertHandler != null)
{
//---检查设备插入事件
if (this.defaultInsertWatcher != null)
{
this.defaultInsertWatcher.Stop();
this.defaultInsertWatcher = null;
}
WqlEventQuery insertQuery = new WqlEventQuery("__InstanceCreationEvent", interval, "TargetInstance isa 'Win32_USBControllerDevice'");
this.defaultInsertWatcher = new ManagementEventWatcher(Scope, insertQuery);
this.defaultInsertWatcher.EventArrived += insertHandler;
this.defaultInsertWatcher.Options.Timeout = new TimeSpan(0, 0, 5);
this.defaultInsertWatcher.Start();
}
//---USB拔出监视
if (removeHandler != null)
{
//---检查设备移除事件
if (this.defaultRemoveWatcher != null)
{
this.defaultRemoveWatcher.Stop();
this.defaultRemoveWatcher = null;
}
WqlEventQuery removeQuery = new WqlEventQuery("__InstanceDeletionEvent", interval, "TargetInstance isa 'Win32_USBControllerDevice'");
this.defaultRemoveWatcher = new ManagementEventWatcher(Scope, removeQuery);
this.defaultRemoveWatcher.EventArrived += removeHandler;
this.defaultRemoveWatcher.Options.Timeout = new TimeSpan(0, 0, 5);
this.defaultRemoveWatcher.Start();
}
return(true);
}
catch (Exception)
{
this.DestroyWatcherCommEvent();
return(false);
}
}
public ProcessObserver(string processName, EventArrivedEventHandler onStart, EventArrivedEventHandler onStop)
{
WqlEventQuery startQuery = new WqlEventQuery("Win32_ProcessStartTrace", String.Format("ProcessName='{0}'", processName));
m_processStartEvent = new ManagementEventWatcher(startQuery);
WqlEventQuery stopQuery = new WqlEventQuery("Win32_ProcessStopTrace", String.Format("ProcessName='{0}'", processName));
m_processStopEvent = new ManagementEventWatcher(stopQuery);
if (onStart != null)
{
m_processStartEvent.EventArrived += onStart;
}
if (onStop != null)
{
m_processStopEvent.EventArrived += onStop;
}
}
public RegistryChangeListener(string registryKey, EventArrivedEventHandler eventArrivedEventHandler)
{
registryKey = registryKey.Replace("\\", "\\\\");
string text = string.Format("SELECT * FROM RegistryKeyChangeEvent WHERE Hive = 'HKEY_LOCAL_MACHINE' AND KeyPath = '{0}'", registryKey);
try
{
WqlEventQuery query = new WqlEventQuery(text);
this.watcher = new ManagementEventWatcher(query);
this.watcher.EventArrived += eventArrivedEventHandler;
this.watcher.Start();
RegistryChangeListener.Tracer.TraceDebug <string>(0L, "Registry Watcher Started With Query: {0}", text);
}
catch (ManagementException ex)
{
RegistryChangeListener.Tracer.TraceDebug <string, string>(0L, "An error occurred when setting registry listener. Query: {0}, Message: {1} ", text, ex.Message);
}
}
public static void BrightnessChanged(EventArrivedEventHandler eventArrivedEventHandler)
{
try
{
WqlEventQuery query = new WqlEventQuery(
"SELECT * FROM WmiMonitorBrightnessEvent");
ManagementEventWatcher watcher = new ManagementEventWatcher(new ManagementScope("root\\WMI"), query);
watcher.EventArrived += eventArrivedEventHandler;
watcher.Start();
return;
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
public void AddWatchExitProcessEvent(EventArrivedEventHandler eventHandler)
{
WqlEventQuery query = new WqlEventQuery(
$"SELECT * FROM Win32_ProcessStopTrace WHERE ProcessName = '{_processName}'");
deleteWatcher = new ManagementEventWatcher(query);
deleteWatcher.EventArrived += new EventArrivedEventHandler(eventHandler);
try
{
deleteWatcher.Start();
deleteWatcherStarted = true;
}
catch (Exception)
{
deleteWatcherStarted = false;
//TODO: exception handler AddWatchExitProcessEvent
}
}
public static void StartDriveChangeNotification(EventArrivedEventHandler handler)
{
if (mew != null)
{
throw new Exception("Already started");
}
NotifyHandler = handler;
mew = new List <ManagementEventWatcher>();
mew.Add(new ManagementEventWatcher("SELECT * FROM __InstanceCreationEvent WITHIN 1 WHERE TargetInstance ISA 'Win32_DiskDrive'"));
mew.Add(new ManagementEventWatcher("SELECT * FROM __InstanceDeletionEvent WITHIN 1 WHERE TargetInstance ISA 'Win32_DiskDrive'"));
mew.Add(new ManagementEventWatcher("SELECT * FROM __InstanceModificationEvent WITHIN 1 WHERE TargetInstance ISA 'Win32_DiskDrive'"));
foreach (var m in mew)
{
m.EventArrived += EventArrived;
m.Start();
}
}
/// <summary>
/// 添加USB事件监视器
/// </summary>
/// <param name="usbInsertHandler">USB插入事件处理器</param>
/// <param name="usbRemoveHandler">USB拔出事件处理器</param>
/// <param name="withinInterval">发送通知允许的滞后时间</param>
public Boolean AddUSBEventWatcher(EventArrivedEventHandler usbInsertHandler, EventArrivedEventHandler usbRemoveHandler, TimeSpan withinInterval)
{
try
{
ManagementScope Scope = new ManagementScope("root\\CIMV2");
Scope.Options.EnablePrivileges = true;
// USB插入监视
if (usbInsertHandler != null)
{
WqlEventQuery InsertQuery = new WqlEventQuery("__InstanceCreationEvent",
withinInterval,
"TargetInstance isa 'Win32_USBControllerDevice'");
insertWatcher = new ManagementEventWatcher(Scope, InsertQuery);
insertWatcher.EventArrived += usbInsertHandler;
insertWatcher.Start();
}
// USB拔出监视
if (usbRemoveHandler != null)
{
WqlEventQuery RemoveQuery = new WqlEventQuery("__InstanceDeletionEvent",
withinInterval,
"TargetInstance isa 'Win32_USBControllerDevice'");
removeWatcher = new ManagementEventWatcher(Scope, RemoveQuery);
removeWatcher.EventArrived += usbRemoveHandler;
removeWatcher.Start();
}
return(true);
}
catch (Exception ex)
{
ErrorHelper.ErrorPutting(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
RemoveUSBEventWatcher();
return(false);
}
}
/** Occhio questo loop va chiamato probabilmente in un thread separato */
public void attesaEventi()
{
// Solo la prima volta
if (_attivazioneAttesa == null)
{
// Attivo ascoltatore
// Devo tenermi un riferimento di questa callback altrimenti durante interop si spacca
eventArrivedEventHandler = new EventArrivedEventHandler(onVolumeCambiatoEvent);
_watcher.EventArrived += eventArrivedEventHandler;
// poi non lo ribadisco più
_attivazioneAttesa = attesaBloccante;
}
if (attesaBloccante)
{
_giornale.Debug("Sto per mettermi in attesa del prossimo evento");
ManagementBaseObject oo = _watcher.WaitForNextEvent();
_giornale.Debug("Esco dalla attesa di eventi");
}
}
static void Main(string[] args)
{
ManagementObjectSearcher processorSearcher = new ManagementObjectSearcher("SELECT * FROM Win32_Processor");
foreach (ManagementObject obj in processorSearcher.Get())
{
Console.WriteLine(obj["Name"]);
Console.WriteLine("{0} / {1}", obj["CurrentClockSpeed"], obj["MaxClockSpeed"]);
}
EventQuery query = new EventQuery();
//query.QueryString = "SELECT * FROM _InstanceModifiationEvent WITHIN 3600 WHERE TargetInstance ISA 'Win32_DiskDrive'";
query.QueryString = "SELECT * FROM __InstanceCreationEvent WITHIN 1 WHERE TargetInstance isa \"Win32_Process\"";
ManagementEventWatcher watcher = new ManagementEventWatcher(query);
watcher.Options.Timeout = new TimeSpan(0, 0, 30);
EventArrivedEventHandler eventArrived = new EventArrivedEventHandler(EventReceived);
watcher.EventArrived += eventArrived;
watcher.Start();
Console.WriteLine("Open an application (notepad.exe) to trigger an event.");
//ManagementBaseObject e = watcher.WaitForNextEvent();
Console.WriteLine("Actually I rewrote this to use events, it will now monitor all application starts until you hit a key...");
ConsoleKeyInfo key;
while (true)
{
key = Console.ReadKey();
if (key.KeyChar.Equals('q'))
break;
}
/*
//Display information from the event
Console.WriteLine("Process {0} has been created, path is: {1}", ((ManagementBaseObject)e["TargetInstance"])["Name"],
((ManagementBaseObject)e["TargetInstance"])["ExecutablePath"]);
*/
watcher.Stop();
}
static public void StartWMIReceiveEvent(EventArrivedEventHandler WMIHandleEvent)
{
try
{
WqlEventQuery query = new WqlEventQuery("SELECT * FROM AcpiTest_EventULong");
watcher = new ManagementEventWatcher(new ManagementScope("\\\\.\\Root\\WMI"), query);
//Console.WriteLine("Waiting for an event...");
watcher.EventArrived += WMIHandleEvent;
// Start listening for events
watcher.Start();
return;
}
catch (ManagementException err)
{
Console.WriteLine("An error occurred while trying to receive an event: " + err.Message);
}
}
/// <summary>
/// Start capturing data
/// </summary>
public void BeginCapture()
{
// add timer
if (!IsRunning)
{
isRunning = true;
timer = new System.Timers.Timer(Interval * 1000);
timer.Elapsed += new System.Timers.ElapsedEventHandler(OnTimer);
timer.Start();
WmiEventHandler myHandler = new WmiEventHandler();
eventArrivedEventHandler = new EventArrivedEventHandler(myHandler.Win32ProcCreated);
win32ProcCreatedWatcher = WmiEventHandler.GetWatcher("__InstanceCreationEvent");
win32ProcCreatedWatcher.EventArrived += eventArrivedEventHandler;
win32ProcCreatedWatcher.Start();
eventArrivedEventHandler = new EventArrivedEventHandler(myHandler.Win32ProcDeleted);
win32ProcDeletedWatcher = WmiEventHandler.GetWatcher("__InstanceDeletionEvent");
win32ProcDeletedWatcher.EventArrived += eventArrivedEventHandler;
win32ProcDeletedWatcher.Start();
}
}
/// <summary>
/// <see cref="SerialPortWatcher"/> クラスの新しいインスタンスを初期化します。
/// </summary>
private SerialPortWatcher()
{
_Changed = (sender, e) =>
{
int value = 0;
var valueText = e.NewEvent.GetPropertyValue("EventType").ToString();
UpdateComPortNames();
int.TryParse(valueText, out value);
var type = (DeviceChangeType)value;
var newPorts = SerialPort.GetPortNames();
Changed?.Invoke(this, new DeviceChangedEventArgs(type, newPorts, e));
};
_Disposed += (sender, e) =>
{
Disposed?.Invoke(this, e);
};
UpdateComPortNames();
}
public PortExtender(EventArrivedEventHandler deviceRemovedHandler)
{
DeviceRemovedHandler_ = deviceRemovedHandler;
}
public void AddListenerToConnectEvent(EventArrivedEventHandler handler)
{
ConnectEvent.EventArrived += handler;
}
public WmiWatchListener Watch(EventArrivedEventHandler handler)
{
WqlEventQuery eq = new WqlEventQuery("CitrixXenStoreWatchEvent", String.Format("EventId=\"{0}\"", name));
ManagementEventWatcher ev = new ManagementEventWatcher(WmiBase.Singleton.Scope, eq);
ev.EventArrived += handler;
return new WmiWatchListener(wmisession, ev, name);
}
public WmiListener ListenForEvent(string eventname, EventArrivedEventHandler handler)
{
ManagementEventWatcher ev = GetListenerEvent(eventname);
ev.EventArrived += handler;
return new WmiListener(ev);
}
public RegistryWatcher(EventArrivedEventHandler handler)
{
_handler = handler;
}
