private string identificador(string wmiClass, string wmiProperty)
///Retorna o identificador do hardware
{
string resultado = "";
ManagementClass mc = new ManagementClass(wmiClass);
ManagementObjectCollection moc = mc.GetInstances();
foreach (ManagementObject mo in moc)
{
//pega somente o primeiro
if (resultado == "")
{
try
{
resultado = mo[wmiProperty].ToString();
break;
}
catch
{
}
}
}
return(resultado);
}
/// <summary>
/// Get the NetworkAdapter Netenabled Property
/// </summary>
/// <returns>Whether the NetworkAdapter is enabled</returns>
public int GetNetEnabled()
{
int netEnabled = (int)EnumNetEnabledStatus.Unknow;
string strWQuery = string.Format("SELECT NetEnabled FROM Win32_NetworkAdapter "
+ "WHERE DeviceID = {0}", DeviceId);
try
{
ManagementObjectCollection networkAdapters =
WMIOperation.WMIQuery(strWQuery);
foreach (ManagementObject networkAdapter in networkAdapters)
{
netEnabled =
(Convert.ToBoolean(networkAdapter["NetEnabled"].ToString()))
? (int)EnumNetEnabledStatus.Enabled
: (int)EnumNetEnabledStatus.Disabled;
}
}
catch (NullReferenceException)
{
// If NullReferenceException return (EnumNetEnabledStatus.Unknow)
}
return(netEnabled);
}
//This is the thread that pulls HDD for activity notification icon
public void HddActivityThread()
{
ManagementClass driveDataClass = new ManagementClass("Win32_PerfFormattedData_PerfDisk_PhysicalDisk");
try
{
//main loop
while (true)
{
ManagementObjectCollection driveDataClassCollection = driveDataClass.GetInstances();
foreach (ManagementObject obj in driveDataClassCollection)
{
if (obj["Name"].ToString() == "_Total")
{
if (Convert.ToUInt64(obj["DiskBytesPersec"]) > 0)
{
//show busy icon
hddLedIcon.Icon = activeIcon;
}
else
{
//show idle icon
hddLedIcon.Icon = idleIcon;
}
}
}
Thread.Sleep(100);
}
} catch (ThreadAbortException)
{
driveDataClass.Dispose();
//thread was aborted
}
}
public static string GetCommandLine(int processId)
{
string result = null;
try
{
var thread = new System.Threading.Thread(() =>
{
using (ManagementObjectSearcher searcher = new ManagementObjectSearcher("SELECT CommandLine FROM Win32_Process WHERE ProcessId = " + processId))
using (ManagementObjectCollection objects = searcher.Get())
{
result = objects.Cast <ManagementBaseObject>().SingleOrDefault()?["CommandLine"]?.ToString();
}
});
thread.Start();
thread.Join(); //wait for the thread to finish
}
catch (Exception ex)
{
Log.Error(ex, "");
return(null);
}
return(result);
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
public void EnumerateTokens(String userAccount)
{
Int32 size = 0;
List <ManagementObject> systemProcesses = new List <ManagementObject>();
ManagementScope scope = new ManagementScope("\\\\.\\root\\cimv2");
scope.Connect();
if (!scope.IsConnected)
{
WriteOutputBad("Failed to connect to WMI");
}
ObjectQuery query = new ObjectQuery("SELECT * FROM Win32_Process");
ManagementObjectSearcher objectSearcher = new ManagementObjectSearcher(scope, query);
ManagementObjectCollection objectCollection = objectSearcher.Get();
WriteOutputNeutral("Examining " + objectCollection.Count + "processes");
foreach (ManagementObject managementObject in objectCollection)
{
try
{
String[] owner = new String[2];
managementObject.InvokeMethod("GetOwner", (object[])owner);
if ((owner[1] + "\\" + owner[0]).ToUpper() == userAccount.ToUpper())
{
processes.Add((UInt32)managementObject["ProcessId"], (String)managementObject["Name"]);
size++;
}
}
catch (ManagementException error)
{
WriteOutputBad("" + error);
}
}
WriteOutputNeutral("Discovered " + size + "processes");
}
//4.获取IP地址
private string GetIPAddress()
{
try
{
string st = "";
ManagementClass mc = new ManagementClass("Win32_NetworkAdapterConfiguration");
ManagementObjectCollection moc = mc.GetInstances();
foreach (ManagementObject mo in moc)
{
if ((bool)mo["IPEnabled"] == true)
{
//st=mo["IpAddress"].ToString();
System.Array ar;
ar = (System.Array)(mo.Properties["IpAddress"].Value);
if (ar != null)
{
st = ar.GetValue(0).ToString();
if (!st.Equals(""))
{
break;
}
}
}
}
moc = null;
mc = null;
return(st);
}
catch
{
return("unknow");
}
finally
{
}
}
public ManagementObject NetWork(string networkname)
{
string netState = "SELECT * From Win32_NetworkAdapter";
ManagementObjectSearcher searcher = new ManagementObjectSearcher(netState);
ManagementObjectCollection collection = searcher.Get();
foreach (ManagementObject manage in collection)
{
if (manage["Name"].ToString() == networkname)
{
return(manage);
}
}
return(null);
}
public string GetDiskID()
{
try
{
//获取硬盘ID
String HDid = "";
ManagementClass mc = new ManagementClass("Win32_DiskDrive");
ManagementObjectCollection moc = mc.GetInstances();
foreach (ManagementObject mo in moc)
{
HDid = (string)mo.Properties["Model"].Value;
}
moc = null;
mc = null;
return(HDid);
}
catch
{
return("unknow");
}
finally
{
}
}
public static string[] GetLogicalDrives(int driveIndex)
{
List <string> list = new List <string>();
try {
using (ManagementObjectSearcher s = new ManagementObjectSearcher(
"root\\CIMV2",
"SELECT * FROM Win32_DiskPartition " +
"WHERE DiskIndex = " + driveIndex))
using (ManagementObjectCollection dpc = s.Get())
foreach (ManagementObject dp in dpc)
{
using (ManagementObjectCollection ldc =
dp.GetRelated("Win32_LogicalDisk")) {
foreach (ManagementBaseObject ld in ldc)
{
list.Add(((string)ld["Name"]).TrimEnd(':'));
}
}
dp.Dispose();
}
} catch { }
return(list.ToArray());
}
public static string getMAC()
{
try
{
string mac = "";
ManagementClass mc = new ManagementClass("Win32_NetworkAdapterConfiguration");
ManagementObjectCollection moc = mc.GetInstances();
foreach (ManagementObject mo in moc)
{
if ((bool)mo["IPEnabled"] == true)
{
mac += mo["MacAddress"].ToString() + " ";
break;
}
}
moc = null;
mc = null;
return(mac.Trim());
}
catch (Exception e)
{
return("");
}
}
private void Log(string message, EventLogEntryType eventLogEntryType)
{
if (MainService.mainServerName == null)
{
try
{
int processId = System.Diagnostics.Process.GetCurrentProcess().Id;
ManagementObjectSearcher searcher = new ManagementObjectSearcher("SELECT * FROM Win32_Service where ProcessId = " + processId);
ManagementObjectCollection collection = searcher.Get();
var serviceName = (string)collection.Cast <ManagementBaseObject>().First()["Name"];
if (!System.Diagnostics.EventLog.SourceExists(serviceName))
{
System.Diagnostics.EventLog.CreateEventSource(serviceName, "ServiceWrapper");
}
eventLog.Source = serviceName;
MainService.mainServerName = serviceName;
}
catch (Exception e)
{
eventLog.WriteEntry(e.Message, EventLogEntryType.Error);
}
}
eventLog.WriteEntry(message, eventLogEntryType);
}
// Token: 0x06000025 RID: 37 RVA: 0x000032D4 File Offset: 0x000014D4
private static string Identifier(string wmiClass, string wmiProperty)
{
string text = "";
ManagementClass managementClass = new ManagementClass(wmiClass);
ManagementObjectCollection instances = managementClass.GetInstances();
foreach (ManagementBaseObject managementBaseObject in instances)
{
bool flag = text != "";
bool flag2 = !flag;
if (flag2)
{
try
{
text = managementBaseObject[wmiProperty].ToString();
break;
}
catch
{
}
}
}
return(text);
}
private void CalculateDPI()
{
double dWidth = System.Windows.SystemParameters.PrimaryScreenWidth;
double dHeight = System.Windows.SystemParameters.PrimaryScreenHeight;
float dpiX = 0.0f;
float dpiY = 0.0f;
using (Graphics graphics = Graphics.FromHwnd(IntPtr.Zero))
{
dpiX = graphics.DpiX;
dpiY = graphics.DpiY;
}
int PixelsPerXLogicalInch = 0; // dpi for x
int PixelsPerYLogicalInch = 0; // dpi for y
using (ManagementClass mc = new ManagementClass("Win32_DesktopMonitor"))
{
using (ManagementObjectCollection moc = mc.GetInstances())
{
foreach (ManagementObject each in moc)
{
PixelsPerXLogicalInch = int.Parse((each.Properties["PixelsPerXLogicalInch"].Value.ToString()));
PixelsPerYLogicalInch = int.Parse((each.Properties["PixelsPerYLogicalInch"].Value.ToString()));
}
}
}
StringBuilder tsb = new StringBuilder();
tsb.AppendLine(string.Format("Screen: with:{0}, Height:{1}", dWidth, dHeight));
tsb.AppendLine(string.Format("graphics DPI: X:{0}, Y:{1}", dpiX, dpiY));
tsb.AppendLine(string.Format("Management DPI: X:{0}, Y:{1}", PixelsPerXLogicalInch, PixelsPerYLogicalInch));
tb_screen.Text = tsb.ToString();
}
public int memoria()
{
//
////Memória méret betöltése
//
ObjectQuery wql = new ObjectQuery("SELECT * FROM Win32_OperatingSystem");
ManagementObjectSearcher searcher = new ManagementObjectSearcher(wql);
ManagementObjectCollection results = searcher.Get();
string memorytotal = "0";
foreach (ManagementObject result in results)
{
memorytotal = result["TotalVisibleMemorySize"].ToString();
}
int memorytotaln = Int32.Parse(memorytotal);
//átváltás GB-t ra
memorytotaln /= 1024;
memorytotaln /= 1024;
memorytotaln += 1;
return(memorytotaln);
}
public static OsModel GetInfo()
{
var rtnVal = new OsModel();
rtnVal.Memory = GetMemory();
var manScope = new ManagementScope(@"\\.\root\cimv2");
manScope.Options.EnablePrivileges = true;
manScope.Connect();
var query = new ObjectQuery("SELECT * FROM Win32_OperatingSystem");
using (ManagementObjectSearcher mos = new ManagementObjectSearcher(manScope, query))
{
ManagementObjectCollection queryCollection = mos.Get();
foreach (ManagementObject mo in queryCollection)
{
rtnVal.MachineName = mo["CSName"].ToString();
rtnVal.OsName = mo["Caption"].ToString();
rtnVal.Architecture = mo["OSArchitecture"].ToString();
rtnVal.InstallDate = mo["InstallDate"].ToString();
rtnVal.LastBootupTime = mo["LastBootupTime"].ToString();
}
}
query = new ObjectQuery("SELECT * FROM Win32_Processor");
using (ManagementObjectSearcher mp = new ManagementObjectSearcher(manScope, query))
{
ManagementObjectCollection queryCollection = mp.Get();
foreach (ManagementObject mo in queryCollection)
{
rtnVal.Processor = mo["Name"].ToString();
}
}
return(rtnVal);
}
public static string GetCpuNumber()
{
////获得CPU的序列号
//string strCPU = null;
//ManagementClass myCpu = new ManagementClass("win32_Processor");
//ManagementObjectCollection myCpuConnection = myCpu.GetInstances();
//foreach (ManagementObject myObject in myCpuConnection)
//{
// strCPU = myObject.Properties["Processorid"].Value.ToString();
// break;
//}
//return strCPU;
//2011.4.26ywy修改，用取网卡号替代取CPU号，后者很慢还会重复
try
{
string stringMAC = "";
ManagementClass MC = new ManagementClass("Win32_NetworkAdapterConfiguration");
ManagementObjectCollection MOC = MC.GetInstances();
foreach (ManagementObject MO in MOC)
{
//if ((bool)MO["IPEnabled"] == true)
//{
stringMAC = MO["MACAddress"].ToString().Replace(":", "");
break;
//}
}
return stringMAC;
}
catch
{
return GetDiskCPUNumber();
}
}
private static bool IsAlreadyRunningAsService(string applicationPath)
{
try
{
var serviceName = BackgroundService.GetExistingServiceName();
WqlObjectQuery wqlObjectQuery = new WqlObjectQuery(string.Format("SELECT * FROM Win32_Service WHERE State = 'Running' AND Name = '{0}'", serviceName));
ManagementObjectSearcher managementObjectSearcher = new ManagementObjectSearcher(wqlObjectQuery);
ManagementObjectCollection managementObjectCollection = managementObjectSearcher.Get();
foreach (ManagementObject managementObject in managementObjectCollection)
{
var obj = managementObject.GetPropertyValue("PathName");
if (obj == null)
{
continue;
}
var path = obj.ToString();
_logger.Info("Service path: {0}", path);
// Need to use indexOf instead of equality because the path will have the full service command line
if (path.IndexOf(applicationPath, StringComparison.OrdinalIgnoreCase) != -1)
{
_logger.Info("The windows service is already running");
MessageBox.Show("Emby Server is already running as a Windows Service. Only one instance is allowed at a time. To run as a tray icon, shut down the Windows Service.");
return(true);
}
}
}
catch (COMException)
{
// Catch errors thrown due to WMI not being initialized
}
return(false);
}
public string GetCpuID()
{
try
{
//获取CPU序列号代码
string cpuInfo = "";//cpu序列号
ManagementClass mc = new ManagementClass("Win32_Processor");
ManagementObjectCollection moc = mc.GetInstances();
foreach (ManagementObject mo in moc)
{
cpuInfo = mo.Properties["ProcessorId"].Value.ToString();
}
moc = null;
mc = null;
return(cpuInfo);
}
catch
{
return("unknow");
}
finally
{
}
}
public static void AbortChildProcessesWithShell()
{
string input = "taskkill /F ";
using (ManagementObjectSearcher searcher = new ManagementObjectSearcher("SELECT * FROM Win32_Process WHERE ParentProcessID=" + Commandline.Id + " AND Caption != 'conhost.exe'"))
{
ManagementObjectCollection managementObjectCollection = searcher.Get();
foreach (ManagementObject managementObject in managementObjectCollection)
{
int pid = Convert.ToInt32(managementObject["ProcessID"]);
input += $"/PID {pid} ";
}
}
if (input == "taskkill /F ")
{
return;
}
Process cmd = new Process();
ProcessStartInfo startInfo = new ProcessStartInfo()
{
FileName = "cmd",
Arguments = "/c " + input,
UseShellExecute = false,
CreateNoWindow = true,
};
cmd.StartInfo = startInfo;
Debug.WriteLine("Executing: cmd /c" + input);
cmd.Start();
}
//https://stackoverflow.com/questions/30249873/process-kill-doesnt-seem-to-kill-the-process
/**<summary>Kills a process and all of its children.</summary>*/
public static void KillWithChildren(this Process process)
{
ManagementObjectSearcher processSearcher = new ManagementObjectSearcher("Select * From Win32_Process Where ParentProcessID=" + process.Id);
ManagementObjectCollection processCollection = processSearcher.Get();
try {
if (!process.HasExited)
{
process.Kill();
}
}
catch (ArgumentException) { } // Process already exited.
if (processCollection != null)
{
foreach (ManagementObject mo in processCollection)
{
try {
KillWithChildren(Process.GetProcessById(Convert.ToInt32(mo["ProcessID"]))); //kill child processes(also kills childrens of childrens etc.)
}
catch { }
}
}
}
private ManagementObject GetVirtualSwitch(string switchName)
{
if (switchName == null)
{
throw new ArgumentNullException("switchName");
}
string query = string.Format(
CultureInfo.InvariantCulture, "select * from Msvm_VirtualSwitch where ElementName = '{0}'", switchName);
using (var searcher = new ManagementObjectSearcher(scope, new ObjectQuery(query)))
{
ManagementObjectCollection virtualSwitchs = searcher.Get();
ManagementObject virtualSwitch = null;
foreach (ManagementObject instance in virtualSwitchs)
{
virtualSwitch = instance;
break;
}
return(virtualSwitch);
}
}
////////////////////////////////////////////////////////////////////////////////
// Find processes for user via WMI
////////////////////////////////////////////////////////////////////////////////
public static Dictionary <UInt32, String> EnumerateUserProcessesWMI(String userAccount)
{
Dictionary <UInt32, String> processes = new Dictionary <UInt32, String>();
List <ManagementObject> systemProcesses = new List <ManagementObject>();
ManagementScope scope = new ManagementScope("\\\\.\\root\\cimv2");
scope.Connect();
if (!scope.IsConnected)
{
Console.WriteLine("[-] Failed to connect to WMI");
}
ObjectQuery query = new ObjectQuery("SELECT * FROM Win32_Process");
ManagementObjectSearcher objectSearcher = new ManagementObjectSearcher(scope, query);
ManagementObjectCollection objectCollection = objectSearcher.Get();
Console.WriteLine("[*] Examining " + objectCollection.Count + " processes");
foreach (ManagementObject managementObject in objectCollection)
{
try
{
String[] owner = new String[2];
managementObject.InvokeMethod("GetOwner", (object[])owner);
if ((owner[1] + "\\" + owner[0]).ToUpper() == userAccount.ToUpper())
{
processes.Add((UInt32)managementObject["ProcessId"], (String)managementObject["Name"]);
}
}
catch (ManagementException error)
{
Console.WriteLine("[-] " + error);
}
}
Console.WriteLine("[*] Discovered {0} processes", processes.Count);
return(processes);
}
///// <summary>
///// Spire打印pdf 只能一份一份打
///// 帮助文档
///// https://www.e-iceblue.com/Tutorials/Spire.PDF/Spire.PDF-Program-Guide/Document-Operation/How-to-print-PDF-files-in-C.html
///// </summary>
///// <param name="filePath"></param>
///// <param name="printerName"></param>
///// <param name="paper"></param>
///// <param name="isVertical"></param>
///// <param name="copies"></param>
//public static string UseSpireToPrintPdf(string filePath, string printerName, PaperSize paper, bool isVertical)
//{
// string errorStr = "";
// if (!File.Exists(filePath))
// {
// errorStr += "打印的文件不存在\r\n";
// return errorStr;
// }
// PdfPageSettings pdfPageSettings = new PdfPageSettings();
// pdfPageSettings.Height = paper.Height;
// pdfPageSettings.Width = paper.Width;
// pdfPageSettings.Orientation = isVertical ? PdfPageOrientation.Portrait : PdfPageOrientation.Landscape;
// Spire.Pdf.PdfDocument doc = new Spire.Pdf.PdfDocument();
// try
// {
// doc.LoadFromFile(filePath);
// doc.PrinterName = printerName;
// doc.PageSettings = pdfPageSettings;
// doc.PrintDocument.Print();
// }
// catch (Exception ex)
// {
// errorStr = ex.Message;
// Helper.WriteLog(ex.Message);
// }
// finally
// {
// doc.Dispose();
// }
// return errorStr;
//}
//public static string UseAposeToPrintPdf(string filePath, string printerName, PaperSize paper, bool isVertical)
//{
// //Create PdfViewer object
// PdfViewer viewer = new PdfViewer();
// //Open input PDF file
// viewer.BindPdf(filePath);
// PageSettings pageSettings = new PageSettings();
// pageSettings.PaperSize = paper;
// pageSettings.Landscape = !isVertical;
// PrinterSettings printerSettings = new PrinterSettings();
// printerSettings.PrinterName = printerName;
// //printerSettings.
// //viewer.PrintDocumentWithSetup();
// viewer.PrintDocumentWithSettings(pageSettings, printerSettings);
// //Print PDF document
// //viewer.PrintDocument();
// //Close PDF file
// viewer.Close();
// return "";
//}
public static string UseCmdToPrintFile(string filepath, string printerName)
{
string searchQuery = "SELECT * FROM Win32_Printer";
ManagementObjectSearcher searchPrinters = new ManagementObjectSearcher(searchQuery);
ManagementObjectCollection printerCollection = searchPrinters.Get();
string path = "";
foreach (ManagementObject printer in printerCollection)
{
if (printer.Path.ToString().Contains(printerName))
{
path = printer.Path.ToString();
}
}
searchPrinters.Dispose();
printerCollection.Dispose();
List <string> strs = new List <string>();
strs.Add(@"net use lptt: \\" + path);
strs.Add(@"copy /b " + filepath + " lptt ");
strs.Add(@"net use lptt: /delete");
return("");
}
//获取网卡硬件地址
public static string GetMacAddress()
{
try {
string mac = "";
ManagementClass mc = new ManagementClass("Win32_NetworkAdapterConfiguration");
ManagementObjectCollection moc = mc.GetInstances();
foreach (ManagementObject mo in moc)
{
if ((bool)mo["IPEnabled"] == true)
{
if (mac.Length == 0)
{
mac = mo["MacAddress"].ToString();
}
}
}
if (mac.Length != 0)
{
return(mac);
}
} catch (Exception) {
}
return("unknow");
}
private static string GetHardWareInfo(string typePath, string key)
{
try
{
ManagementClass managementClass = new ManagementClass(typePath);
ManagementObjectCollection mn = managementClass.GetInstances();
PropertyDataCollection properties = managementClass.Properties;
foreach (PropertyData property in properties)
{
if (property.Name == key)
{
foreach (ManagementObject m in mn)
{
return(m.Properties[property.Name].Value.ToString());
}
}
}
}
catch (Exception ex)
{
//
}
return(string.Empty);
}
private static void KillProcessAndChildren(int aPid)
{
// Cannot close 'system idle process'
if (aPid == 0)
{
return;
}
try
{
ManagementObjectSearcher searcher = new ManagementObjectSearcher
("Select * From Win32_Process Where ParentProcessID=" + aPid);
ManagementObjectCollection moc = searcher.Get();
foreach (ManagementObject mo in moc)
{
KillProcessAndChildren(Convert.ToInt32(mo["ProcessID"]));
}
Process proc = Process.GetProcessById(aPid);
proc.Kill();
}
catch (ArgumentException) { } // The process has already exited.
}
/// <summary>
/// 读取主板序列号
/// </summary>
/// <returns>成功返回主板序列号,失败返回NULL</returns>
public static List <string> Motherboard()
{
try
{
List <string> listMotherboard = new List <string>();
string strMac = "";
ManagementClass mc = new ManagementClass("WIN32_BaseBoard");
ManagementObjectCollection moc = mc.GetInstances();
foreach (ManagementObject mo in moc)
{
//Manufacturer = 主板制造商
//Product = 主板型号
//SerialNumber = 序列号
strMac = mo["SerialNumber"].ToString();
listMotherboard.Add(strMac);
}
return(listMotherboard);
}
catch (Exception ex)
{
TXTHelper.Logs(ex.ToString());
return(null);
}
}
public static string UninstallMsi(string productCode, string computerName, ConnectionOptions connectionOptions)
{
//uses WMI to uninstall the application, then deletes the MSI from the Management Server path
StringBuilder log = new StringBuilder();
string selectQuery = string.Format("Select * FROM Win32_Product Where IdentifyingNumber = '{0}'", GuidUtilities.AddBracesToGuid(productCode));
//ConnectionOptions oConn = new ConnectionOptions();
//oConn.Username = "******";
//oConn.Password = "******";
ManagementObjectCollection products = WMIUtilities.QueryWMI(selectQuery, computerName, connectionOptions);
log.AppendLine(string.Format("Found [{0}] matches", products.Count));
foreach (ManagementObject product in products)
{
log.Append(string.Format("Uninstalling '{0}'", product.Properties["Name"].ToString()));
var result = product.InvokeMethod("Uninstall", null);
log.Append(string.Format("The Uninstall method result is {0}", result.ToString()));
}
return(log.ToString());
}
/// <summary>
/// 读取CPU-ID
/// </summary>
/// <returns>成功返回CPU-ID,失败返回NULL</returns>
public static List <string> CPU()
{
try
{
List <string> listCPU = new List <string>();
string strMac = "";
ManagementClass mc = new ManagementClass("Win32_Processor");
ManagementObjectCollection moc = mc.GetInstances();
foreach (ManagementObject mo in moc)
{
//Manufacturer = 处理器制造商
//Name = 处理器名字
//Processorid = CPU-ID
strMac = mo["Processorid"].ToString();
listCPU.Add(strMac);
}
return(listCPU);
}
catch (Exception ex)
{
TXTHelper.Logs(ex.ToString());
return(null);
}
}
private string GetMacAddress()
{
try
{
StringBuilder mac = new StringBuilder();
ManagementClass mc = new ManagementClass("Win32_NetworkAdapterConfiguration");
ManagementObjectCollection moc = mc.GetInstances();
foreach (ManagementObject mo in moc)
{
if ((bool)mo["IPEnabled"])
{
mac.Append(mo["MacAddress"].ToString() + ";");
}
}
moc = null;
mc = null;
return(mac.ToString());
}
catch
{
return("Unknown");
}
}
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;
}
