public static string GetHardDiskID2()
{
var strHardDiskID = string.Empty;
ManagementObjectSearcher wmiSearcher = new ManagementObjectSearcher();
/*
* 1. 接口
* 2. 型号
* 3. 驱动版本号
* 4. 硬盘出厂序列号
*/
//signature 需要程序以管理员身份运行
try
{
wmiSearcher.Query = new SelectQuery("Win32_DiskDrive", "", new string[] { "PNPDeviceID", "signature" });
ManagementObjectCollection myCollection = wmiSearcher.Get();
ManagementObjectCollection.ManagementObjectEnumerator em = myCollection.GetEnumerator();
myCollection.GetEnumerator();
em.MoveNext();
ManagementBaseObject mo = em.Current;
strHardDiskID = mo.Properties["signature"].Value.ToString().Trim();
return(strHardDiskID);
}
catch
{
return(string.Empty);
}
}
internal ManagementObject GetOne()
{
if (_enumerator == null)
{
_enumerator = _data.GetEnumerator();
_enumerator.MoveNext();
_isfirst = true;
}
try
{
if (_isfirst)
{
_records++;
}
return(_enumerator.Current as ManagementObject);
}
catch (IndexOutOfRangeException)
{
if (_isfirst)
{
_records--;
}
return(null);
}
}
public static string GetMemoryInfo()
{
ManagementObjectSearcher searcher = new ManagementObjectSearcher(); //用于查询一些如系统信息的管理对象
searcher.Query = new SelectQuery("Win32_PhysicalMemory ", "", new string[] { "Capacity" }); //设置查询条件
ManagementObjectCollection collection = searcher.Get(); //获取内存容量
ManagementObjectCollection.ManagementObjectEnumerator em = collection.GetEnumerator();
long capacity = 0;
while (em.MoveNext())
{
ManagementBaseObject baseObj = em.Current;
if (baseObj.Properties["Capacity"].Value != null)
{
try
{
capacity += (long.Parse(baseObj.Properties["Capacity"].Value.ToString())) / 1024 / 1024 / 1024;
}
catch
{
capacity = 0;
}
}
}
searcher.Query = new SelectQuery("Win32_PhysicalMemory ", "", new string[] { "Speed" }); //设置查询条件
collection = searcher.Get(); //获取内存速度（即频率）
em = collection.GetEnumerator();
string speed = "";
while (em.MoveNext())
{
ManagementBaseObject baseObj = em.Current;
if (baseObj.Properties["Speed"].Value != null)
{
try
{
speed = baseObj.Properties["Speed"].Value.ToString();
}
catch
{
speed = "";
}
}
}
string mi = "";
if (capacity > 0 && speed.Length > 0)
{
mi = capacity.ToString() + " GB, " + speed + " MHz";
}
return(mi);
}
/* Methode zum Ermitteln der Version des aktuellen Service Pack */
public static OSVersion GetServicePackVersion()
{
// Version-Instanz für die Rückgabe erzeugen
OSVersion version = new OSVersion();
// Win32_OperatingSystem-Instanz für das aktive Betriebssystem ermitteln
ManagementClass mc = new ManagementClass("Win32_OperatingSystem");
ManagementObjectCollection moc = mc.GetInstances();
ManagementObjectCollection.ManagementObjectEnumerator
mocEnumerator = moc.GetEnumerator();
mocEnumerator.MoveNext();
ManagementObject mo = (ManagementObject)mocEnumerator.Current;
// Die Version abfragen und speichern
try{ version.Major = (ushort)mo["ServicePackMajorVersion"]; }
catch {}
try{ version.Minor = (ushort)mo["ServicePackMinorVersion"]; }
catch {}
// WMI-Objekte freigeben um den Speicher möglichst schnell zu entlasten
mo.Dispose();
moc.Dispose();
mc.Dispose();
// Ergebnis zurückgeben
return(version);
}
public static string GetCPUId()
{
string cpuInfo = string.Empty;
string temp = string.Empty;
ManagementClass mc = new ManagementClass("Win32_Processor");
ManagementObjectCollection moc = mc.GetInstances();
try
{
ManagementObjectCollection.ManagementObjectEnumerator enumerator = moc.GetEnumerator();
while (enumerator.MoveNext())
{
ManagementObject mo = (ManagementObject)enumerator.Current;
if (Operators.CompareString(cpuInfo, string.Empty, false) == 0)
{
cpuInfo = mo.Properties["ProcessorId"].Value.ToString();
}
}
}
finally
{
ManagementObjectCollection.ManagementObjectEnumerator enumerator;
if (enumerator != null)
{
((IDisposable)enumerator).Dispose();
}
}
return(cpuInfo);
}
public static string GetMACAddress()
{
ManagementClass mc = new ManagementClass("Win32_NetworkAdapterConfiguration");
ManagementObjectCollection moc = mc.GetInstances();
string MACAddress = string.Empty;
try
{
ManagementObjectCollection.ManagementObjectEnumerator enumerator = moc.GetEnumerator();
while (enumerator.MoveNext())
{
ManagementObject mo = (ManagementObject)enumerator.Current;
if (Operators.CompareString(MACAddress, string.Empty, false) == 0 && Conversions.ToBoolean(mo["IPEnabled"]))
{
MACAddress = mo["MacAddress"].ToString();
}
mo.Dispose();
}
}
finally
{
ManagementObjectCollection.ManagementObjectEnumerator enumerator;
if (enumerator != null)
{
((IDisposable)enumerator).Dispose();
}
}
MACAddress = MACAddress.Replace(":", "");
return(MACAddress);
}
/// <summary>
/// 获取系统内存大小
/// </summary>
/// <returns>内存大小（单位M）</returns>
public static string GetMemoryTotal()
{
ManagementObjectSearcher searcher = new ManagementObjectSearcher();
searcher.Query = new SelectQuery(WindowsAPIType.Win32_PhysicalMemory.ToString(), "",
new string[] { WindowsAPIKeys.Capacity.ToString() });
ManagementObjectCollection collection = searcher.Get();
ManagementObjectCollection.ManagementObjectEnumerator em = collection.GetEnumerator();
long capacity = 0;
while (em.MoveNext())
{
ManagementBaseObject baseObj = em.Current;
if (baseObj.Properties[WindowsAPIKeys.Capacity.ToString()].Value != null)
{
try
{
capacity += long.Parse(baseObj.Properties[WindowsAPIKeys.Capacity.ToString()].Value.ToString());
}
catch
{
return("Error");
}
}
}
return(ByteToMB((double)capacity, 1024.0));
}
private static Process GetParentProcess()
{
Process parentProcess = null;
using (Process currentProcess = Process.GetCurrentProcess())
{
string filter = string.Format("ProcessId={0}", currentProcess.Id);
SelectQuery query = new SelectQuery("Win32_Process", filter);
using (ManagementObjectSearcher searcher = new ManagementObjectSearcher(query))
using (ManagementObjectCollection results = searcher.Get())
{
if (results.Count > 0)
{
if (results.Count > 1)
{
throw new InvalidOperationException();
}
IEnumerator resultEnumerator = results.GetEnumerator();
bool fMoved = resultEnumerator.MoveNext();
using (ManagementObject wmiProcess = (ManagementObject)resultEnumerator.Current)
{
PropertyData parentProcessId = wmiProcess.Properties["ParentProcessId"];
uint pid = (uint)parentProcessId.Value;
parentProcess = Process.GetProcessById((int)pid);
}
}
}
}
return(parentProcess);
}
/// <summary> 获取系统内存大小 </summary>
/// <returns> 内存大小（单位M） </returns>
public string GetPhisicalMemory()
{
//用于查询一些如系统信息的管理对象
ManagementObjectSearcher searcher = new ManagementObjectSearcher();
searcher.Query = new SelectQuery(WindowsAPIType.Win32_PhysicalMemory.ToString(), "", new string[] { WindowsAPIKeys.Capacity.ToString() }); //设置查询条件
ManagementObjectCollection collection = searcher.Get(); //获取内存容量
ManagementObjectCollection.ManagementObjectEnumerator em = collection.GetEnumerator();
long capacity = 0;
while (em.MoveNext())
{
ManagementBaseObject baseObj = em.Current;
if (baseObj.Properties[WindowsAPIKeys.Capacity.ToString()].Value != null)
{
try
{
capacity += long.Parse(baseObj.Properties[WindowsAPIKeys.Capacity.ToString()].Value.ToString());
}
catch
{
return("查询失败");
}
}
}
return(ToGB(capacity, 1024.0));
}
/// <summary>
/// This method checks if the context user, belongs to the local administrators group
/// </summary>
/// <param name="username"></param>
/// <returns></returns>
public bool CheckAdminRights(string username)
{
bool result = false;
List <string> admins = new List <string>();
//SelectQuery query = new SelectQuery("Select AccountType from Win32_UserAccount where Name=\"" + username + "\"");
SelectQuery query = new SelectQuery("SELECT * FROM win32_group WHERE Name=\"" + getAdministratorGroupName() + "\"");
ManagementObjectSearcher searcher = new ManagementObjectSearcher(query);
ManagementObjectCollection OC = searcher.Get();
IEnumerator enumerator = OC.GetEnumerator();
enumerator.MoveNext();
ManagementObject O = (ManagementObject)enumerator.Current;
ManagementObjectCollection adminusers = O.GetRelated("Win32_UserAccount");
foreach (ManagementObject envVar in adminusers)
{
admins.Add(envVar["Name"].ToString());
//Console.WriteLine("Username : {0}", envVar["Name"]);
//foreach (PropertyData pd in envVar.Properties)
// Console.WriteLine(string.Format(" {0,20}: {1}", pd.Name, pd.Value));
}
if (admins.Contains(username))
{
result = true;
}
return(result);
}
private static int GetPhisicalMemory()
{
ManagementObjectSearcher searcher = new ManagementObjectSearcher(); //用于查询一些如系统信息的管理对象
searcher.Query = new SelectQuery("Win32_PhysicalMemory", "", new string[] { "Capacity" }); //设置查询条件
ManagementObjectCollection collection = searcher.Get(); //获取内存容量
ManagementObjectCollection.ManagementObjectEnumerator em = collection.GetEnumerator();
int capacity = 0;
while (em.MoveNext())
{
ManagementBaseObject baseObj = em.Current;
if (baseObj.Properties["Capacity"].Value != null)
{
try
{
capacity += int.Parse(baseObj.Properties["Capacity"].Value.ToString());
}
catch
{
Console.WriteLine("有错误发生！", "错误信息");
return(0);
}
}
}
return(capacity);
}
ManagementObject GetNetAdapterManagementObject()
{
LogThis(LogLevel.Debug, "-> Get Management object ...");
var objectSearcher = new ManagementObjectSearcher("root\\StandardCimv2", $@"select * from MSFT_NetAdapter"); //Physical adapter
string q = String.Format("select * from MSFT_NetAdapter where {0}=\"{1}\"",
managementObjectTagForWindowsDeviceID,
windowsDeviceId
);
using (var searcher = new ManagementObjectSearcher("root\\StandardCimv2", q))
{
ManagementObjectCollection collection = searcher.Get();
if (collection.Count == 0) //Device isn't currently connected to host machine
{
LogThis(LogLevel.Debug, "Management object count is zero - returning null ...");
return(null);
}
else
{
LogThis(LogLevel.Debug, "Return Management object ...");
var enumerator = collection.GetEnumerator();
enumerator.MoveNext();
return((ManagementObject)enumerator.Current);
}
}
}
/// <summary>
/// Get list of namespaces under a path
/// </summary>
public ModelWMINamespaces GetListofNamespaces()
{
ModelWMINamespaces objData = new ModelWMINamespaces();
objData.Path = new ModelWMIPath(this.MgmntScope.Path.Server,
this.MgmntScope.Path.NamespacePath,
this.MgmntScope.Path.ClassName);
if (string.IsNullOrEmpty(this.MgmntScope.Path.ClassName) == false)
{
return(null);
}
ManagementObjectSearcher searcher = new ManagementObjectSearcher(this.MgmntScope,
new SelectQuery("__NAMESPACE"));
ManagementObjectCollection objColl = searcher.Get();
ManagementObjectCollection.ManagementObjectEnumerator objIndexer = objColl.GetEnumerator();
while (objIndexer.MoveNext())
{
foreach (PropertyData prop in objIndexer.Current.Properties)
{
objData.Lists.Add(prop.Value.ToString());
}
}
return(objData);
}
protected ArrayList DetectLocalMacAddresses()
{
ArrayList addresses = new ArrayList();
try
{
ManagementClass mc = new ManagementClass("Win32_NetworkAdapterConfiguration");
ManagementObjectCollection objects = mc.GetInstances();
ManagementObjectCollection.ManagementObjectEnumerator enumerator = objects.GetEnumerator();
while (enumerator.MoveNext())
{
ManagementObject mobj = (ManagementObject)(enumerator.Current);
if (mobj != null)
{
Object obj = mobj["MacAddress"];
if (obj != null)
{
addresses.Add(obj.ToString());
}
}
}
}
catch (Exception e)
{
e.ToString();
}
return(addresses);
}
//返回电脑cpu和硬盘序列号
public static string GetInfo()
{
string cpuSerialCode = "";//cpu序列号
ManagementClass cimobject = new ManagementClass("Win32_Processor");
ManagementObjectCollection moc = cimobject.GetInstances();
foreach (ManagementObject mo in moc)
{
cpuSerialCode = mo.Properties["ProcessorId"].Value.ToString();
}
////获取硬盘ID
//String HDid = "";
//ManagementClass cimobject1 = new ManagementClass("Win32_DiskDrive");
//ManagementObjectCollection moc1 = cimobject1.GetInstances();
//foreach (ManagementObject mo in moc1)
//{
// HDid = (string)mo.Properties["Model"].Value;
//}
ManagementObjectSearcher mos = new ManagementObjectSearcher();
mos.Query = new SelectQuery("Win32_DiskDrive", "", new string[] { "PNPDeviceID", "Signature" });
ManagementObjectCollection myCollection = mos.Get();
ManagementObjectCollection.ManagementObjectEnumerator em = myCollection.GetEnumerator();
em.MoveNext();
ManagementBaseObject moo = em.Current;
string HDSerialCode = moo.Properties["signature"].Value.ToString().Trim();
string result = cpuSerialCode + HDSerialCode;
return(result);
}
private void DeleteReceiveHandler(string adapterName, string serverName, string hostName, HandlerType handlerType)
{
try
{
string handler = handlerType == HandlerType.Receive ? "MSBTS_ReceiveHandler" : "MSBTS_SendHandler2";
string query = string.Format("Select * FROM {0} WHERE AdapterName=\"{1}\" AND HostName=\"{2}\"", handler, adapterName, hostName);
ManagementObjectSearcher searcher = new ManagementObjectSearcher(new ManagementScope(string.Format(BIZTALKSCOPE, serverName)), new WqlObjectQuery(query), null);
ManagementObjectCollection result = searcher.Get();
IEnumerator enumerator = result.GetEnumerator();
if (!enumerator.MoveNext())
{
Console.WriteLine("Not found");
return;
}
ManagementObject o = (ManagementObject)enumerator.Current;
o.Delete();
}
catch (Exception ex)
{
throw new ApplicationException("Failed while deleting receive handler", ex);
}
}
/// <summary>
/// 获取内存可用大小
/// </summary>
/// <returns>内存可用大小（单位M）</returns>
public static string GetMemoryAvailable()
{
long available = 0;
ManagementObjectSearcher searcher = new ManagementObjectSearcher();
searcher.Query = new SelectQuery(WindowsAPIType.Win32_PerfFormattedData_PerfOS_Memory.ToString(), "",
new string[] { WindowsAPIKeys.AvailableMBytes.ToString() });
ManagementObjectCollection collection = searcher.Get();
ManagementObjectCollection.ManagementObjectEnumerator em = collection.GetEnumerator();
while (em.MoveNext())
{
ManagementBaseObject baseObj = em.Current;
if (baseObj.Properties[WindowsAPIKeys.AvailableMBytes.ToString()].Value != null)
{
try
{
available += long.Parse(baseObj.Properties[WindowsAPIKeys.AvailableMBytes.ToString()].Value.ToString());
}
catch
{
return("Error");
}
}
}
return(available.ToString());
}
///检测物理内存信息
public string GetMemoryInfo()
{
string result = "";
ManagementObjectSearcher searcher = new ManagementObjectSearcher(); //用于查询一些如系统信息的管理对象
searcher.Query = new SelectQuery("Win32_PhysicalMemory ", "", new string[] { "Capacity", "manufacturer" }); //查询内存大小
ManagementObjectCollection collection = searcher.Get(); //获取内存容量与厂商
ManagementObjectCollection.ManagementObjectEnumerator em = collection.GetEnumerator();
long capacity = 0;
string manufacturer = "";
while (em.MoveNext())
{
ManagementBaseObject baseObj = em.Current;
if (baseObj.Properties["Capacity"].Value != null)
{
try
{
manufacturer = baseObj.Properties["Manufacturer"].Value.ToString();
capacity += long.Parse(baseObj.Properties["Capacity"].Value.ToString());
}
catch
{
return(null);
}
}
}
var theresult = (int)((capacity / 1024 / 1024)) / 1024 + "G";
result += manufacturer + " " + theresult.ToString();
return(result);
}
/// <summary>
/// Returns the list of Network Interfaces installed
/// </summary>
/// <param name="ipEnabled"> true(default) - returns only ipEnabled(network cards) devices</param>
/// <returns>Array list of string</returns>
public async Task <object> GetDevicesAsync(bool ipEnabled = true)
{
return(await Task.Run(() =>
{
ArrayList nicNames = new ArrayList {
};
using (ManagementClass mc = new ManagementClass("Win32_NetworkAdapterConfiguration"))
{
using (ManagementObjectCollection moc = mc.GetInstances())
{
var adaps = moc.GetEnumerator();
foreach (ManagementObject mo in moc)
{
if (ipEnabled)
{
if ((bool)mo["ipEnabled"])
{
nicNames.Add(mo["Caption"]);
}
}
else
{
nicNames.Add(mo["Caption"]);
}
}
}
}
try { Logging.Logger.Instanse.Log("Info", "Request for getting devices"); }
catch { }
return nicNames;
}));
}
private T SelectFirst <T>(ManagementObjectCollection instances)
{
IEnumerator enumerator = instances.GetEnumerator();
enumerator.MoveNext();
return((T)enumerator.Current);
}
private static void ChangeQueuePort(string portName, string newName)
{
ConnectionOptions options = new ConnectionOptions();
options.EnablePrivileges = true;
ManagementScope mgmtScope = new ManagementScope("root\\CIMV2", options);
mgmtScope.Connect();
ObjectQuery objQuery = new ObjectQuery("SELECT * FROM Win32_Printer WHERE PortName = '{0}'".FormatWith(portName));
using (ManagementObjectSearcher searcher = new ManagementObjectSearcher(mgmtScope, objQuery))
{
ManagementObjectCollection match = searcher.Get();
if (match.Count != 1)
{
throw new InvalidOperationException("Unexpected search result. Returned {0} matches for PortName:{1}".FormatWith(match.Count, portName));
}
var enumerator = match.GetEnumerator();
enumerator.MoveNext();
ManagementObject printerObject = (ManagementObject)enumerator.Current;
TraceFactory.Logger.Debug("Old Port: {0}, New Port: {1}".FormatWith(printerObject["PortName"], newName));
printerObject["PortName"] = newName;
PutOptions po = new PutOptions();
po.Type = PutType.UpdateOrCreate;
printerObject.Put(po);
}
}
internal ManagementObject GetWmiObject(string className, string filter, params object[] args)
{
ManagementObjectCollection col = GetWmiObjects(className, filter, args);
ManagementObjectCollection.ManagementObjectEnumerator enumerator = col.GetEnumerator();
return(enumerator.MoveNext() ? (ManagementObject)enumerator.Current : null);
}
/// <summary>
/// Gets the physcial cores and should this fail returns the Environment.ProcessorCount
/// that can also include logical cores.
/// </summary>
/// <returns>core count.</returns>
public static uint GetPhysicalCores()
{
try
{
ManagementScope scope = new ManagementScope("\\\\.\\ROOT\\cimv2");
ObjectQuery query = new ObjectQuery("SELECT NumberOfCores FROM Win32_Processor");
ManagementObjectSearcher searcher =
new ManagementObjectSearcher(scope, query);
ManagementObjectCollection queryCollection = searcher.Get();
var enumerator = queryCollection.GetEnumerator();
if (enumerator.MoveNext())
{
ManagementObject obj = (ManagementObject)enumerator.Current;
return((uint)obj["NumberOfCores"]);
}
else
{
return((uint)Environment.ProcessorCount);
}
}
// We are not very interested in throwing the exception, we might log it
// but this carries little information as if WMI fails there is very little
// that the we or the user can do to provide the correct information.
catch
{
return((uint)Environment.ProcessorCount);
}
}
private static ManagementObject GetreceiveLocationWmiObject(string receiveLocation)
{
var searcher = new ManagementObjectSearcher();
var scope = new ManagementScope("root\\MicrosoftBizTalkServer");
searcher.Scope = scope;
// Build a Query to enumerate the MSBTS_ReceiveLocation instances if an argument
// is supplied use it to select only the matching RL.
var query = new SelectQuery
{
QueryString = String.Format("SELECT * FROM MSBTS_ReceiveLocation WHERE Name =\"{0}\"", receiveLocation)
};
// Set the query for the searcher.
searcher.Query = query;
// Execute the query and determine if any results were obtained.
ManagementObjectCollection queryCol = searcher.Get();
ManagementObjectCollection.ManagementObjectEnumerator me = queryCol.GetEnumerator();
me.Reset();
if (me.MoveNext())
{
return((ManagementObject)me.Current);
}
else
{
throw new ApplicationException(string.Format("The WMI object for the receive location:{0} could not be retrieved.", receiveLocation));
}
}
public static LogicalDisk[] FillLogicalDisks(string machineName, string userName, string password,
string queryArea)
{
InitializeScope(machineName, userName, password);
ManagementClass managementClass = new ManagementClass(path + ":" + queryArea);
if (mScope != null)
{
managementClass.Scope = mScope;
}
ManagementObjectCollection instances = managementClass.GetInstances();
if (instances == null)
{
return(null);
}
LogicalDisk[] logicalDisks = new LogicalDisk[instances.Count];
ManagementObjectCollection.ManagementObjectEnumerator enumerator = instances.GetEnumerator();
int i = 0;
while (enumerator.MoveNext())
{
logicalDisks[i] = new LogicalDisk((ManagementObject)enumerator.Current);
i++;
}
return(logicalDisks);
}
public static Processor[] FillProcessorInformation(string machineName, string userName, string password,
string queryArea)
{
InitializeScope(machineName, userName, password);
ManagementClass managementClass = new ManagementClass(path + ":" + queryArea);
if (mScope != null)
{
managementClass.Scope = mScope;
}
ManagementObjectCollection instances = managementClass.GetInstances();
if (instances == null)
{
return(null);
}
Processor[] processors = new Processor[instances.Count];
ManagementObjectCollection.ManagementObjectEnumerator enumerator = instances.GetEnumerator();
int i = 0;
while (enumerator.MoveNext())
{
processors[i] = new Processor((ManagementObject)enumerator.Current);
i++;
}
return(processors);
}
public static HotFixes[] FillHotFixes(string machineName, string userName, string password, string queryArea)
{
InitializeScope(machineName, userName, password);
ManagementClass managementClass = new ManagementClass(path + ":" + queryArea);
if (mScope != null)
{
managementClass.Scope = mScope;
}
ManagementObjectCollection instances = managementClass.GetInstances();
if (instances == null)
{
return(null);
}
HotFixes[] hotfixesInstalled = new HotFixes[instances.Count];
ManagementObjectCollection.ManagementObjectEnumerator enumerator = instances.GetEnumerator();
int i = 0;
while (enumerator.MoveNext())
{
hotfixesInstalled[i] = new HotFixes((ManagementObject)enumerator.Current);
i++;
}
return(hotfixesInstalled);
}
// Token: 0x060000FE RID: 254 RVA: 0x00023524 File Offset: 0x00021724
private static object cju()
{
string result = string.Empty;
ManagementClass managementClass = new ManagementClass(<Module>.smethod_strings_decryptor(320864 -> "win32_processor")));
ManagementObjectCollection instances = managementClass.GetInstances();
try
{
ManagementObjectCollection.ManagementObjectEnumerator enumerator = instances.GetEnumerator();
for (;;)
{
IL_AA:
if (enumerator.MoveNext())
{
goto IL_8E;
}
uint num = 2116956050u;
ManagementObject managementObject;
for (;;)
{
IL_62:
uint num2;
switch ((num2 = (num ^ 2097288165u)) % 5u)
{
case 0u:
num = 788083082u;
continue;
case 2u:
result = managementObject.Properties[<Module>.smethod_strings_decryptor(320968 -> "processorID"))].Value.ToString();
public Source GetSource(ISourceParent parent, string name, bool ignoreCase)
{
string query = "SELECT * FROM " + Constants.Wmi.Source.Class
+ " WHERE Parent = '" + parent.FullName + "' AND Name = '" + name + "'";
var searcher = new ManagementObjectSearcher(_scope, new ObjectQuery(query));
using (ManagementObjectCollection configs = searcher.Get())
{
Debug.Assert(configs.Count <= 1, "configs.Count <= 1");
IEnumerator enumerator = configs.GetEnumerator();
if (!enumerator.MoveNext())
{
return(null); // Source not found.
}
Source source = CreateSource(parent, (ManagementObject)enumerator.Current);
// WQL is case-isensitive, so check the case below, if needed.
if (!ignoreCase && source.Name != name)
{
return(null);
}
parent.AddIfNotLoaded(source);
return(source);
}
}
/// <summary>
/// 获取系统内存大小
/// 以G为单位
/// </summary>
/// <returns>内存大小（单位M）</returns>
private int GetPhisicalMemory()
{
int phyMemSize = 0;
try
{
ManagementObjectSearcher searcher = new ManagementObjectSearcher(); //用于查询一些如系统信息的管理对象
searcher.Query = new SelectQuery("Win32_PhysicalMemory ", "", new string[] { "Capacity" }); //设置查询条件
ManagementObjectCollection collection = searcher.Get(); //获取内存容量
ManagementObjectCollection.ManagementObjectEnumerator em = collection.GetEnumerator();
long capacity = 0;
while (em.MoveNext())
{
ManagementBaseObject baseObj = em.Current;
if (baseObj.Properties["Capacity"].Value != null)
{
try
{
capacity += long.Parse(baseObj.Properties["Capacity"].Value.ToString());
}
catch
{
return(0);
}
}
}
phyMemSize = (int)(capacity / 1024 / 1024 / 1024);
}
catch (Exception)
{
}
return(phyMemSize);
}
internal static string smethod_18(ManagementObjectCollection managementObjectCollection_0, string string_10)
{
string text = "";
try
{
using (ManagementObjectCollection.ManagementObjectEnumerator enumerator = managementObjectCollection_0.GetEnumerator())
{
while (enumerator.MoveNext())
{
ManagementObject managementObject = (ManagementObject)enumerator.Current;
if (text == "")
{
try
{
text = managementObject[string_10].ToString();
break;
}
catch
{
text = "";
}
}
}
}
}
catch
{
text = "";
}
return text;
}
