public UsbDeviceEvent()
 {
     this.creationEventWatcher = (ManagementEventWatcher)null;
     ManagementOperationObserver operationObserver = new ManagementOperationObserver();
     ManagementScope scope = new ManagementScope("root\\CIMV2");
     scope.Options.EnablePrivileges = true;
     try
     {
         WqlEventQuery wqlEventQuery = new WqlEventQuery();
         wqlEventQuery.EventClassName = "__InstanceCreationEvent";
         wqlEventQuery.WithinInterval = new TimeSpan(0, 0, 3);
         wqlEventQuery.Condition = "TargetInstance ISA 'Win32_USBControllerDevice'";
         Console.WriteLine(wqlEventQuery.QueryString);
         this.creationEventWatcher = new ManagementEventWatcher(scope, (EventQuery)wqlEventQuery);
         this.creationEventWatcher.EventArrived += new EventArrivedEventHandler(this.creationEventWatcher_EventArrived);
         this.creationEventWatcher.Start();
         wqlEventQuery.EventClassName = "__InstanceDeletionEvent";
         wqlEventQuery.WithinInterval = new TimeSpan(0, 0, 3);
         wqlEventQuery.Condition = "TargetInstance ISA 'Win32_USBControllerdevice'";
         Console.WriteLine(wqlEventQuery.QueryString);
         this.deletionEventWatcher = new ManagementEventWatcher(scope, (EventQuery)wqlEventQuery);
         this.deletionEventWatcher.EventArrived += new EventArrivedEventHandler(this.deletionEventWatcher_EventArrived);
         this.deletionEventWatcher.Start();
     }
     catch
     {
         this.Dispose();
     }
 }

        private void findPorts()
        {
            try
            {
                comboBox_Ports.Items.Clear();
                serialItems.Items.Clear();

                ManagementObjectSearcher searcher = new ManagementObjectSearcher( new SelectQuery("WIN32_SerialPort"));
                ManagementOperationObserver results = new ManagementOperationObserver();
                results.ObjectReady += new ObjectReadyEventHandler(this.NewObject);
                results.Completed += new CompletedEventHandler(this.Done);

                // Get availble port names asynchronously
                searcher.Get(results);

                while (!this.Completed)
                {
                    System.Threading.Thread.Sleep(1000);
                }
                this.Reset();

            }
            catch (ManagementException e)
            {
                MessageBox.Show("Failed to run query: " + e.Message);
                throw;
            }

            foreach (object port in serialItems.Items)
            {
                comboBox_Ports.Items.Add(port);
            }
        }

		protected WmiEventSink(ManagementOperationObserver watcher, object context, ManagementScope scope, string path, string className)
		{
			try
			{
				this.context = context;
				this.watcher = watcher;
				this.className = className;
				this.isLocal = false;
				if (path != null)
				{
					this.path = new ManagementPath(path);
					if (string.Compare(this.path.Server, ".", StringComparison.OrdinalIgnoreCase) == 0 || string.Compare(this.path.Server, Environment.MachineName, StringComparison.OrdinalIgnoreCase) == 0)
					{
						this.isLocal = true;
					}
				}
				if (scope != null)
				{
					this.scope = scope.Clone();
					if (path == null && (string.Compare(this.scope.Path.Server, ".", StringComparison.OrdinalIgnoreCase) == 0 || string.Compare(this.scope.Path.Server, Environment.MachineName, StringComparison.OrdinalIgnoreCase) == 0))
					{
						this.isLocal = true;
					}
				}
				WmiNetUtilsHelper.GetDemultiplexedStub_f(this, this.isLocal, out this.stub);
				this.hash = Interlocked.Increment(ref WmiEventSink.s_hash);
			}
			catch
			{
			}
		}

 /// <summary>
 /// Internal Constructor
 /// </summary>
 /// <param name="childJob">Job associated with this operation</param>
 /// <param name="wmiObject">object associated with this operation</param>
 /// <param name="computerName"> computer on which the operation is invoked </param>
 /// <param name="results"> sink to get wmi objects </param>
 internal WmiAsyncCmdletHelper(PSWmiChildJob childJob, Cmdlet wmiObject, string computerName, ManagementOperationObserver results)
 {
     _wmiObject = wmiObject;
     _computerName = computerName;
     _results = results;
     this.State = WmiState.NotStarted;
     _job = childJob;
 }

        /// <summary>Creates a new process</summary>>
        /// <param name="commandLine">Command line to execute</param>
        /// <param name="currentDirectory">Current drive and directory for the child process</param>
        /// <param name="processStartupInformation">The startup configuration of a Windows process</param>
        /// <param name="processId">Global process identifier that can be used to identify a process</param>
        public void Create(string commandLine, string currentDirectory, Win32_ProcessStartup processStartupInformation,ref uint processId)
        {
            object[] methodArgs = { commandLine, currentDirectory, processStartupInformation, processId };
            ManagementOperationObserver observer = new ManagementOperationObserver();

            this._mc.InvokeMethod(observer, "Create", methodArgs);
            processId = Convert.ToUInt32(methodArgs[3]);
        }

 /// <summary>
 /// Kills the process.
 /// </summary>
 /// <param name="machineName">Name of the machine.</param>
 /// <param name="serviceObj">The service obj.</param>
 /// <param name="observer">The observer.</param>
 public static void KillProcess(string machineName, ManagementObject serviceObj, ManagementOperationObserver observer)
 {
     string str = String.Empty;
     foreach (var prop in serviceObj.Properties)
     {
         str += String.Format("{0} - {1}\r\n", prop.Name, prop.Value);
     }
     var processObj = GetProcess(machineName, serviceObj["ProcessId"].ToString());
     processObj.InvokeMethod(observer, "Terminate", null);
 }

 internal static WmiGetEventSink GetWmiGetEventSink(ManagementOperationObserver watcher, object context, ManagementScope scope, ManagementObject managementObject)
 {
     if (MTAHelper.IsNoContextMTA())
     {
         return new WmiGetEventSink(watcher, context, scope, managementObject);
     }
     watcherParameter = watcher;
     contextParameter = context;
     scopeParameter = scope;
     managementObjectParameter = managementObject;
     new ThreadDispatch(new ThreadDispatch.ThreadWorkerMethod(WmiGetEventSink.HackToCreateWmiGetEventSink)).Start();
     return wmiGetEventSinkNew;
 }

 internal static WmiEventSink GetWmiEventSink(ManagementOperationObserver watcher, object context, ManagementScope scope, string path, string className)
 {
     if (MTAHelper.IsNoContextMTA())
     {
         return new WmiEventSink(watcher, context, scope, path, className);
     }
     watcherParameter = watcher;
     contextParameter = context;
     scopeParameter = scope;
     pathParameter = path;
     classNameParameter = className;
     new ThreadDispatch(new ThreadDispatch.ThreadWorkerMethod(WmiEventSink.HackToCreateWmiEventSink)).Start();
     return wmiEventSinkNew;
 }

		private IObservable<ManagementBaseObject> Factory(ManagementClass mc)
		{
			var src = new ReplaySubject<ManagementBaseObject>();
			var ob = new ManagementOperationObserver();

			Observable.FromEventPattern<ObjectReadyEventHandler, ObjectReadyEventArgs>(
				h => h.Invoke,
				h => ob.ObjectReady += h,
				h => ob.ObjectReady -= h
			).Subscribe(obj => src.OnNext(obj.EventArgs.NewObject));

			Observable.FromEventPattern<CompletedEventHandler, CompletedEventArgs>(
				h => h.Invoke,
				h => ob.Completed += h,
				h => ob.Completed -= h
			).Subscribe(_ => src.OnCompleted());

			mc.GetInstances(ob);
			return src.AsObservable();
		}

		internal PSWmiChildJob(Cmdlet cmds, string computerName, ThrottleManager throttleManager) : base(null, null)
		{
			this.syncObject = new object();
			this.statusMessage = "test";
			base.UsesResultsCollection = true;
			this.computerName = computerName;
			this.throttleManager = throttleManager;
			this.wmiSinkArray = new ArrayList();
			ManagementOperationObserver managementOperationObserver = new ManagementOperationObserver();
			this.wmiSinkArray.Add(managementOperationObserver);
			PSWmiChildJob pSWmiChildJob = this;
			pSWmiChildJob.sinkCompleted = pSWmiChildJob.sinkCompleted + 1;
			managementOperationObserver.ObjectReady += new ObjectReadyEventHandler(this.NewObject);
			managementOperationObserver.Completed += new CompletedEventHandler(this.JobDone);
			this.helper = new WmiAsyncCmdletHelper(this, cmds, computerName, managementOperationObserver);
			this.helper.WmiOperationState += new EventHandler<WmiJobStateEventArgs>(this.HandleWMIState);
			this.helper.ShutdownComplete += new EventHandler<EventArgs>(this.JobDoneForWin32Shutdown);
			base.SetJobState(JobState.NotStarted);
			IThrottleOperation throttleOperation = this.helper;
			throttleOperation.OperationComplete += new EventHandler<OperationStateEventArgs>(this.HandleOperationComplete);
			throttleManager.ThrottleComplete += new EventHandler<EventArgs>(this.HandleThrottleComplete);
			throttleManager.AddOperation(throttleOperation);
		}

		public void GetRelationships (ManagementOperationObserver watcher, string relationshipClass)
		{
			throw new NotImplementedException ();
		}

		public void GetRelated (ManagementOperationObserver watcher)
		{
			throw new NotImplementedException ();
		}

 /// <summary>
 /// Internal constructor for initializing WMI jobs, where WMI command is executed a variable
 /// number of times.
 /// </summary>
 internal PSWmiChildJob(Cmdlet cmds, string computerName, ThrottleManager throttleManager, int count)
     : base(null, null)
 {
     UsesResultsCollection = true;
     Location = computerName;
     _throttleManager = throttleManager;
     _wmiSinkArray = new ArrayList();
     ManagementOperationObserver wmiSink = new ManagementOperationObserver();
     _wmiSinkArray.Add(wmiSink);
     _sinkCompleted += count;
     wmiSink.ObjectReady += new ObjectReadyEventHandler(this.NewObject);
     wmiSink.Completed += new CompletedEventHandler(this.JobDone);
     _helper = new WmiAsyncCmdletHelper(this, cmds, computerName, wmiSink, count);
     _helper.WmiOperationState += new EventHandler<WmiJobStateEventArgs>(HandleWMIState);
     _helper.ShutdownComplete += new EventHandler<EventArgs>(JobDoneForWin32Shutdown);
     SetJobState(JobState.NotStarted);
     IThrottleOperation operation = _helper;
     operation.OperationComplete += new EventHandler<OperationStateEventArgs>(HandleOperationComplete);
     throttleManager.ThrottleComplete += new EventHandler<EventArgs>(HandleThrottleComplete);
     throttleManager.AddOperation(operation);
 }

        void SetupDriveWatcher()
        {
            try
            {
                ManagementEventWatcher w = null;
                WqlEventQuery q;
                ManagementOperationObserver observer = new ManagementOperationObserver();
                // Bind to local machine
                ManagementScope scope = new ManagementScope("root\\CIMV2");
                scope.Options.EnablePrivileges = true; //sets required privilege

                q = new WqlEventQuery();
                q.EventClassName = "__InstanceOperationEvent";
                q.WithinInterval = new TimeSpan(0, 0, 3);
                q.Condition = @"TargetInstance ISA 'Win32_DiskDrive' ";

                //Console.WriteLine(q.QueryString);
                w = new ManagementEventWatcher(scope, q);

                w.EventArrived += new EventArrivedEventHandler(UsbEventArrived);
                w.Start();
                // Console.ReadLine(); // block main thread for test purposes
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
        }

		public void InvokeMethod (ManagementOperationObserver watcher,
					  string methodName,
					  ManagementBaseObject inParameters,
					  InvokeMethodOptions options)
		{
			throw new NotImplementedException ();
		}

        private void GetEventLogItemMessages(string machinename, string logname)
        {
            if (_eventMessagesObserver == null)
            {
                ManagementScope messageScope = new ManagementScope(
                             GetStandardPath(machinename)
                 );

                messageScope.Connect();

                StringBuilder query = new StringBuilder();
                query.Append("select Message, InsertionStrings, RecordNumber from Win32_NTLogEvent where LogFile ='");
                query.Append(logname.Replace("'", "''"));
                query.Append("'");

                System.Management.ObjectQuery objectQuery = new System.Management.ObjectQuery(
                    query.ToString()
                );

                EnumerationOptions objectQueryOptions = new EnumerationOptions();
                objectQueryOptions.BlockSize = 100000;

                ManagementObjectSearcher objectSearcher = new ManagementObjectSearcher(messageScope, objectQuery);

                _eventMessagesObserver = new ManagementOperationObserver();
                _eventMessagesObserver.ObjectReady += new ObjectReadyEventHandler(OnEventLogEntryReady);
                _eventMessagesObserver.Completed += new CompletedEventHandler(OnEventLogEntryCompleted);
                objectSearcher.Get(_eventMessagesObserver);
            }
        }

		public void CopyTo (ManagementOperationObserver watcher, ManagementPath path)
		{
			throw new NotImplementedException ();
		}

		public void Put (ManagementOperationObserver watcher, PutOptions options)
		{
			throw new NotImplementedException ();
		}

        /// <summary>
        /// Invoke method 'Create' on local or remote machine
        /// </summary>
        /// <param name="stringCommandLine"></param>
        private void CreateProcess(string stringCommandLine)
        {
            //Set up a handler for the asynchronous callback
            ManagementOperationObserver observer = new ManagementOperationObserver();
            completionHandler.MyHandler completionHandlerObj = new completionHandler.MyHandler();
            observer.ObjectReady  += new ObjectReadyEventHandler(completionHandlerObj.Done);

            string stringMachineName = "";

            //Connect to the remote computer
            ConnectionOptions co = new ConnectionOptions();

            if (radioMachine.Checked == true)
            {
                stringMachineName = "localhost";
            }
            else
            {
                stringMachineName = textIP.Text;
            }

            if (stringMachineName.Trim().Length == 0)
            {
                MessageBox.Show("Must enter machine IP address or name.");
                return;
            }

            //get user and password
            if (textUserID.Text.Trim().Length   > 0)
            {
                co.Username = textUserID.Text;
                co.Password = textPassword.Text;
            }

            //Point to machine
            System.Management.ManagementScope ms = new System.Management.ManagementScope("\\\\" + stringMachineName + "\\root\\cimv2", co);
            //get process path
            ManagementPath path = new ManagementPath( "Win32_Process");

            //Get the object on which the method will be invoked
            ManagementClass processClass = new ManagementClass(ms,path,null);

            //Status
            updateStatus("Create process " + stringCommandLine + ".");

            //Create an array containing all arguments for the method
            object[] methodArgs = {stringCommandLine, null, null, 0};

            //Execute the method
            processClass.InvokeMethod (observer, "Create", methodArgs);

            //wait until invoke method is complete or 5 sec timeout
            int intCount = 0;
            while (!completionHandlerObj.IsComplete)
            {
                if (intCount > 10)
                {
                    MessageBox.Show("Create process timed out.", "Terminate Process Status");
                    break;
                }
                //wait 1/2 sec.
                System.Threading.Thread.Sleep(500);

                //increment counter
                intCount++;
            }

            if (intCount != 10)
            {
                //InvokeMethod did not time out
                //check for error
                if (completionHandlerObj.ReturnObject.Properties["returnValue"].Value.ToString() == "0")
                {
                    //refresh process list
                    this.Refresh();
                }
                else
                {
                    MessageBox.Show("Error creating new process.", "Create New Process");
                }
            }

            //Status
            updateStatus("Ready");
            this.Update();
        }

        protected override void OnStart(string[] args)
        {
            WMIEvent we = new WMIEvent();
            ManagementEventWatcher w = null;
            WqlEventQuery q;
            ManagementOperationObserver observer = new
            ManagementOperationObserver();
            // Bind to local machine
            ManagementScope scope = new ManagementScope("root\\CIMV2");
            scope.Options.EnablePrivileges = true; //sets required

            try {
                q = new WqlEventQuery();
                q.EventClassName = "__InstanceOperationEvent";
                q.WithinInterval = new TimeSpan(0, 0, 3);
                q.Condition = @
                "TargetInstance ISA 'Win32_DiskDrive' ";
                //EventLog es una forma de escribir lo que está pasando en
                //el visor de sucesos de windows
                EventLog.WriteEntry(q.QueryString);
                w = new ManagementEventWatcher(q);
                w.EventArrived += new
                EventArrivedEventHandler(we.UsbEventArrived);
                w.Start();

            } catch (Exception e) {
                EventLog.WriteEntry(e.Message);
            }
        }