internal static ManagementObject WmiGetObject(string query)
{
if (CanAdjustBrightness)
{
try
{
System.Management.ManagementScope scope = new System.Management.ManagementScope("root\\WMI");
using (System.Management.ManagementObjectSearcher mos = new System.Management.ManagementObjectSearcher(scope, new SelectQuery(query)))
{
using (ManagementObjectCollection collection = mos.Get())
{
return(collection.OfType <ManagementObject>().FirstOrDefault());
}
}
}
catch
{
return(null);
}
}
else
{
return(null);
}
}
public List <string> StartServices(Dictionary <string, List <string> > servicesToStart, string login, string password, Label labelProcessInfo)
{
var errors = new List <string>();
ConnectionOptions connectoptions = new ConnectionOptions
{
Username = login,
Password = password
};
foreach (var serverName in servicesToStart.Keys)
{
try
{
if (serverName.ToLower() == Environment.MachineName.ToLower())
{
StartServices(servicesToStart[serverName], labelProcessInfo);
continue;
}
var scope = new ManagementScope($"\\\\{serverName}\\root\\cimv2")//
{
Options = connectoptions
};
scope.Connect();
foreach (var serviceName in servicesToStart[serverName])
{
try
{
SelectQuery query = new SelectQuery($"select * from Win32_Service where name = '{serviceName}'");
using (ManagementObjectSearcher searcher = new ManagementObjectSearcher(scope, query))
{
ManagementObjectCollection collection = searcher.Get();
foreach (ManagementObject service in collection.OfType <ManagementObject>())
{
if (service["started"].Equals(false))
{
ShowCurrentServiceInfo(serverName, serviceName, labelProcessInfo);
service.InvokeMethod("StartService", null);
}
}
}
}
catch (Exception ex)
{
errors.Add(serverName + ": " + serviceName + ": " + ex.Message);
}
}
}
catch (Exception ex)
{
errors.Add(serverName + ": " + ex.Message);
}
}
return(errors);
}
private void KillProcessAndChildren(int pid)
{
using (ManagementObjectSearcher processSearcher = new ManagementObjectSearcher
("Select * From Win32_Process Where ParentProcessID=" + pid))
{
ManagementObjectCollection processCollection = processSearcher.Get();
// We must kill child processes first!
foreach (ManagementObject mo in processCollection.OfType <ManagementObject>())
{
KillProcessAndChildren(Convert.ToInt32(mo["ProcessID"], CultureInfo.InvariantCulture)); //kill child processes(also kills childrens of childrens etc.)
}
}
// Then kill parents.
try
{
System.Diagnostics.Process proc = System.Diagnostics.Process.GetProcessById(pid);
if (!proc.HasExited)
{
proc.Kill();
}
}
catch (ArgumentException)
{
// Process already exited.
}
}
private static void DeviceInsertedEvent(object sender, EventArrivedEventArgs e)
{
string driveName = "";
string serialNumber = "";
string logFileName = "usb-grabber-";
try
{
driveName = e.NewEvent.Properties["DriveName"].Value.ToString();
ManagementObjectSearcher searcher = new ManagementObjectSearcher("SELECT VolumeSerialNumber from Win32_LogicalDisk where Name='" + driveName + "'");
ManagementObjectCollection list = searcher.Get();
serialNumber = list.OfType <ManagementObject>().FirstOrDefault().Properties["VolumeSerialNumber"].Value.ToString();
logFileName = logFileName + serialNumber + ".txt";
}
catch (Exception ex)
{
WriteLog("ERR :: Unable to read USB Drive Letter or Serial Number at " + DateTime.Now + ": " + ex.Message.ToString(), logFileName);
}
if (!String.IsNullOrEmpty(driveName))
{
WriteLog("****************************************************************************************************", logFileName);
WriteLog(driveName + " drive inserted at " + DateTime.Now, logFileName);
WriteLog(" ", logFileName);
CopyContent(driveName, serialNumber, logFileName);
}
}
public static void OSInfo()
{
using (WMI wmi = new WMI("."))
{
if (!wmi.Connect())
{
Console.WriteLine("Unable to Connect");
return;
}
wmi.ExecuteQuery("Select * FROM Win32_OperatingSystem");
ManagementObjectCollection results = wmi.GetResults();
if (null == results)
{
Console.WriteLine("WMI Query Failed");
return;
}
ManagementObject result = results.OfType <ManagementObject>().FirstOrDefault();
Console.WriteLine("OS Information");
Console.WriteLine("--------------");
Console.WriteLine("{0} {1} ({2})", result["Caption"], result["OSArchitecture"], result["BuildNumber"]);
Console.WriteLine("Computer Name : {0}", result["CSName"]);
Console.WriteLine("Free Memory : {0}/{1}", result["FreeVirtualMemory"], result["TotalVirtualMemorySize"]);
Console.WriteLine("Country & Locale : {0} - {1}", result["CountryCode"], result["Locale"]);
Console.WriteLine("System Device : {0}", result["SystemDevice"]);
Console.WriteLine("BitLocker Level : {0}", result["EncryptionLevel"]);
Console.WriteLine("InstallDate : {0}", result["InstallDate"]);
Console.WriteLine("LastBootUpTime : {0}", result["LastBootUpTime"]);
Console.WriteLine("LocalDateTime : {0}", result["LocalDateTime"]);
}
}
/// <exception cref="ManagementException" />
public virtual string FetchHardwareId()
{
try
{
string query = $"SELECT {this.Entity.EntityKey} FROM {this.Entity.ManagmentEntityId}";
using (ManagementObjectSearcher searcher = new ManagementObjectSearcher(query))
{
ManagementObjectCollection results = searcher.Get();
ManagementObject result = results.OfType <ManagementObject>()?.FirstOrDefault();
object value = result?[this.Entity.EntityKey];
string normalized = $"{value}".Trim();
return(normalized);
}
}
catch (ManagementException mex)
{
throw mex;
}
catch (Exception ex)
{
throw ex;
}
}
public static bool IsServerOS(string computerName)
{
ConnectionOptions options = new ConnectionOptions()
{
EnablePrivileges = true, Impersonation = ImpersonationLevel.Impersonate
};
ManagementScope scope = new ManagementScope(string.Format(@"\\{0}\root\CIMV2", computerName), options);
ObjectQuery query = new ObjectQuery("SELECT * FROM Win32_OperatingSystem");
using (ManagementObjectSearcher searcher = new ManagementObjectSearcher(scope, query))
using (ManagementObjectCollection results = searcher.Get())
{
if (results.Count != 1)
{
throw new ManagementException();
}
uint productType = (uint)results.OfType <ManagementObject>().First().Properties["ProductType"].Value;
switch (productType)
{
case 1:
return(false);
case 2:
return(true);
case 3:
return(true);
default:
throw new ManagementException();
}
}
}
public IEnumerable <Orchestration> Get()
{
List <Orchestration> orchestrations = new List <Orchestration>();
try
{
//Create EnumerationOptions and run wql query
EnumerationOptions enumOptions = new EnumerationOptions();
enumOptions.ReturnImmediately = false;
//Search for DB servername and trackingDB name
ManagementObjectSearcher searchObject = new ManagementObjectSearcher("root\\MicrosoftBizTalkServer", "Select TrackingDBServerName, TrackingDBName from MSBTS_GroupSetting", enumOptions);
ManagementObjectCollection searchCollection = searchObject.Get();
ManagementObject obj = searchCollection.OfType <ManagementObject>().FirstOrDefault();
string connectionString = "Server=" + obj["TrackingDBServerName"] + ";Database=" + obj["TrackingDBName"] + ";Integrated Security=True;";
string query = @"select A.nvcName [ApplicationName] " +
", O.[nvcFullName] [OrchestrationName] " +
", O.nOrchestrationStatus [OrchestrationStatus] " +
", MAX(SF.[ServiceInstance/StartTime]) [LastStartDateTime] " +
"from BizTalkMgmtDb.dbo.bts_orchestration O " +
"left outer join dtav_ServiceFacts SF on SF.[Service/Name] = O.nvcFullName " +
"join BizTalkMgmtDb.dbo.bts_item I on I.id = O.nItemID " +
"join BizTalkMgmtDb.dbo.bts_assembly ASSY on ASSY.nID = I.AssemblyId " +
"join BizTalkMgmtDb.dbo.bts_application A on A.nID = ASSY.nApplicationID " +
"group by A.nvcName, O.[nvcFullName], O.nOrchestrationStatus;";
using (SqlConnection connection = new SqlConnection(connectionString))
{
SqlCommand command = new SqlCommand(query, connection);
connection.Open();
SqlDataReader reader = command.ExecuteReader();
try
{
while (reader.Read())
{
Orchestration orchestration = new Orchestration();
orchestration.ApplicationName = (string)reader["ApplicationName"];
orchestration.OrchestrationName = (string)reader["OrchestrationName"];
orchestration.OrchestrationStatus = Enum.GetName(typeof(Orchestration.OrchestrationStatusEnum), (int)reader["OrchestrationStatus"]);
if (reader["LastStartDateTime"] != DBNull.Value)
{
orchestration.LastStartDateTime = (DateTime)reader["LastStartDateTime"];
}
orchestrations.Add(orchestration);
}
}
finally
{
// Always call Close when done reading.
reader.Close();
}
}
}
catch (Exception ex)
{
throw new Exception("Exception Occurred in get orchestrations call. " + ex.Message);
}
return(orchestrations);
}
////////////////////////////////////////////////////////////////////////////////
// Prints a management object collection
////////////////////////////////////////////////////////////////////////////////
public void PrintResults()
{
List <String> properties = new List <String>();
if (null == results || 0 == results.Count)
{
return;
}
Int32 length = 0;
ManagementObject propertiesObject = results.OfType <ManagementObject>().FirstOrDefault();
foreach (PropertyData property in propertiesObject.Properties)
{
properties.Add(property.Name);
if (property.Name.Length > length)
{
length = property.Name.Length;
}
}
foreach (ManagementObject managementObject in results)
{
foreach (String property in properties)
{
Console.WriteLine("{0,-" + length + "} {1}", property, managementObject[property]);
}
Console.WriteLine("");
}
}
public async Task <object> Invoke(object input)
{
var payload = input as object[];
string pNamespace = payload[0] as string;
string pQuery = payload[1] as string;
List <object> results = new List <object>();
if (pQuery == null)
{
throw new ArgumentException("Error: Query should be of string type");
}
// Define scope (namespace)
ManagementScope scope = new ManagementScope(pNamespace);
// Define query
SelectQuery query = new SelectQuery(pQuery);
ManagementObjectSearcher searcher = new ManagementObjectSearcher(scope, query);
ManagementObjectCollection objectCollection = searcher.Get();
var firstObject = objectCollection.OfType <ManagementObject>().FirstOrDefault();
var selectedItem = firstObject.Properties.OfType <PropertyData>().FirstOrDefault();
return(selectedItem.Value);
}
public IEnumerable <SendPort> Get()
{
List <SendPort> sendPorts = new List <SendPort>();
try
{
//Create EnumerationOptions and run wql query
EnumerationOptions enumOptions = new EnumerationOptions();
enumOptions.ReturnImmediately = false;
//Search for DB servername and trackingDB name
ManagementObjectSearcher searchObject = new ManagementObjectSearcher("root\\MicrosoftBizTalkServer", "Select TrackingDBServerName, TrackingDBName from MSBTS_GroupSetting", enumOptions);
ManagementObjectCollection searchCollection = searchObject.Get();
ManagementObject obj = searchCollection.OfType <ManagementObject>().FirstOrDefault();
string connectionString = "Server=" + obj["TrackingDBServerName"] + ";Database=" + obj["TrackingDBName"] + ";Integrated Security=True;";
string query = @"select A.nvcName [ApplicationName] " +
",SP.nvcName [SendPortName] " +
",SP.nPortStatus [PortStatus] " +
",MAX(MF.[Event/Timestamp]) [LastMessageSentDateTime] " +
"FROM " +
"BizTalkMgmtDb.dbo.bts_sendport SP " +
"LEFT OUTER JOIN BizTalkDTADb.dbo.dtav_MessageFacts MF ON MF.[Event/Port] = SP.nvcName " +
"JOIN BizTalkMgmtDb.dbo.bts_application A ON SP.nApplicationID = A.nID " +
"group by A.nvcName, SP.nvcName, SP.nPortStatus;";
using (SqlConnection connection = new SqlConnection(connectionString))
{
SqlCommand command = new SqlCommand(query, connection);
connection.Open();
SqlDataReader reader = command.ExecuteReader();
try
{
while (reader.Read())
{
SendPort sendPort = new SendPort();
sendPort.ApplicationName = (string)reader["ApplicationName"];
sendPort.SendPortName = (string)reader["SendPortName"];
sendPort.PortStatus = Enum.GetName(typeof(SendPort.SendPortStatusEnum), (int)reader["PortStatus"]);
if (reader["LastMessageSentDateTime"] != DBNull.Value)
{
sendPort.LastMessageSentDateTime = (DateTime)reader["LastMessageSentDateTime"];
}
sendPorts.Add(sendPort);
}
}
finally
{
// Always call Close when done reading.
reader.Close();
}
}
}
catch (Exception ex)
{
throw new Exception("Exception Occurred in get sendports call. " + ex.Message);
}
return(sendPorts);
}
private static string getPropertyValueFromSearcher(ManagementObjectSearcher searcher, string propertyName, string noResult = "")
{
using (ManagementObjectCollection queryCollection = searcher.Get())
{
ManagementObject obj = queryCollection.OfType <ManagementObject>().FirstOrDefault();
return(getPropertyValueFromManObject(obj, propertyName, noResult));
}
}
/// <summary>
/// 获取页面文件大小
/// </summary>
/// <returns></returns>
public static long GetPagingFileSize()
{
using (ManagementClass mc = new ManagementClass(WmiPathConst.OperatingSystem))
{
ManagementObjectCollection moc = mc.GetInstances();
return(moc.OfType <ManagementObject>()
.Select(mo => Convert.ToInt64(mo[ManagementObjectConst.SizeStoredInPagingFiles].ToString()))
.FirstOrDefault());
}
}
/// <summary>
/// 获取可用虚拟内存
/// </summary>
/// <returns></returns>
public static long GetFreeVirtualMemory()
{
using (ManagementClass mc = new ManagementClass(WmiPathConst.OperatingSystem))
{
ManagementObjectCollection moc = mc.GetInstances();
return(moc.OfType <ManagementObject>()
.Select(mo => Convert.ToInt64(mo[ManagementObjectConst.FreeVirtualMemory].ToString()))
.FirstOrDefault());
}
}
/// <summary>
/// 获取CPU最大频率
/// </summary>
/// <returns></returns>
public static string GetMaxMhz()
{
using (ManagementClass mc = new ManagementClass(WmiPathConst.Processor))
{
ManagementObjectCollection moc = mc.GetInstances();
return(moc.OfType <ManagementObject>()
.Select(mo => mo[ManagementObjectConst.MaxClockSpeed].ToString())
.FirstOrDefault());
}
}
/// <summary>
/// 获取启动设备
/// </summary>
/// <returns></returns>
public static string GetBootDevice()
{
using (ManagementClass mc = new ManagementClass(WmiPathConst.OperatingSystem))
{
ManagementObjectCollection moc = mc.GetInstances();
return(moc.OfType <ManagementObject>()
.Select(mo => mo[ManagementObjectConst.BootDevice].ToString())
.FirstOrDefault());
}
}
/// <summary>
/// 获取CPU当前频率
/// </summary>
/// <returns></returns>
public static List <string> GetCurrentMhz()
{
using (ManagementClass mc = new ManagementClass(WmiPathConst.Processor))
{
ManagementObjectCollection moc = mc.GetInstances();
return(moc.OfType <ManagementObject>()
.Select(mo => mo[ManagementObjectConst.CurrentClockSpeed].ToString())
.ToList());
}
}
public ComputerInfo GetComputerInfo(string computer)
{
ManagementObjectCollection computerInfoCollection = CIMQuery(computer, "Win32_ComputerSystem");
if (computerInfoCollection == null)
{
return(new ComputerInfo());
}
ManagementObject computerInfo = computerInfoCollection.OfType <ManagementObject>().First();
IPAddress[] addresses = Dns.GetHostAddresses(computer);
string computerIP = "";
int i = 0;
foreach (IPAddress a in addresses)
{
if (i > 0)
{
computerIP += "; ";
}
computerIP += a.ToString();
i++;
}
ManagementObjectCollection biosInfoCollection = CIMQuery(computer, "Win32_Bios");
ManagementObject biosInfo = biosInfoCollection.OfType <ManagementObject>().First();
ManagementObjectCollection windowsInfoCollection = CIMQuery(computer, "Win32_OperatingSystem");
ManagementObject windowsInfo = windowsInfoCollection.OfType <ManagementObject>().First();
ManagementObjectCollection enclosureInfoCollection = CIMQuery(computer, "Win32_SystemEnclosure");
ManagementObject enclosureInfo = enclosureInfoCollection.OfType <ManagementObject>().First();
string name = (computerInfo["Name"] ?? "N/A").ToString();
string address = computerIP;
string manufacturer = (computerInfo["Manufacturer"] ?? "N/A").ToString();
string model = (computerInfo["Manufacturer"] ?? "N/A").ToString() + " " + (computerInfo["Model"].ToString());
string serial = (biosInfo["SerialNumber"] ?? "N/A").ToString();
string version = (windowsInfo["Caption"] ?? "N/A") + " " + (windowsInfo["OSArchitecture"] ?? "????") + " (" + (windowsInfo["Version"] ?? "????") + ")";
string bootTime = (ManagementDateTimeConverter.ToDateTime(windowsInfo["LastBootUpTime"].ToString())).ToString();
string username = (computerInfo["Username"] ?? "N/A").ToString();
username = username.Remove(0, username.LastIndexOf("\\") + 1); //+1 to remove slashes
string displayName = new ADQuerier().GetDisplayName(username);
string assettag = (enclosureInfo["SMBIOSAssetTag"] ?? "N/A").ToString();
ComputerInfo info = new ComputerInfo(name, address, manufacturer, model, serial, version, username, displayName, assettag, bootTime);
return(info);
}
private void UpdateStatisticsFromWmi(int driveIndex)
{
string query = $"SELECT * FROM Win32_PerfRawData_PerfDisk_PhysicalDisk Where Name LIKE \"{driveIndex}%\"";
using (var perfData = new ManagementObjectSearcher(query)
{
Options = { Timeout = TimeSpan.FromSeconds(2.5) }
})
using (ManagementObjectCollection collection = perfData.Get())
using (ManagementObject data = collection.OfType <ManagementObject>().FirstOrDefault())
{
if (data == null)
{
return;
}
ulong value = (ulong)data.Properties["PercentDiskWriteTime"].Value;
ulong valueBase = (ulong)data.Properties["PercentDiskWriteTime_Base"].Value;
_perfWrite.Update(value, valueBase);
_sensorDiskWriteActivity.Value = (float)_perfWrite.Result;
value = (ulong)data.Properties["PercentIdleTime"].Value;
valueBase = (ulong)data.Properties["PercentIdleTime_Base"].Value;
_perfTotal.Update(value, valueBase);
_sensorDiskTotalActivity.Value = (float)(100.0 - _perfTotal.Result);
ulong readRateCounter = (ulong)data.Properties["DiskReadBytesPerSec"].Value;
ulong readRate = readRateCounter - _lastReadRateCounter;
_lastReadRateCounter = readRateCounter;
ulong writeRateCounter = (ulong)data.Properties["DiskWriteBytesPerSec"].Value;
ulong writeRate = writeRateCounter - _lastWriteRateCounter;
_lastWriteRateCounter = writeRateCounter;
ulong timestampPerfTime = (ulong)data.Properties["Timestamp_PerfTime"].Value;
ulong frequencyPerfTime = (ulong)data.Properties["Frequency_Perftime"].Value;
double currentTime = (double)timestampPerfTime / frequencyPerfTime;
double timeDeltaSeconds = currentTime - _lastTime;
if (_lastTime == 0 || timeDeltaSeconds > 0.2)
{
double writeSpeed = writeRate * (1 / timeDeltaSeconds);
_sensorDiskWriteRate.Value = (float)writeSpeed;
double readSpeed = readRate * (1 / timeDeltaSeconds);
_sensorDiskReadRate.Value = (float)readSpeed;
}
if (_lastTime == 0 || timeDeltaSeconds > 0.2)
{
_lastTime = currentTime;
}
}
}
/// <summary>
/// 获取总物理内存
/// </summary>
/// <returns></returns>
public static long GetTotalPhysicalMemory()
{
// 方法2：WmiPathConst.OperatingSystem、ManagementObjectConst.TotalVisibleMemorySize
using (ManagementClass mc = new ManagementClass(WmiPathConst.ComputerSystem))
{
ManagementObjectCollection moc = mc.GetInstances();
return(moc.OfType <ManagementObject>()
.Select(mo => Convert.ToInt64(mo[ManagementObjectConst.TotalPhysicalMemory].ToString()))
.FirstOrDefault());
}
}
public static ManagementObject[] Query(ObjectQuery objectQuery, ManagementScope managementScope = null)
{
objectQuery.NotNull(nameof(objectQuery));
using (ManagementObjectSearcher searcher = new ManagementObjectSearcher(
managementScope ?? new ManagementScope(), // Default ManagementPath: \\.\root\cimv2.
objectQuery)) // Default QueryLangauge: WQL.
using (ManagementObjectCollection processes = searcher.Get())
{
return(processes.OfType <ManagementObject>().ToArray());
}
}
/// <summary>
/// 获取硬盘信息
/// </summary>
/// <returns></returns>
public static List <DiskInfo> GetDiskInfos()
{
using (ManagementClass mc = new ManagementClass(WmiPathConst.DiskDrive))
{
ManagementObjectCollection moc = mc.GetInstances();
return(moc.OfType <ManagementObject>().Select(mo =>
new DiskInfo(
mo[ManagementObjectConst.Model].ToString(),
Convert.ToInt64(mo[ManagementObjectConst.Size])
)
).ToList());
}
}
public static ManagementObject[] Query(ObjectQuery objectQuery, ManagementScope?managementScope = null)
{
if (objectQuery == null)
{
throw new ArgumentNullException(nameof(objectQuery));
}
using ManagementObjectSearcher searcher = new(
managementScope ?? new(), // Default ManagementPath: \\.\root\cimv2.
objectQuery); // Default QueryLangauge: WQL.
using ManagementObjectCollection processes = searcher.Get();
return(processes.OfType <ManagementObject>().ToArray());
}
private static ManagementObject GetServerManagementObject()
{
ObjectQuery query = new ObjectQuery("SELECT * FROM MIIS_Server");
ManagementObjectSearcher searcher = new ManagementObjectSearcher(SyncServer.Scope, query);
ManagementObjectCollection moc = searcher.Get();
if (moc.Count == 0)
{
throw new InvalidOperationException();
}
ManagementObject mo = moc.OfType <ManagementObject>().First();
return(mo);
}
public Dictionary <string, object> GetServerFeatureOption(string objectName)
{
ManagementClass myManagementClass = new ManagementClass(objectName);
ManagementObjectCollection myManagementCollection = myManagementClass.GetInstances();
PropertyDataCollection myProperties = myManagementClass.Properties;
Dictionary <string, object> myPropertyResults = new Dictionary <string, object>();
var obj = myManagementCollection.OfType <ManagementObject>().FirstOrDefault();
foreach (var myProperty in myProperties)
{
myPropertyResults.Add(myProperty.Name,
obj.Properties[myProperty.Name].Value);
}
return(myPropertyResults);
}
public static int GetProcessIdByImageName(string ImageName)
{
string WmiQueryString = "select ProcessId, Name from Win32_Process where Name = '" + ImageName + "'";
using (ManagementObjectSearcher searcher = new ManagementObjectSearcher(WmiQueryString))
{
using (ManagementObjectCollection results = searcher.Get())
{
ManagementObject mo = results.OfType <ManagementObject>().FirstOrDefault();
if (mo != null)
{
return(Convert.ToInt32(mo["ProcessId"]));
}
}
}
return(0);
}
//http://stackoverflow.com/questions/9501771/how-to-avoid-a-win32-exception-when-accessing-process-mainmodule-filename-in-c
//MainModule Access 에러 나는 경우 있어 사용
public static string GetExecutablePathByProcessId(int ProcessId)
{
string wmiQueryString = "select ProcessId, ExecutablePath from Win32_Process where ProcessId = " + ProcessId;
using (ManagementObjectSearcher searcher = new ManagementObjectSearcher(wmiQueryString))
{
using (ManagementObjectCollection results = searcher.Get())
{
ManagementObject mo = results.OfType <ManagementObject>().FirstOrDefault();
if (mo != null)
{
return((string)mo["ExecutablePath"]);
}
}
}
return(null);
}
public void Put(string servername, string hostname, string state)
{
if (state == "Start" || state == "Stop")
{
EnumerationOptions enumOptions = new EnumerationOptions();
enumOptions.ReturnImmediately = false;
ManagementObjectSearcher searchObject = new ManagementObjectSearcher("root\\MicrosoftBizTalkServer", "Select * from MSBTS_HostInstance Where RunningServer='" + servername + "' And HostName='" + hostname + "'", enumOptions);
if (searchObject.Get().Count > 0)
{
ManagementObjectCollection instcol = searchObject.Get();
ManagementObject inst = instcol.OfType <ManagementObject>().FirstOrDefault();
inst.InvokeMethod(state, null);
}
}
}
private void Form1_Load(object sender, EventArgs e)
{
Version winver = Environment.OSVersion.Version;
int majorVer = winver.Major;
int minorver = winver.Minor;
int revisver = winver.Revision;
string winstr = Environment.OSVersion.ServicePack;
ManagementClass mc = new ManagementClass("Win32_OperatingSystem");
ManagementObjectCollection moc = mc.GetInstances();
ManagementObject mo = moc.OfType <ManagementObject>().FirstOrDefault();
string wincap = mo["Caption"].ToString();
string relsever = null;
string buildver = null;
string upbldver = null;
string usrName = null;
string orgName = null;
using (var hklmKey = Microsoft.Win32.Registry.LocalMachine)
using (var subKey = hklmKey.OpenSubKey(@"SOFTWARE\Microsoft\Windows NT\CurrentVersion")) {
if (subKey != null)
{
relsever = subKey.GetValue("ReleaseId") as string;
buildver = subKey.GetValue("CurrentBuildNumber") as string;
upbldver = subKey.GetValue("UBR").ToString() as string;
usrName = subKey.GetValue("RegisteredOwner") as string;
orgName = subKey.GetValue("RegisteredOrganization") as string;
}
}
lblVersion.Text = "Version " + relsever + " (OS Build " + buildver + "." + upbldver + ")";
lblCopyright.Text = "The " + wincap.Replace("Microsoft ", "") +
" operating system and its user interface are protected by trademark and other pending or existing intellectual property rights in the United States and other countries/regions.";
lblUsr.Text = usrName;
lblOrg.Text = orgName ?? "org name";
Bitmap winlogo = new Bitmap(Properties.Resources.win10);
winlogo.MakeTransparent(Color.White);
pictureBox1.Image = winlogo;
}
public List <string> GetAllStoppedServices(string serverName, string login, string password, List <string> servicesFirstPartDisplayNames)
{
var result = new List <string>();
ConnectionOptions connectoptions = new ConnectionOptions
{
Username = login,
Password = password
};
var scope = new ManagementScope($"\\\\{serverName}\\root\\cimv2")//
{
Options = connectoptions
};
scope.Connect();
foreach (var servicesFirstPartDisplayName in servicesFirstPartDisplayNames)
{
try
{
SelectQuery query = new SelectQuery($"select * from Win32_Service where name like '{servicesFirstPartDisplayName}%'");
using (ManagementObjectSearcher searcher = new ManagementObjectSearcher(scope, query))
{
ManagementObjectCollection collection = searcher.Get();
foreach (ManagementObject service in collection.OfType <ManagementObject>())
{
if (service["started"].Equals(false) && service["startMode"].Equals("Auto"))
{
result.Add(service["name"].ToString());
}
}
}
}
catch (Exception ex)
{
result.Add(servicesFirstPartDisplayName + ": " + ex.Message);
}
}
return(result);
}
