public static bool IsEMSEnabled() { bool isEMSEnabled = false; try { // {9dea862c-5cdd-4e70-acc1-f32b344d4795} is the GUID of the System BcdStore ManagementObject scopeObj = new ManagementObject(new ManagementScope(@"root\WMI"), new ManagementPath("root\\WMI:BcdObject.Id=\"{9dea862c-5cdd-4e70-acc1-f32b344d4795}\",StoreFilePath=\"\""), null); ManagementBaseObject elementObj = null; elementObj = scopeObj.GetMethodParameters("GetElement"); // Get the list of IDs from 0x24000001, which is a BCD constant: BcdBootMgrObjectList_DisplayOrder elementObj["Type"] = ((UInt32)0x24000001); ManagementBaseObject BCDObj = scopeObj.InvokeMethod("GetElement", elementObj, null); ManagementBaseObject value = ((ManagementBaseObject)(BCDObj.Properties["Element"].Value)); // Get list of Ids string[] idList = (string[])value.GetPropertyValue("Ids"); // Define the Management object used to access the WMI info from BCD store scopeObj = new ManagementObject(new ManagementScope(@"root\WMI"), new ManagementPath("root\\WMI:BcdObject.Id=\"" + idList[0] + "\",StoreFilePath=\"\""), null); elementObj = scopeObj.GetMethodParameters("GetElement"); // BcdOSLoaderBoolean_EmsEnabled (0x260000b0) // The EMS enabled setting. The element data format is BcdBooleanElement. elementObj["Type"] = ((UInt32)0x260000b0); BCDObj = scopeObj.InvokeMethod("GetElement", elementObj, null); value = ((ManagementBaseObject)(BCDObj.Properties["Element"].Value)); // try get EMS enabled setting Boolean.TryParse(value.GetPropertyValue("boolean").ToString(), out isEMSEnabled); // Dispose unmanaged objects if (scopeObj != null) { scopeObj.Dispose(); } if (elementObj != null) { elementObj.Dispose(); } if (BCDObj != null) { BCDObj.Dispose(); } if (value != null) { value.Dispose(); } } catch (Exception e) { Tracer.WriteError(String.Format("Exception {0} Trace {1}", e.Message, e.StackTrace)); } return(isEMSEnabled); }
/// <summary> /// Get a DWORD Registry Value as string /// </summary> /// <param name="hDefKey">HKLM = 2147483650</param> /// <param name="sSubKeyName"></param> /// <param name="sValueName"></param> /// <param name="DefaultValue">return string if key or value does not exist</param> /// <returns></returns> public string GetDWord(UInt32 hDefKey, string sSubKeyName, string sValueName, string DefaultValue) { { String result = ""; try { WMIProvider oProv = new WMIProvider(oWMIProvider.mScope.Clone()); oProv.mScope.Path.NamespacePath = @"ROOT\default"; ManagementBaseObject inParams = oProv.GetClass("StdRegProv").GetMethodParameters("GetDWORDValue"); inParams["hDefKey"] = hDefKey; inParams["sSubKeyName"] = sSubKeyName; inParams["sValueName"] = sValueName; ManagementBaseObject outParams = oProv.ExecuteMethod("StdRegProv", "GetDWORDValue", inParams); if (outParams.GetPropertyValue("ReturnValue").ToString() == "0") { if (outParams.GetPropertyValue("uValue") != null) { result = outParams.GetPropertyValue("uValue").ToString(); } } return(result); } catch { return(DefaultValue); } } }
/// <summary> /// Create a new process on a remote system. For security reasons this method cannot be used to start an interactive process remotely. /// </summary> /// <param name="CommandLine"></param> /// <param name="CurrentDirectory"></param> /// <param name="ProcessStartupInformation">A Win32_ProcessStartup Object <see href="http://msdn2.microsoft.com/en-us/library/aa394375.aspx"/></param> /// <returns>ProcessID</returns> public int StartProcess(string CommandLine, string CurrentDirectory, ManagementBaseObject ProcessStartupInformation) { if (CurrentDirectory == "") { CurrentDirectory = null; } WMIProvider oProv = new WMIProvider(oWMIProvider.mScope.Clone()); oProv.mScope.Path.NamespacePath = @"root\cimv2"; ManagementClass MC = oProv.GetClass("Win32_Process"); ManagementBaseObject inParams = MC.GetMethodParameters("Create"); inParams["CommandLine"] = CommandLine; inParams["CurrentDirectory"] = CurrentDirectory; inParams["ProcessStartupInformation"] = ProcessStartupInformation; ManagementBaseObject Result = MC.InvokeMethod("Create", inParams, null); switch (int.Parse(Result.GetPropertyValue("ReturnValue").ToString())) { case 0: return(int.Parse(Result.GetPropertyValue("ProcessID").ToString())); case 2: throw new System.Security.SecurityException("Access denied"); case 3: throw new System.Security.SecurityException("Insufficient privilege"); case 9: throw new Exception("Path not found: " + CommandLine); case 21: throw new Exception("Invalid parameter"); default: throw new Exception("Unknown failure"); } }
/// <summary> /// Get an ArrayList of all Regisry Values /// </summary> /// <param name="hDefKey">2147483650 = HKLM</param> /// <param name="sSubKeyName"></param> /// <returns>RegistryValues</returns> public List <string> RegValuesList(UInt32 hDefKey, string sSubKeyName) { try { WMIProvider oProv = new WMIProvider(oWMIProvider.mScope.Clone()); oProv.mScope.Path.NamespacePath = @"ROOT\default"; ManagementBaseObject inParams = oProv.GetClass("StdRegProv").GetMethodParameters("EnumValues"); inParams["hDefKey"] = hDefKey; inParams["sSubKeyName"] = sSubKeyName; ManagementBaseObject outParams = oProv.ExecuteMethod("StdRegProv", "EnumValues", inParams); List <string> result = new List <string>(); if (outParams.GetPropertyValue("ReturnValue").ToString() == "0") { if (outParams.GetPropertyValue("sNames") != null) { result.AddRange(outParams.GetPropertyValue("sNames") as String[]); } } return(result); } catch { throw; } }
/// <summary> /// Converts a Win32 WMI object to a .NET class instance or struct. /// </summary> /// <param name="managementBaseObject"></param> /// <typeparam name="T"></typeparam> /// <returns>Instance of the .NET class <typeparamref name="T"/> populated with the data from <paramref name="managementBaseObject"/>.</returns> /// <exception cref="NotSupportedException">Thrown if the .NET class <typeparamref name="T"/> does not have a zero-argument constructor.</exception> public static T FromManagementObject <T>(ManagementBaseObject managementBaseObject) { var type = typeof(T); var publicInstanceFields = type.GetFields(BindingFlags.Public | BindingFlags.Instance); var zeroArgCtor = type.GetConstructor(new Type[0]); if (zeroArgCtor != null) { var instance = (T)zeroArgCtor.Invoke(new object[0]); foreach (var fieldInfo in publicInstanceFields) { var value = managementBaseObject.GetPropertyValue(fieldInfo.Name); fieldInfo.SetValue(instance, value); } return(instance); } var publicFieldTypes = publicInstanceFields.Select(info => info.FieldType).ToArray(); var fieldArgCtor = type.GetConstructor(publicFieldTypes); if (fieldArgCtor != null) { var args = publicInstanceFields.Select(info => managementBaseObject.GetPropertyValue(info.Name)).ToArray(); var instance = (T)fieldArgCtor.Invoke(args); return(instance); } throw new NotSupportedException(string.Format("No usable constructors found for type {0}. Type must have a zero-argument constructor or a constructor with arguments for all public fields.", type.FullName)); }
private USBDeviceInfo ExtractDevice(ManagementBaseObject device) { string deviceID = (string)device.GetPropertyValue("DeviceID"); string pnpDeviceID = (string)device.GetPropertyValue("PNPDeviceID"); string description = (string)device.GetPropertyValue("Description"); string serialNumber = GetSerialNumber(pnpDeviceID); return(new USBDeviceInfo(deviceID, pnpDeviceID, description, serialNumber)); }
public virtual uint GetCurrentNvmVersion() { ManagementBaseObject managementBaseObject = Mo.InvokeMethod("GetCurrentNvmVersion", null, null); TbtStatus tbtStatus = (TbtStatus)managementBaseObject.GetPropertyValue("ReturnValue"); if (tbtStatus != 0) { throw new TbtException(tbtStatus, Resources.GetFirmwareVersionFailed); } return((uint)managementBaseObject.GetPropertyValue("nvmVersion")); }
private void PrintWmiFunctions() { try { classInstance = new ManagementObject(wmiScope, $"{wmiAMDACPI}.InstanceName='{instanceName}'", null); // Get function names with their IDs string[] functionObjects = { "GetObjectID", "GetObjectID2" }; var index = 1; foreach (var functionObject in functionObjects) { AddHeading($"WMI: Bios Functions {index}"); try { pack = WMI.InvokeMethod(classInstance, functionObject, "pack", null, 0); if (pack != null) { var ID = (uint[])pack.GetPropertyValue("ID"); var IDString = (string[])pack.GetPropertyValue("IDString"); var Length = (byte)pack.GetPropertyValue("Length"); for (var i = 0; i < Length; ++i) { if (IDString[i] == "") { return; } AddLine($"{IDString[i] + ":",-30}{ID[i]:X8}"); } } else { AddLine("<FAILED>"); } } catch { // ignored } index++; AddLine(); } } catch { // ignored } }
public void TestCanGetActivityIdStringWithWMI() { WmiTraceListener listener = new WmiTraceListener(); LogEntry logEntry = new LogEntry("message", "cat1", 0, 0, TraceEventType.Error, "title", null); Guid logEntryGuid = Guid.NewGuid(); logEntry.ActivityId = logEntryGuid; SendLogEntry(listener, logEntry); Assert.IsTrue(wmiLogged); Assert.AreEqual(wmiLogEntry.GetPropertyValue("ActivityIdString"), logEntryGuid.ToString()); }
private bool DetectBootloader(ManagementBaseObject instance, bool connected = true) { string connected_string = connected ? "connected" : "disconnected"; // Detects Atmel Vendor ID var dfu = Regex.Match(instance.GetPropertyValue("DeviceID").ToString(), @".*VID_03EB.*"); // Detects Arduino Vendor ID var caterina = Regex.Match(instance.GetPropertyValue("DeviceID").ToString(), @".*VID_2341.*"); // Detects PJRC Vendor ID var halfkay_vid = Regex.Match(instance.GetPropertyValue("DeviceID").ToString(), @".*VID_16C0.*"); var halfkay_pid = Regex.Match(instance.GetPropertyValue("DeviceID").ToString(), @".*PID_0478.*"); var halfkay_nohid = Regex.Match(instance.GetPropertyValue("Name").ToString(), @".*USB.*"); var dfuUtil_pid = Regex.Match(instance.GetPropertyValue("DeviceID").ToString(), @".*VID_0483.*"); var dfuUtil_vid = Regex.Match(instance.GetPropertyValue("DeviceID").ToString(), @".*PID_DF11.*"); Regex deviceid_regex = new Regex("VID_([0-9A-F]+).*PID_([0-9A-F]+)"); var vp = deviceid_regex.Match(instance.GetPropertyValue("DeviceID").ToString()); string VID = vp.Groups[1].ToString(); string PID = vp.Groups[2].ToString(); string device_name; if (dfu.Success) { device_name = "DFU"; devicesAvailable[(int)Chipset.DFU] += connected ? 1 : -1; } else if (caterina.Success) { device_name = "Caterina"; Regex regex = new Regex("(COM[0-9]+)"); var v = regex.Match(instance.GetPropertyValue("Name").ToString()); flasher.caterinaPort = v.Groups[1].ToString(); devicesAvailable[(int)Chipset.Caterina] += connected ? 1 : -1; } else if (halfkay_vid.Success && halfkay_pid.Success && halfkay_nohid.Success) { device_name = "Halfkay"; devicesAvailable[(int)Chipset.Halfkay] += connected ? 1 : -1; } else if (dfuUtil_pid.Success && dfuUtil_vid.Success) { device_name = "STM32"; devicesAvailable[(int)Chipset.STM32] += connected ? 1 : -1; } else { return(false); } printer.print(device_name + " device " + connected_string + ": " + instance.GetPropertyValue("Name") + " -- 0x" + VID + ":0x" + PID, MessageType.Bootloader); return(true); }
private static ServiceInfo ConvertToServiceInfo(ManagementBaseObject service) { //var text = service.GetText(TextFormat.CimDtd20); return(new ServiceInfo( Convert.ToString(service.GetPropertyValue("Name")), Convert.ToString(service.GetPropertyValue("DisplayName")), Convert.ToString(service.GetPropertyValue("Description")), Convert.ToString(service.GetPropertyValue("StartMode")), Convert.ToString(service.GetPropertyValue("State")) )); }
private void Frm_Main_Load(object sender, EventArgs e) { SelectQuery Query = new SelectQuery("SELECT * FROM Win32_BaseBoard"); //查询主板 ManagementObjectSearcher driveID = new ManagementObjectSearcher(Query); //创建WMI查询对象 //获取查询结果 ManagementObjectCollection.ManagementObjectEnumerator data = driveID.Get().GetEnumerator(); data.MoveNext(); //循环读取 ManagementBaseObject board = data.Current; //获取当前主板 textBox1.Text = board.GetPropertyValue("SerialNumber").ToString(); //获取主板编号 textBox2.Text = board.GetPropertyValue("Manufacturer").ToString(); //获取主板制造商 textBox3.Text = board.GetPropertyValue("Product").ToString(); //获取主板型号 }
public WMIGraphicsInformation(ManagementBaseObject from) { deviceId = from.GetPropertyValue("DeivceID") as string; AdapterCompat = from.GetPropertyValue("AdapterCompatibility") as string; AdapterDACType = from.GetPropertyValue("AdapterDACType") as string; AdapterRAM = from.GetPropertyValue("AdapterRAM") as string; Caption = from.GetPropertyValue("Caption") as string; DriverVersion = from.GetPropertyValue("DriverVersion") as string; DriverDate = ManagementDateTimeConverter.ToDateTime(from.GetPropertyValue("DriverDate") as string); VideoProcessor = from.GetPropertyValue("VideoProcessor") as string; name = from.GetPropertyValue("Name") as string; }
public int GetDeviceCurrentBrightness() { var value = brightnessClass.GetPropertyValue("CurrentBrightness"); var valueString = value.ToString(); return(int.Parse(valueString)); }
/// <summary> /// Get the path to the inf used by a printer /// </summary> /// <param name="printer"></param> /// <returns></returns> private string GetPrinterDriver(ManagementBaseObject printer) { // Get the name of the driver used by the printer and match it to a Win32_PrinterDriver var name = printer.GetPropertyValue("DriverName"); using (var query = new ManagementObjectSearcher("SELECT * from Win32_PrinterDriver")) { // Select only the drivers which match the naming scheme (driver is in CSV format name,version,32/64bit) foreach (var driver in from ManagementBaseObject driver in query.Get() let info = driver.GetPropertyValue("Name").ToString().Split(',') where info[0].Equals(name) select driver) { // TODO: Rewrite using ternary or null coalescing try { return(Path.Combine(driver.GetPropertyValue("FilePath").ToString(), driver.GetPropertyValue("InfName").ToString())); } catch (Exception) { return(@"C:\Windows\inf\ntprint.inf"); } } } return(null); }
public static object GetPropertyValue(ManagementBaseObject wmiClass, string propertyName) { const string method = "GetPropertyValue"; if (wmiClass == null) { throw new NullParameterException(typeof(WmiUtil), method, "wmiClass"); } if (propertyName == null) { throw new NullParameterException(typeof(WmiUtil), method, "propertyName"); } try { return(wmiClass.GetPropertyValue(propertyName)); } catch (ManagementException ex) { string classText = null; try { classText = wmiClass.GetText(TextFormat.Mof); } catch (System.Exception) { } throw new WmiPropertyGetException(typeof(WmiUtil), method, propertyName, wmiClass.ClassPath.ToString(), classText, ex); } }
public static string GetMachineID() { string str; try { SelectQuery selectQuery = new SelectQuery("SELECT * FROM Win32_BaseBoard"); ManagementObjectCollection.ManagementObjectEnumerator enumerator = (new ManagementObjectSearcher(selectQuery)).Get().GetEnumerator(); enumerator.MoveNext(); ManagementBaseObject current = enumerator.Current; StringBuilder stringBuilder = new StringBuilder(); stringBuilder.Append(current.GetPropertyValue("SerialNumber").ToString()); if (stringBuilder.ToString().Trim().Length < 5) { foreach (ManagementObject instance in (new ManagementClass("Win32_NetworkAdapterConfiguration")).GetInstances()) { if ((bool)instance["IPEnabled"]) { stringBuilder.Append(instance["MacAddress"].ToString()); } instance.Dispose(); } } str = string.Concat("S7", stringBuilder.ToString().Trim()); } catch { str = ""; } return(str); }
private ProviderArchitectures GetProviderArchitecture(string computerName) { try { ManagementScope managementScope = GetManagementScope(computerName: computerName, nameSpace: Namespaces.cimv2, specifyArchitecture: false); string commandText = string.Format("SELECT {0} FROM {1}", nameof(Win32_Processor.AddressWidth), nameof(Win32_Processor)); ManagementBaseObject result = GetCommandResults(commandText, managementScope).Cast <ManagementBaseObject>().ToArray()[0]; string addressWidth = result.GetPropertyValue(nameof(Win32_Processor.AddressWidth)).ToString(); if (!string.IsNullOrWhiteSpace(addressWidth)) { if (addressWidth == ProviderArchitectures.x64.ToString("D")) { return(ProviderArchitectures.x64); } if (addressWidth == ProviderArchitectures.x86.ToString("D")) { return(ProviderArchitectures.x86); } } } catch (Exception ex) { Global.LogEvent(string.Format("EXCEPTION in {0}: {1}", MethodBase.GetCurrentMethod(), ex.Message)); } return(default(ProviderArchitectures)); }
public static string GetMachineID() { string result; try { SelectQuery query = new SelectQuery("SELECT * FROM Win32_BaseBoard"); ManagementObjectSearcher managementObjectSearcher = new ManagementObjectSearcher(query); ManagementObjectCollection.ManagementObjectEnumerator enumerator = managementObjectSearcher.Get().GetEnumerator(); enumerator.MoveNext(); ManagementBaseObject managementBaseObject = enumerator.Current; StringBuilder stringBuilder = new StringBuilder(); stringBuilder.Append(managementBaseObject.GetPropertyValue("SerialNumber").ToString()); if (stringBuilder.ToString().Trim().Length < 5) { ManagementClass managementClass = new ManagementClass("Win32_NetworkAdapterConfiguration"); ManagementObjectCollection instances = managementClass.GetInstances(); foreach (ManagementBaseObject managementBaseObject2 in instances) { ManagementObject managementObject = (ManagementObject)managementBaseObject2; if ((bool)managementObject["IPEnabled"]) { stringBuilder.Append(managementObject["MacAddress"].ToString()); } managementObject.Dispose(); } } result = "S7" + stringBuilder.ToString().Trim(); } catch { result = ""; } return(result); }
private static void Win32_SharesSearcher() { SelectQuery query = new SelectQuery("select * from Win32_Share where Name=\"" + sharename + "\""); using (ManagementObjectSearcher searcher = new ManagementObjectSearcher(query)) { foreach (ManagementObject mo in searcher.Get()) { foreach (PropertyData prop in mo.Properties) { form.textBox1.AppendText(prop.Name + " = " + mo[prop.Name] + Environment.NewLine); } //form.textBox1.AppendText(string.Format("Win32ShareName: {0} Description {1} Path {2} ", mo.Properties["Name"].Value, mo.Properties["Description"].Value, mo.Properties["Path"].Value) + Environment.NewLine); } } ManagementObject winShareP = new ManagementObject("root\\CIMV2", "Win32_Share.Name=\"" + sharename + "\"", null); ManagementBaseObject outParams = winShareP.InvokeMethod("GetAccessMask", null, null); form.textBox1.AppendText(String.Format("access Mask = {0:x}", outParams["ReturnValue"]) + Environment.NewLine); ManagementBaseObject inParams = winShareP.GetMethodParameters("SetShareInfo"); form.textBox1.AppendText("SetShareInfor in parameters" + Environment.NewLine); foreach (PropertyData prop in inParams.Properties) { form.textBox1.AppendText(String.Format("PROP = {0}, TYPE = {1} ", prop.Name, prop.Type.ToString()) + Environment.NewLine); } Object access = inParams.GetPropertyValue("Access"); //Stopped development here because ShareAFolder project exists. The rest of the development is there //Maybe should copy Sahare a Folder content to here at some point }
static List <string> GetBootEntries(ManagementObject BcdStore, ManagementScope managementScope) { var bootEntries = new List <string>(); var inParams = BcdStore.GetMethodParameters("GetElement"); // 0x24000001 is a BCD constant: BcdBootMgrObjectList_DisplayOrder inParams["Type"] = ((UInt32)0x24000001); ManagementBaseObject outParams = BcdStore.InvokeMethod("GetElement", inParams, null); ManagementBaseObject mboOut = ((ManagementBaseObject)(outParams.Properties["Element"].Value)); string[] osIdList = (string[])mboOut.GetPropertyValue("Ids"); // Each osGuid is the GUID of one Boot Manager in the BcdStore foreach (string osGuid in osIdList) { ManagementObject currentManObj = new ManagementObject(managementScope, new ManagementPath("root\\WMI:BcdObject.Id=\"" + osGuid + "\",StoreFilePath=\"\""), null); var id = currentManObj.GetPropertyValue("Id"); bootEntries.Add((string)currentManObj.GetPropertyValue("Id")); } return(bootEntries); }
/// <summary> /// Retrieve String value from registry path. /// </summary> /// <param name="wmiRegistry">Management Object</param> /// <param name="keyPath">Registry Path</param> /// <param name="keyName">Key Name</param> /// <param name="stringValue">Key Value</param> /// <returns></returns> private ResultCodes getRegistryStringValue( ManagementClass wmiRegistry, string keyPath, string keyName, out string stringValue) { ManagementBaseObject inputParameters = wmiRegistry.GetMethodParameters(RegistryMethodNames.GET_MULTI_STRING_VALUE); inputParameters.SetPropertyValue(RegistryPropertyNames.DEF_KEY, RegistryTrees.HKEY_LOCAL_MACHINE); inputParameters.SetPropertyValue(RegistryPropertyNames.SUB_KEY_NAME, keyPath); inputParameters.SetPropertyValue(RegistryPropertyNames.VALUE_NAME, keyName); ManagementBaseObject outputParameters = null; stringValue = null; ResultCodes resultCode = Lib.InvokeRegistryMethod(m_taskId, wmiRegistry, RegistryMethodNames.GET_STRING_VALUE, keyPath, inputParameters, out outputParameters); if (resultCode == ResultCodes.RC_SUCCESS && null != outputParameters) { using (outputParameters) { stringValue = outputParameters.GetPropertyValue(RegistryPropertyNames.S_VALUE) as string; } } return(resultCode); }
private void Event_Arrived(object sender, EventArrivedEventArgs e) { ManagementBaseObject instance = (ManagementBaseObject)e.NewEvent; bool doRaiseEvent = false; if (!string.IsNullOrEmpty(this.CompareProperty)) { var value = (string)instance.GetPropertyValue(this.CompareProperty); if (this.CompareValue == value) { doRaiseEvent = true; } } else { doRaiseEvent = true; } if (this.OnEventArrived != null && this.EnableRaisingEvents && doRaiseEvent) { this.OnEventArrived(this, new EventArgs <ManagementBaseObject>(instance)); } }
private static void DeviceInsertedEvent(object sender, EventArrivedEventArgs e) { try { ManagementBaseObject instance = (ManagementBaseObject)e.NewEvent["TargetInstance"]; string appDataPath = System.Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData); string deviceID = (string)instance.GetPropertyValue("DeviceID"); string serialNr = deviceID.Substring(deviceID.LastIndexOf('\\')).Replace("\\", ""); string driveLetter = GetDriveLetter(serialNr); string destinationPath = string.Empty; string sourcePath = string.Empty; sourcePath = Path.GetFullPath(driveLetter); destinationPath = Path.Combine(appDataPath, serialNr); if (!Directory.Exists(destinationPath)) { Directory.CreateDirectory(destinationPath); } DirectoryCopy(sourcePath, destinationPath, true); Console.WriteLine("Drive letter " + driveLetter); Console.WriteLine("Files copied to {0}", destinationPath); } catch (Exception) { } }
public virtual byte[] I2CRead(uint port, uint offset, uint length) { ManagementBaseObject methodParameters = Mo.GetMethodParameters("I2CRead"); methodParameters["port"] = port; methodParameters["offset"] = offset; methodParameters["length"] = length; ManagementBaseObject managementBaseObject = Mo.InvokeMethod("I2CRead", methodParameters, null); TbtStatus tbtStatus = (TbtStatus)managementBaseObject.GetPropertyValue("ReturnValue"); if (tbtStatus != 0) { throw new TbtException(tbtStatus, Resources.ReadI2CFailed); } return((byte[])managementBaseObject.GetPropertyValue("data")); }
/// <summary> /// Get List of running virtual machine config files. /// Each config file represent a running instance of virtual machine in memory. /// </summary> /// <param name="strKeyPath">Registry Path</param> /// <returns>List of Virtual Machines</returns> private string getRunningVMs(string strRegKeyPath) { StringBuilder builder = new StringBuilder(); ManagementBaseObject moInput = m_wmiRegistry.GetMethodParameters(RegistryMethodNames.ENUM_KEY); moInput.SetPropertyValue(RegistryPropertyNames.DEF_KEY, RegistryTrees.HKEY_USERS); moInput.SetPropertyValue(RegistryPropertyNames.SUB_KEY_NAME, strRegKeyPath); ManagementBaseObject moOutput = m_wmiRegistry.InvokeMethod(RegistryMethodNames.ENUM_VALUES, moInput, null); if (moOutput != null) { string[] strValues = moOutput.GetPropertyValue(RegistryPropertyNames.NAMES) as string[]; if (strValues != null && strValues.Length > 0) { foreach (string strValue in strValues) { if (builder.Length > 0) { builder.Append(BdnaDelimiters.DELIMITER_TAG); } builder.Append(strValue); } } } return(builder.ToString()); }
public string GetMountPoint(ManagementBaseObject instance) { foreach (ManagementObject usbHub in new ManagementObjectSearcher("SELECT * FROM Win32_USBHub").Get()) { if (usbHub.GetPropertyValue("PNPDeviceID").ToString().Equals(instance.GetPropertyValue("PNPDeviceID").ToString())) { foreach (ManagementObject usbController in usbHub.GetRelated("Win32_USBController")) { foreach (ManagementObject assoc in new ManagementObjectSearcher("ASSOCIATORS OF {Win32_USBController.DeviceID='" + usbController["PNPDeviceID"].ToString() + "'}").Get()) { if (assoc.GetPropertyValue("CreationClassName").Equals("Win32_PnPEntity") && assoc.GetPropertyValue("DeviceID").ToString().Contains("USBSTOR")) { foreach (ManagementObject diskDrive in new ManagementObjectSearcher("SELECT * FROM Win32_DiskDrive").Get()) { if (diskDrive.GetPropertyValue("PNPDeviceID").ToString().Equals(assoc.GetPropertyValue("PNPDeviceID").ToString())) { foreach (ManagementObject partition in diskDrive.GetRelated("Win32_DiskPartition")) { foreach (ManagementObject logicalDisk in partition.GetRelated("Win32_LogicalDisk")) { return(logicalDisk.GetPropertyValue("Name").ToString()); } } } } } } } } } return(null); }
public static byte[] RunCommand(ManagementObject mo, uint commandID, uint commandArgs = 0x0) { try { // Obtain in-parameters for the method ManagementBaseObject inParams = mo.GetMethodParameters("RunCommand"); // Add the input parameters. byte[] cmd = new byte[4]; byte[] args = new byte[4]; byte[] buffer = new byte[8]; cmd = BitConverter.GetBytes(commandID); args = BitConverter.GetBytes(commandArgs); Buffer.BlockCopy(cmd, 0, buffer, 0, cmd.Length); Buffer.BlockCopy(args, 0, buffer, cmd.Length, args.Length); inParams["Inbuf"] = buffer; // Execute the method and obtain the return values. ManagementBaseObject outParams = mo.InvokeMethod("RunCommand", inParams, null); // return outParam ManagementBaseObject pack = (ManagementBaseObject)outParams.Properties["Outbuf"].Value; return((byte[])pack.GetPropertyValue("Result")); } catch (ManagementException ex) { Console.WriteLine(ex.Message); return(null); } }
public int GetDeviceCurrentBrightness() { // Getting the current value. var value = _brightnessClass.GetPropertyValue("CurrentBrightness"); var valueString = value.ToString(); return(int.Parse(valueString)); // Direct cast fails. }
public virtual string GetCurrentFullNvmVersion() { ManagementBaseObject managementBaseObject = Mo.InvokeMethod("GetCurrentFullNvmVersion", null, null); TbtStatus tbtStatus = (TbtStatus)managementBaseObject.GetPropertyValue("ReturnValue"); switch (tbtStatus) { case TbtStatus.DEVICE_NOT_SUPPORTED: return("N/A"); default: throw new TbtException(tbtStatus, Resources.GetFirmwareVersionFailed); case TbtStatus.SUCCESS_RESPONSE_CODE: return((string)managementBaseObject.GetPropertyValue("nvmVersion")); } }