public static string ShowUserSID(string username)
 {
     // local scope
     string[] unames = username.Split("\\".ToCharArray(),2);
     string d = "";
     string n = "";
     d = unames[0];
     if (unames.Length < 2)
     {
         n = unames[0];
         d = "US_IBS";
     }
     else
         n = unames[1];
     ConnectionOptions co = new ConnectionOptions();
     //co.Username = username;
     ManagementScope msc = new ManagementScope ("\\root\\cimv2",co);
     string queryString = "SELECT * FROM Win32_UserAccount where LocalAccount = false AND SIDType = 1 AND Domain = '" + d+ "' AND Name = '" + n + "'";
     //System.Windows.Forms.MessageBox.Show(queryString);
     SelectQuery q = new SelectQuery (queryString);
     query = new ManagementObjectSearcher(msc, q);
     queryCollection = query.Get();
     string res=String.Empty;
     foreach( ManagementObject mo in queryCollection )
     {
         // there should be only one here!
         res+= mo["SID"].ToString();
         //res+= mo["Name"]+"\n";
     }
     return res;
 }

        //private char NULL_VALUE = char(0);
        public static ProcessReturnCode Run(string machineName, string commandLine, string args, string currentDirectory)
        {
            var connOptions = new ConnectionOptions
                                  {
                                      EnablePrivileges = true
                                  };

            var scope = new ManagementScope(@"\\{0}\root\cimv2".FormatWith(machineName), connOptions);
            scope.Connect();
            var managementPath = new ManagementPath(CLASSNAME);
            using (var processClass = new ManagementClass(scope, managementPath, new ObjectGetOptions()))
            {
                var inParams = processClass.GetMethodParameters("Create");
                commandLine = System.IO.Path.Combine(currentDirectory, commandLine);
                inParams["CommandLine"] = "{0} {1}".FormatWith(commandLine, args);

                var outParams = processClass.InvokeMethod("Create", inParams, null);

                var rtn = Convert.ToUInt32(outParams["returnValue"]);
                var pid = Convert.ToUInt32(outParams["processId"]);
                if (pid != 0)
                {
                    WaitForPidToDie(machineName, pid);
                }

                return (ProcessReturnCode)rtn;
            }
        }

 protected virtual void GetOperatingSystemInfo(string Name, string UserName, string Password)
 {
     if (string.IsNullOrEmpty(Name))
         throw new ArgumentNullException("Name");
     ManagementScope Scope = null;
     if (!string.IsNullOrEmpty(UserName) && !string.IsNullOrEmpty(Password))
     {
         ConnectionOptions Options = new ConnectionOptions();
         Options.Username = UserName;
         Options.Password = Password;
         Scope = new ManagementScope("\\\\" + Name + "\\root\\cimv2", Options);
     }
     else
     {
         Scope = new ManagementScope("\\\\" + Name + "\\root\\cimv2");
     }
     Scope.Connect();
     ObjectQuery Query = new ObjectQuery("SELECT * FROM Win32_OperatingSystem");
     using (ManagementObjectSearcher Searcher = new ManagementObjectSearcher(Scope, Query))
     {
         using (ManagementObjectCollection Collection = Searcher.Get())
         {
             foreach (ManagementObject TempNetworkAdapter in Collection)
             {
                 if (TempNetworkAdapter.Properties["LastBootUpTime"].Value != null)
                 {
                     LastBootUpTime = ManagementDateTimeConverter.ToDateTime(TempNetworkAdapter.Properties["LastBootUpTime"].Value.ToString());
                 }
             }
         }
     }
 }

        public static List<Object[]> checkAntiVirus()
        {
            List<Object[]> av = new List<Object[]>();
            ConnectionOptions _connectionOptions = new ConnectionOptions();

            _connectionOptions.EnablePrivileges = true;
            _connectionOptions.Impersonation = ImpersonationLevel.Impersonate;
            ManagementScope _managementScope = new ManagementScope(string.Format("\\\\{0}\\root\\SecurityCenter2", "localhost"), _connectionOptions);
            _managementScope.Connect();

            ObjectQuery _objectQuery = new ObjectQuery("SELECT * FROM AntivirusProduct");
            ManagementObjectSearcher _managementObjectSearcher = new ManagementObjectSearcher(_managementScope, _objectQuery);
            ManagementObjectCollection _managementObjectCollection = _managementObjectSearcher.Get();

            if (_managementObjectCollection.Count > 0)
            {
                Boolean updated = false;
                foreach (ManagementObject item in _managementObjectCollection)
                {
                    updated = (item["productState"].ToString() == "266240" || item["productState"].ToString() == "262144");
                    av.Add(new Object[] { item["displayName"].ToString(), updated });
                }
            }

            return av;
        }

        protected override void OnCommitted(IDictionary savedState)
        {
            base.OnCommitted (savedState);

            // Setting the "Allow Interact with Desktop" option for this service.
            ConnectionOptions connOpt = new ConnectionOptions();
            connOpt.Impersonation = ImpersonationLevel.Impersonate;
            ManagementScope mgmtScope = new ManagementScope(@"root\CIMv2", connOpt);
            mgmtScope.Connect();
            ManagementObject wmiService = new ManagementObject("Win32_Service.Name='" + ReflectorMgr.ReflectorServiceName + "'");
            ManagementBaseObject inParam = wmiService.GetMethodParameters("Change");
            inParam["DesktopInteract"] = true;
            ManagementBaseObject outParam = wmiService.InvokeMethod("Change", inParam, null);

            #region Start the reflector service immediately
            try
            {
                ServiceController sc = new ServiceController("ConferenceXP Reflector Service");
                sc.Start();
            }
            catch (Exception ex)
            {
                // Don't except - that would cause a rollback.  Instead, just tell the user.
                RtlAwareMessageBox.Show(null, string.Format(CultureInfo.CurrentCulture, Strings.ServiceStartFailureText, 
                    ex.ToString()), Strings.ServiceStartFailureTitle, MessageBoxButtons.OK, MessageBoxIcon.Warning, 
                    MessageBoxDefaultButton.Button1, (MessageBoxOptions)0);
            }
            #endregion
        }

        public static List<EntDisk>GetDiskDetails(ManagementScope scope)
        {
            _logger.Info("Collecting disk details for machine " + scope.Path.Server);

            ObjectQuery query = null;
            ManagementObjectSearcher searcher = null;
            ManagementObjectCollection objects = null;
            List<EntDisk> lstDisk = new List<EntDisk>();

            try
            {
                query = new ObjectQuery("Select * from Win32_DiskDrive");
                searcher = new ManagementObjectSearcher(scope, query);
                objects = searcher.Get();
                lstDisk.Capacity = objects.Count;
                foreach (ManagementBaseObject obj in objects)
                {
                    lstDisk.Add(FillDetails(obj));
                    obj.Dispose();
                }
            }
            catch (Exception e)
            {
                _logger.Error("Exception is disk collection " + e.Message);
            }
            finally
            {
                searcher.Dispose();
            }
            return lstDisk;
        }

        public static ManagementScope GetScope(string ns = @"root\cimv2", string server = ".", string username = null, string password = null)
        {
            var scope = new ManagementScope()
            {
                Options =
                {
                    Impersonation = ImpersonationLevel.Impersonate,
                    Authentication = AuthenticationLevel.PacketPrivacy,
                    EnablePrivileges = true
                },
                Path = new ManagementPath()
                {
                    NamespacePath = ns,
                    Server = server
                }
            };

            if (!string.IsNullOrWhiteSpace(username))
                scope.Options.Username = username;

            if (!string.IsNullOrWhiteSpace(password))
                scope.Options.Password = password;

            return scope;
        }

        /// <summary>
        /// Gets COM port list.
        /// </summary>
        /// <returns>Enumerable list of COM ports.</returns>
        public static IEnumerable<ComPortItem> GetComPorts()
        {
            var result = new List<ComPortItem>();

            ManagementScope connectionScope = new ManagementScope();
            SelectQuery serialQuery = new SelectQuery("SELECT * FROM Win32_SerialPort");
            ManagementObjectSearcher searcher = new ManagementObjectSearcher(connectionScope, serialQuery);

            try
            {
                foreach (ManagementObject item in searcher.Get())
                {
                    string portName = item["DeviceID"].ToString();
                    string portDescription = item["DeviceID"].ToString();

                    // COM port with Arduino is not detected.
                    // portDescription.Contains("Arduino") is not working.
                    // I should find out how to get value "Arduino Uno" from "Описание устройства, предоставленное шиной" parameter.
                    // And where is this parameter?
                    result.Add(new ComPortItem(portName, portDescription.Contains("Arduino")));
                }
            }
            catch (ManagementException)
            {
            }

            return result;
        }

        ConfigureMmioGap(
            string vmName, 
            uint gapSize)
        {
            ManagementScope scope = new ManagementScope(@"root\virtualization\v2");

            using (ManagementObject vm = WmiUtilities.GetVirtualMachine(vmName, scope))
            using (ManagementObject vssd = WmiUtilities.GetVirtualMachineSettings(vm))
            using (ManagementObject vmms = WmiUtilities.GetVirtualMachineManagementService(scope))
            using (ManagementBaseObject inParams = vmms.GetMethodParameters("ModifySystemSettings"))
            {
                Console.WriteLine("Configuring MMIO gap size of Virtual Machine \"{0}\" ({1}) " +
                        "to {2} MB...", vm["ElementName"], vm["Name"], gapSize);

                vssd["LowMmioGapSize"] = gapSize;
                inParams["SystemSettings"] = vssd.GetText(TextFormat.CimDtd20);

                using (ManagementBaseObject outParams =
                    vmms.InvokeMethod("ModifySystemSettings", inParams, null))
                {
                    if (WmiUtilities.ValidateOutput(outParams, scope))
                    {
                        Console.WriteLine("Configuring MMIO gap size succeeded.\n");
                    }
                }
            }
        }

 /// <summary>
 /// Loads the BIOS info
 /// </summary>
 /// <param name="Name">Computer name</param>
 /// <param name="UserName">User name</param>
 /// <param name="Password">Password</param>
 private void LoadBIOS(string Name, string UserName, string Password)
 {
     ManagementScope Scope = null;
     if (!string.IsNullOrEmpty(UserName) && !string.IsNullOrEmpty(Password))
     {
         ConnectionOptions Options = new ConnectionOptions();
         Options.Username = UserName;
         Options.Password = Password;
         Scope = new ManagementScope("\\\\" + Name + "\\root\\cimv2", Options);
     }
     else
     {
         Scope = new ManagementScope("\\\\" + Name + "\\root\\cimv2");
     }
     Scope.Connect();
     ObjectQuery Query = new ObjectQuery("SELECT * FROM Win32_BIOS");
     using (ManagementObjectSearcher Searcher = new ManagementObjectSearcher(Scope, Query))
     {
         using (ManagementObjectCollection Collection = Searcher.Get())
         {
             foreach (ManagementObject TempBIOS in Collection)
             {
                 SerialNumber = TempBIOS.Properties["Serialnumber"].Value.ToString();
             }
         }
     }
 }

 public WmiWrapper(ManagementPath path)
 {
     _scope = new ManagementScope(path)
     {
         Options = { Impersonation = ImpersonationLevel.Impersonate }
     };
 }

 public static ManagementObject[] getVhdSettings(ManagementObject virtualMachine, ManagementScope Scope)
 {
     using (ManagementObject mObject = getSettingData(wmiClass.Msvm_VirtualSystemSettingData.ToString(), wmiClass.Msvm_SettingsDefineState.ToString(), virtualMachine, Scope))
     {
         return getVHDSettings(mObject);
     }
 }

        static IEnumerable<byte[]> GetManagementObjects()
        {
            var options = new EnumerationOptions {Rewindable = false, ReturnImmediately = true};
            var scope = new ManagementScope(ManagementPath.DefaultPath);
            var query = new ObjectQuery("SELECT * FROM Win32_NetworkAdapter");

            var searcher = new ManagementObjectSearcher(scope, query, options);
            ManagementObjectCollection collection = searcher.Get();

            foreach (ManagementObject obj in collection)
            {
                byte[] bytes;
                try
                {
                    PropertyData propertyData = obj.Properties["MACAddress"];
                    string propertyValue = propertyData.Value.ToString();

                    bytes = propertyValue.Split(':')
                        .Select(x => byte.Parse(x, NumberStyles.HexNumber))
                        .ToArray();
                }
                catch (Exception)
                {
                    continue;
                }

                if (bytes.Length == 6)
                    yield return bytes;
            }
        }

        public static List<EntHotfixes> GetHotfixDetails(ManagementScope scope)
        {
            _logger.Info("Collecting hotfix for machine " + scope.Path.Server);

            ObjectQuery query = null;
            ManagementObjectSearcher searcher = null;
            ManagementObjectCollection objects = null;
            List<EntHotfixes> lstHotfix = new List<EntHotfixes>();

            try
            {
                query = new ObjectQuery("Select * from Win32_QuickFixEngineering");
                searcher = new ManagementObjectSearcher(scope, query);
                objects = searcher.Get();
                lstHotfix.Capacity = objects.Count;
                foreach (ManagementBaseObject obj in objects)
                {
                    lstHotfix.Add(FillDetails(obj));
                    obj.Dispose();
                }
            }
            catch (System.Exception e)
            {
                _logger.Error("Exception is hotfix collection " + e.Message);
            }
            finally
            {
                searcher.Dispose();
            }
            return lstHotfix;
        }

        /// <summary>
        /// The start detection.
        /// </summary>
        /// <param name="action">
        /// The detection Action.
        /// </param>
        public void StartDetection(Action action)
        {
            ThreadPool.QueueUserWorkItem(
                delegate
                {
                    this.detectionAction = action;

                    var options = new ConnectionOptions { EnablePrivileges = true };
                    var scope = new ManagementScope(@"root\CIMV2", options);

                    try
                    {
                        var query = new WqlEventQuery
                        {
                            EventClassName = "__InstanceModificationEvent",
                            WithinInterval = TimeSpan.FromSeconds(1),
                            Condition = @"TargetInstance ISA 'Win32_LogicalDisk' and TargetInstance.DriveType = 5" // DriveType - 5: CDROM
                        };

                        this.watcher = new ManagementEventWatcher(scope, query);
                        this.watcher.EventArrived += this.WatcherEventArrived;
                        this.watcher.Start();
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine(e.Message);
                    }
                });
        }

 private void AddInsertUSBHandler()
 {
     WqlEventQuery query;
     ManagementScope scope = new ManagementScope("root\\CIMV2");
     scope.Options.EnablePrivileges = true;
     insertUSBWatcher = null;
     try
     {
         query = new WqlEventQuery();
         query.EventClassName = "__InstanceCreationEvent";
         query.WithinInterval = new TimeSpan(0, 0, 3);
         query.Condition = "TargetInstance ISA 'Win32_USBControllerdevice'";
         insertUSBWatcher = new ManagementEventWatcher(scope, query);
         insertUSBWatcher.EventArrived += USBInserted;
         insertUSBWatcher.Start();
     }
     catch(Exception e)
     {
         if (insertUSBWatcher != null)
         {
             insertUSBWatcher.Stop();
         }
         throw e;
     }
 }

        private string GetBatteryPercent()
        {
            try
            {
                var scope = new ManagementScope();
                SelectQuery query = new SelectQuery("Select EstimatedChargeRemaining From Win32_Battery");
                using (ManagementObjectSearcher searcher = new ManagementObjectSearcher(scope, query))
                {
                    using (ManagementObjectCollection objectCollection = searcher.Get())
                    {
                        foreach (ManagementObject mObj in objectCollection)
                            //this nugget has a lot of info see here: https://msdn.microsoft.com/en-us/library/windows/desktop/aa394074%28v=vs.85%29.aspx
                        {
                            PropertyData pData = mObj.Properties["EstimatedChargeRemaining"];
                            var val = pData.Value;
                            if ((ushort) val > (ushort) 100)
                            {
                                return "100";
                            }
                            else
                            {
                                return val.ToString().Replace("%",""); //strip % in case it duplicates
                            }

                        }
                    }
                }
                return "Unk";
            }
            catch (Exception e)
            {
                Debug.WriteLine(e);
                return "Unk";
            }
        }

 /// <summary>
 /// USB 插入和拔出监测函数。
 /// 使用ManagementEventWacher来预定特定系统事件，通过WqlEventQuery设置查询对象和条件以及其他属性（比如查询的轮询间隔），
 /// 通过ManagementScope设置查询路径范围。
 /// </summary>
 public void USBRemoveWacher()
 {
     ManagementEventWatcher wacher = null;
     WqlEventQuery query = null;
     ManagementScope scope = null;
     try
     {
         scope = new ManagementScope("root\\CIMV2");                                //设置WMI路径
         query = new WqlEventQuery();                                               //设置查询的事件类名，条件，查询间隔，也可一次在构造函数中初始化
         query.EventClassName = "__InstanceDeletionEvent";
         query.Condition = @"TargetInstance ISA 'Win32_USBControllerdevice'";
         query.WithinInterval = new TimeSpan(1000);
         wacher = new ManagementEventWatcher(scope, query);
         wacher.EventArrived += new EventArrivedEventHandler(onUSBRemoved);
         wacher.Start();
     }
     catch (Exception ex)
     {
         MessageBox.Show(ex.Message);
     }
     this.Closed += (s, e) =>
       {
           wacher.Stop();
           wacher.Dispose();
       };
 }

 /// <summary>
 /// Tries to connect to the host specified. The connection is used WMI.
 /// </summary>
 /// <param name="target">Host to Connect</param>
 public void Connect(TargetInfo target)
 {
     try
     {
         Credentials credentials = target.IsLocalTarget() ? null : target.credentials;
         ConnectionOptions options = this.GetConnectionOptions(credentials);
         
         this.ConnectionScope = this.GetManagementScope(options, target.GetAddress());
     }
     catch (UnauthorizedAccessException unauthorizedAccessException)
     {
         string errorMessage = string.Format(INVALID_CREDENTIALS_ERROR_MESSAGE, target.GetAddress(), target.credentials.GetDomain(), target.credentials.GetUserName());
         throw new InvalidCredentialsException(target.credentials, errorMessage, unauthorizedAccessException);
     }
     catch (COMException comException)
     {
         string errorMessage = string.Format(PROVIDER_CONNECTING_ERROR_MESSAGE, target.GetAddress(), comException.Message);
         throw new CannotConnectToHostException(target, errorMessage, comException);
     }
     catch (Exception ex)
     {
         string errorMessage = string.Format(PROVIDER_CONNECTING_ERROR_MESSAGE, target.GetAddress(), ex.Message);
         throw new ProbeException(errorMessage, ex);
     }
 }

        MergeVirtualHardDisk(
            string ServerName,
            string ChildPath,
            string ParentPath)
        {
            ManagementScope scope =
                new ManagementScope("\\\\" + ServerName + "\\root\\virtualization\\v2");

            using (ManagementObject imageManagementService =
                StorageUtilities.GetImageManagementService(scope))
            {
                using (ManagementBaseObject inParams =
                    imageManagementService.GetMethodParameters("MergeVirtualHardDisk"))
                {
                    inParams["SourcePath"] = ChildPath;
                    inParams["DestinationPath"] = ParentPath;

                    using (ManagementBaseObject outParams = imageManagementService.InvokeMethod(
                        "MergeVirtualHardDisk", inParams, null))
                    {
                        WmiUtilities.ValidateOutput(outParams, scope);
                    }
                }
            }
        }