c# 使用API读取系统信息并操作

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;
using System.Windows.Forms;
using System.Diagnostics;
using System.Threading;
using System.Collections;
using System.Drawing;
using System.ComponentModel;
using System.Management;
using System.ServiceProcess;
using Microsoft.Win32;

namespace ShutDownAndSystemManage
{
public class AllConctrl
{
#region 网络流量处理部分
private static NetworkAdapter[] adapters;
private static NetworkMonitor monitor;
public static int ErrorInfo;
private const int INTERNET_CONNECTION_MODEM = 1;
private const int INTERNET_CONNECTION_LAN = 2;
[DllImport("winInet.dll")]
private static extern bool InternetGetConnectedState(
ref   int dwFlag,
int dwReserved
);

#endregion

#region CPU 处理参数
private const string CategoryName = "Processor";
private const string CounterName = "% Processor Time";
private const string InstanceName = "_Total";
#endregion

#region 反射部分内容API声明
//内存部分
[DllImport("kernel32")]
public static extern void GlobalMemoryStatus(ref MemoryInfo meminfo);
//CPU部分
[DllImport("kernel32")]
public static extern void GetSystemInfo(ref CPUInfo cpuinfo);
//Windows路径部分
[DllImport("kernel32")]
public static extern void GetWindowsDirectory(StringBuilder WinDir, int count);
//系统路径部分
[DllImport("kernel32")]
public static extern void GetSystemDirectory(StringBuilder SysDir, int count);
//系统时间信息部分
[DllImport("kernel32")]
public static extern void GetSystemTime(ref SystemTimeInfo stinfo);
/// <summary> 
/// 激活窗体 
/// </summary> 
/// <param name="hWnd">句柄 </param> 
/// <returns> </returns> 
[DllImport("user32.dll", CharSet = CharSet.Auto)]
private static extern bool SetForegroundWindow(IntPtr hWnd);
//此处用于取得计算器窗口的句柄
[DllImport("user32.dll", EntryPoint = "FindWindow")]
private static extern int FindWindow(string lpClassName, string lpWindowName);
//发送信息
[DllImport("user32.dll")]
private static extern int SendMessage(IntPtr hWnd, int Msg, int wParam, int lParam);
//此处用于将窗口设置在最前
[DllImport("user32.dll")]
private static extern bool SetWindowPos(IntPtr hWnd, int hWndInsertAfter, int X, int Y, int cx, int cy, int uFlags);
#endregion

#region 调用GetSystemTime函数获取系统时间信息
/// <summary>
/// 调用GetSystemTime函数获取系统时间信息
/// </summary>
/// <param name="StInfo">系统时间结构</param>
/// <returns>当前时间字符串</returns>
public static void SystemTimeSearchInfo(SystemTimeInfo StInfo, Label lbl, ComboBox[] cbo, ComboBox[] cbos)
{
int count = 0;
while (true)
{
GetSystemTime(ref StInfo);
lbl.Text = StInfo.wYear.ToString() + "年" + StInfo.wMonth.ToString() + "月" + StInfo.wDay.ToString() + "日 " + (StInfo.wHour + 8).ToString() + "时" + StInfo.wMinute.ToString() + "分" + StInfo.wSecond.ToString() + "秒";
if (count == 0)
{
cbo[0].Text = cbos[0].Text = StInfo.wDay.ToString();
cbo[1].Text = cbos[1].Text = (StInfo.wHour + 8).ToString();
cbo[2].Text = cbos[2].Text = StInfo.wMinute.ToString();
count++;
}
Thread.Sleep(1000);
}
}
#endregion

#region 获取操作系统设置
/// <summary>
/// 获取操作系统设置
/// </summary>
public static void SystemSearchInfo(Label[] lb)
{
lb[0].Text = SystemInformation.ComputerName;
lb[1].Text = SystemInformation.Network ? "已连接" : "未连接";
lb[2].Text = SystemInformation.UserDomainName;
lb[3].Text = SystemInformation.UserName;
lb[4].Text = CheckBootMode();
lb[5].Text = SystemInformation.MenuFont.Name;
lb[6].Text = SystemInformation.MonitorCount.ToString();
lb[7].Text = SystemInformation.MousePresent ? "已安装" : "未安装";
lb[8].Text = SystemInformation.MouseButtons.ToString();
lb[9].Text = SystemInformation.UserInteractive ? "交互模式" : "非交互模式";
lb[10].Text = SystemInformation.VirtualScreen.Width + "*" + SystemInformation.VirtualScreen.Height;
}
#endregion

#region 判断启动方式
/// <summary>
/// 判断启动方式
/// </summary>
/// <returns></returns>
private static string CheckBootMode()
{
string bootMode = "";
switch (SystemInformation.BootMode)
{
case BootMode.FailSafe:
bootMode = "不具有网络支持的安全模式启动";
break;
case BootMode.FailSafeWithNetwork:
bootMode = "具有网络支持的安全模式启动";
break;
case BootMode.Normal:
bootMode = "正常启动";
break;
default:
break;
}
return bootMode;
}
#endregion

#region 内存监控部分
/// <summary>
/// 内存监控部分
/// </summary>
/// <param name="MemInfo">内存结构</param>
/// <returns>返回内存实体</returns>
public static void MemorySearchInfo(MemoryInfo MemInfo, Label[] lb)
{
while (true)
{
GlobalMemoryStatus(ref MemInfo);
double dwTotalPhys = (MemInfo.dwTotalPhys / 1024);
double dwAvailPhys = (MemInfo.dwAvailPhys / 1024);
double MemoryRate = ((dwTotalPhys - dwAvailPhys) / dwTotalPhys * 100);
lb[0].Text = dwTotalPhys.ToString() + "  KB";//物理内存总量
lb[1].Text = dwAvailPhys.ToString() + "  KB";//可使用物理内存
lb[2].Text = (MemInfo.dwTotalPageFile / 1024).ToString() + "  KB";//交换文件总大小
lb[3].Text = (MemInfo.dwAvailPageFile / 1024).ToString() + "  KB";//可用交换文件大小
lb[4].Text = (MemInfo.dwTotalVirtual / 1024).ToString() + "  KB";//虚拟内存总量
lb[5].Text = (MemInfo.dwAvailVirtual / 1024).ToString() + "  KB";//可用虚拟内存
lb[6].Text = Convert.ToInt32(MemoryRate) + "  %";
Thread.Sleep(1000);
}
}
#endregion

#region 获取网络流量信息部分
/// <summary>
/// 获取网络流量信息部分
/// </summary>
/// <param name="adapter"></param>
public static void NetSearchInfo(ListView lv, Label lb, CheckBox cb, ComboBox cbo, ComboBox cbos)
{
//网卡设备
NetworkAdapter adapter = null;
while (true)
{
monitor = new NetworkMonitor();
adapters = monitor.Adapters;
//对适配器判断
if (adapters.Length == 0 || ErrorInfo == 0)
{
lb.Text = "在计算机上没有找到网络适配器";
Point p = new Point((lv.Size.Width - lb.Size.Width) / 2, (lv.Size.Height - lb.Size.Height) / 2);
lb.Location = p;
lb.Visible = true;
cb.Checked = false;
cb.Enabled = false;
cbo.Enabled = false;
cbos.Enabled = false;
lv.Items.Clear();
adapter = null;
}
if (adapters.Length != 0)
{
cb.Enabled = true;
cbo.Enabled = true;
cbos.Enabled = true;
ErrorInfo = 1;
lb.Visible = false;
for (int i = 0; i < adapters.Length; i++)
{
adapter = adapters[i];
monitor.StopMonitoring();
monitor.StartMonitoring(adapter);
Thread Show = new Thread(new ThreadStart(delegate { ListViewShow(lv, adapter, adapters.Length, lb, cb, cbo, cbos); }));
Show.IsBackground = true;
Show.Start();
}
break;
}
Thread.Sleep(1000);
}
}
#endregion

#region 项窗体控件中添加项
/// <summary>
/// 项窗体控件中添加项
/// </summary>
/// <param name="lv"></param>
/// <param name="adapter"></param>
/// <param name="length"></param>
private static void ListViewShow(ListView lv, NetworkAdapter adapter, int length, Label lb, CheckBox cb, ComboBox cbo, ComboBox cbos)
{
while (true)
{
//适配器启用判断
if (ErrorInfo == 0)
{
lb.Visible = true;
lv.Items.Clear();
adapter = null;
NetSearchInfo(lv, lb, cb, cbo, cbos);
break;
}
string DownLoadValue = String.Format("{0:n} kbps", adapter.DownloadSpeedKbps);
string UploadValue = String.Format("{0:n} kbps", adapter.UploadSpeedKbps);
string CountValue = String.Format("{0:n} kbps", adapter.DownloadSpeedKbps + adapter.UploadSpeedKbps);
string[] str = new string[4];
str[0] = adapter.Name;
str[1] = UploadValue;
str[2] = DownLoadValue;
str[3] = CountValue;
ListViewItem lvi = new ListViewItem(str, 0);
lv.Items.Add(lvi);
Thread.Sleep(1000);
for (int i = 0; i < length; i++)
{
if (lv.Items[i].SubItems[0].Text == adapter.Name)
{
lv.Items[i].Remove();
}
}
}
}
#endregion

#region 获取CPU有关信息部分
/// <summary>
/// 获取CPU有关信息部分
/// </summary>
/// <param name="pc"></param>
/// <param name="CpuInfo">CPU信息结构</param>
/// <returns>返回CPU实体对象</returns>
public static void CPUSearchInfo(CPUInfo CpuInfo, Label[] lb)
{
PerformanceCounter pc = new PerformanceCounter(CategoryName, CounterName, InstanceName);
while (true)
{
GetSystemInfo(ref CpuInfo);
lb[0].Text = CpuInfo.dwNumberOfProcessors.ToString();
lb[1].Text = CpuInfo.dwProcessorType.ToString();
lb[2].Text = CpuInfo.dwProcessorLevel.ToString();
lb[3].Text = CpuInfo.dwOemId.ToString();
lb[4].Text = CpuInfo.dwPageSize.ToString() + "  MB";
lb[5].Text = pc.NextValue().ToString("00.00") + "%";
Thread.Sleep(1000);
}
}
#endregion

#region 窗体置前全部处理
/// <summary>
/// 窗体前置处理
/// </summary>
/// <param name="FormTitleName">窗体标题显示名称</param>
public static void FormPreposition(string FormTitleName)
{
int k = FindWindow(null, FormTitleName);
IntPtr iptr = new IntPtr(k);
SetWindowPos(iptr, -1, 0, 0, 0, 0, 3);
}

/// <summary>
/// 将窗体置前并置为活动的
/// </summary>
/// <param name="FormTitleName">窗体标题显示名称</param>
public static void FormPrepositionAndActive(string FormTitleName)
{
int k = FindWindow(null, FormTitleName);
IntPtr iptr = new IntPtr(k);
SetWindowPos(iptr, -1, 0, 0, 0, 0, 3);
SetForegroundWindow(iptr);
}
#endregion

#region 向任务管理ListView控件中添加进程信息
/// <summary>
/// 向任务管理ListView控件中添加进程信息
/// </summary>
/// <param name="lv"></param>
public static void ProcessList(ListView lv)
{
//while (true)
//{
//获取所有进程项
Process[] processes = Process.GetProcesses();
lv.BeginUpdate();
//清空ListView控件中所有的项
//遍历所有的进程项
foreach (Process instance in processes)
{
ListViewItem lvi = new ListViewItem(instance.ProcessName + ".exe");
lvi.SubItems.Add(FormatProcessID(instance.Id));
lvi.SubItems.Add(FormatMemorySize(instance.WorkingSet64));
lvi.ToolTipText = AddToolTip(instance);
lv.Items.Add(lvi);
}
lv.EndUpdate();
Thread.Sleep(1000);

// }
}
#endregion

#region 添加提示信息
/// <summary>
/// 添加提示信息
/// </summary>
/// <param name="instance"></param>
/// <returns></returns>
private static string AddToolTip(Process instance)
{
string strToolTip = null;
ProcessModuleCollection modules;
if (instance.ProcessName.CompareTo("System") != 0 || instance.ProcessName.CompareTo("Idle") != 0)
{
try
{
////当进程不充允枚举模块时会产生异常
modules = instance.Modules;
foreach (ProcessModule aModule in modules)
{
strToolTip += aModule.ModuleName;
strToolTip += "; ";
}
}
catch (System.ComponentModel.Win32Exception)
{
}
}
return strToolTip;
}
#endregion

#region 向任务管理ListView控件中添加任务信息
/// <summary>
/// 向任务管理ListView控件中添加任务信息
/// </summary>
/// <param name="lv"></param>
public static void TaskList(ListView lv)
{
//while (true)
//{
//获取所有进程项
Process[] processes = Process.GetProcesses();
lv.BeginUpdate();
//清空ListView控件中所有的项
lv.Items.Clear();

//遍历所有的进程项
foreach (Process instance in processes)
{
if (instance.MainWindowTitle != "")
{
ListViewItem lvi = new ListViewItem(instance.MainWindowTitle);
lvi.SubItems.Add(FormatProcessID(instance.Id));
lvi.SubItems.Add(instance.HasExited ? "停止运行" : "正在运行");
lv.Items.Add(lvi);
}
}
lv.EndUpdate();
//lv.Items[Records.SelectItem.Index].Selected = true;
//lv.Items[Records.SelectItem.Index].Focused = true;
//lv.Focus();
//lv.Items[Records.SelectItem.Index].EnsureVisible();
Thread.Sleep(1000);
//}
}
#endregion

#region 字符格式化
//格式化内存字符串
private static string FormatMemorySize(long lMemorySize)
{
return String.Format("{0,8:N0} K", lMemorySize / 1000);
}
//格式化进程字符
private static string FormatProcessID(int id)
{
return String.Format("{0,8}", id);
}
#endregion

#region 结束进程/结束任务
/// <summary>
/// 结束进程/结束任务
/// </summary>
/// <param name="lv">ListView控件</param>
public static void KillProcessExists(ListView lv)
{
if (lv.SelectedItems.Count != 0)
{
Process process = Process.GetProcessById(int.Parse(lv.SelectedItems[0].SubItems[1].Text));
process.Kill();
//删除当前项
lv.SelectedItems[0].Remove();
}
}
#endregion

#region 切换至处理
/// <summary>
/// 切换至处理
/// </summary>
/// <param name="lvt"></param>
/// <param name="tc"></param>
/// <param name="lvp"></param>
public static void Cutover(ListView lvt, TabControl tc, ListView lvp)
{
if (lvt.SelectedItems.Count != 0)
{
Process[] processes = Process.GetProcesses();
foreach (Process instance in processes)
{
if (instance.Id.ToString().Trim() == lvt.SelectedItems[0].SubItems[1].Text.Trim())
{
tc.SelectedIndex = 1;
for (int i = 0; i < lvp.Items.Count; i++)
{
string temp = lvp.Items[i].SubItems[1].Text;
if (instance.Id.ToString().Trim() == temp.Trim())
{
lvp.Items[i].Selected = true;
lvp.Items[i].Focused = true;
lvp.Focus();
lvp.Items[i].EnsureVisible();
}
}
}
}
}
}
#endregion

#region 读取所有服务信息
/// <summary>
/// 读取所有服务信息
/// </summary>
/// <param name="lv"></param>
public static void ReadServices(ListView lv, Label lb,Label lbl)
{
lv.BeginUpdate();
lv.Items.Clear();
lb.Text = "正在加载服务信息";
lb.Visible = true;
Point p = new Point((lv.Size.Width - lb.Size.Width) / 2, (lv.Size.Height - lb.Size.Height) / 2);
lb.Location = p;
foreach (ServerInfo item in GetAllServerInfo(lb))
{
ListViewItem lvi = new ListViewItem(item.ServerName);
lvi.SubItems.Add(item.Description);
lvi.SubItems.Add(item.ServerState);
lvi.SubItems.Add(item.RunType);
lvi.ToolTipText = "服务名称:"+item.ServerName+"; 关联名称"+item.Description + ";";
lv.Items.Add(lvi);
}
lbl.Text = "总计服务有：" + lv.Items.Count.ToString() + "项";
lv.EndUpdate();

}
#endregion

#region 服务相关控制

/// <summary>
/// 获取所有服务信息
/// </summary>
/// <returns></returns>
public static List<ServerInfo> GetAllServerInfo(Label lb)
{
List<ServerInfo> si = new List<ServerInfo>();
ServiceController[] sc = ServiceController.GetServices();
for (int i = 0; i < sc.Length; i++)
{
ServerInfo serverinfo = new ServerInfo();
serverinfo.ServerName = sc[i].DisplayName;
serverinfo.Description = sc[i].ServiceName;
string ServerState = "";
switch (sc[i].Status.ToString())
{
case "Running":
ServerState = "已启动";
break;
case "Paused":
ServerState = "暂停";
break;
default:
break;
}
serverinfo.ServerState = ServerState;
//Thread rtThread = new Thread(new ThreadStart(delegate { }));
//rtThread.IsBackground = true;
//rtThread.Start();
serverinfo.RunType = GetWindowsServiceStartType(sc[i].ServiceName);
si.Add(serverinfo);
}
lb.Visible = false;
return si;
}

/// <summary>
/// 停止服务
/// </summary>
/// <param name="Service">服务对象</param>
/// <returns></returns>
public static void stopService(ServiceController Service, ref bool state)
{
try
{
if (Service.CanStop && Service.Status != ServiceControllerStatus.Stopped && Service.Status != ServiceControllerStatus.StopPending)
{
Service.Stop();
state = true;
}
}
catch
{
state = false;
}
}

/// <summary>
/// 启动服务
/// </summary>
/// <param name="Service">服务对象</param>
/// <returns></returns>
public static void startService(ServiceController Service, ref bool state)
{
try
{
if (Service.Status != ServiceControllerStatus.Running && Service.Status != ServiceControllerStatus.StartPending)
{
Service.Start();
state = true;
}
}
catch
{
state = false;
}
}

/// <summary>
/// 重启服务
/// </summary>
/// <param name="Service"></param>
/// <returns></returns>
public static void resetService(ServiceController Service, ref bool state)
{
try
{
stopService(Service, ref state);
if (state)
{
startService(Service, ref state);
}
}
catch
{ state = false; }
}

/// <summary>
/// 暂停服务
/// </summary>
/// <param name="Service"></param>
/// <returns></returns>
public static void preService(ServiceController Service, ref bool state)
{
try
{
if (Service.Status != ServiceControllerStatus.Paused && Service.Status != ServiceControllerStatus.PausePending)
{
Service.Pause();
state = true;
}
state = false;
}
catch
{
state = false;
}
}

/// <summary>
/// 继续服务
/// </summary>
/// <param name="Service"></param>
/// <returns></returns>
public static void resumeService(ServiceController Service, ref bool state)
{
try
{
if (Service.Status == ServiceControllerStatus.Paused)
{
Service.Continue();
state = true;
}
state = false;
}
catch
{
state = false;
}
}
#endregion

#region 读取服务启动状态
/// <summary>
/// 读取服务启动状态
/// </summary>
/// <param name="sServiceName"></param>
/// <returns></returns>
public static string GetWindowsServiceStartType(String sServiceName)
{
try
{
ProcessStartInfo objProcessInf = new ProcessStartInfo();
objProcessInf.FileName = "cmd.exe";
objProcessInf.UseShellExecute = false;
objProcessInf.RedirectStandardError = true;
objProcessInf.RedirectStandardInput = true;
objProcessInf.RedirectStandardOutput = true;
objProcessInf.CreateNoWindow = true;
objProcessInf.Arguments = "/c sc qc " + sServiceName;
Process objProcess = Process.Start(objProcessInf);
String sStateValue = objProcess.StandardOutput.ReadToEnd();
if (sStateValue.IndexOf("AUTO_START") > 0)
{
return "自动";
}
if (sStateValue.IndexOf("DEMAND_START") > 0)
{
return "手动启动";
}
if (sStateValue.IndexOf("DISABLED") > 0)
{
return "禁用";
}
return "未知";
}
catch (Exception e)
{
return e.Message;
}
}
#endregion

#region 通过注册表修改服务启动状态
/// <summary>
/// 通过注册表修改服务启动状态
/// </summary>
/// <param name="ServerName">服务名称</param>
/// <param name="state">启动状态</param>
public static void UpdateServerRunType(string ServerName,int state)
{
string keyPath = @"SYSTEM\CurrentControlSet\Services\" + ServerName;
RegistryKey key = Registry.LocalMachine.OpenSubKey(keyPath, true);
if (key != null)
{
int val = -1;
bool bConverted = Int32.TryParse(key.GetValue("Start").ToString(), out val);
if (bConverted)
{
key.SetValue("Start", state);
}
}
}
#endregion

#region 关闭危险的服务方法
/// <summary>
/// 关闭危险的服务方法
/// </summary>
public static void DangerServer()
{
bool state = false;
// 使用成员变量禁止服务方法
for (int i = 0; i < Records.servername.Length; i++)
{
UpdateServerRunType(Records.servername[i], 4);
}

// 使用成员变量关闭服务方法
for (int i = 0; i < Records.showname.Length; i++)
{
ServiceController Service = new ServiceController(Records.showname[i]);
stopService(Service, ref state);
}
frm_ShowMessage.Checks = 1;
frm_ShowMessage frm = new frm_ShowMessage();
frm.ShowDialog();
}
#endregion

#region 关闭浪费资源的服务方法
/// <summary>
/// 关闭浪费资源的服务方法
/// </summary>
public static void Waste()
{
bool state = false;
// 使用成员变量关闭服务方法
for (int i = 0; i < Records.showPname.Length; i++)
{
ServiceController Service = new ServiceController(Records.showPname[i]);
stopService(Service, ref state);
}
// 使用成员变量禁止服务方法
for (int i = 0; i < Records.serverPname.Length; i++)
{
UpdateServerRunType(Records.serverPname[i], 4);
}
frm_ShowMessage.Checks = 0;
frm_ShowMessage frm = new frm_ShowMessage();
frm.ShowDialog();
}
#endregion

#region 取消开机自动启动
/// <summary>
/// 取消开机自动启动
/// </summary>
/// <param name="keyName"></param>
public static void DeleteKey(string keyName,ref bool state)
{
RegistryKey hklm = Registry.LocalMachine;
RegistryKey runs = hklm.OpenSubKey(@"Software\Microsoft\Windows\CurrentVersion\Run", true);
try
{
//注意此处用的是GetValueNames()
string[] runsName = runs.GetValueNames();
foreach (string strName in runsName)
{
if (strName.ToUpper() == keyName.ToUpper())
{
runs.DeleteValue(strName, false);
state = true;
}
}
}
catch(Exception)
{
state = false; 
}
}
#endregion

#region 写入开机自动启动
/// <summary>
/// 写入开机自动启动
/// </summary>
/// <param name="keyName"></param>
/// <param name="keyValue"></param>
/// <returns></returns>
public static void WriteKey(string keyName, string keyValue,ref bool state)
{
RegistryKey hklm = Registry.LocalMachine;

//定义hklm指向注册表的LocalMachine,其中 Software\Microsoft\Windows\CurrentVersion\Run就是关系到系统中随系统启动而启动的程序，通称启动项
RegistryKey run = hklm.CreateSubKey(@"Software\Microsoft\Windows\CurrentVersion\Run");
try
{
//将我们的程序加进去
run.SetValue(keyName, keyValue);
//注意，一定要关闭，注册表应用。
hklm.Close();
state = true;
}
catch //这是捕获异常的
{
state = false;
}
}
#endregion
}
}


类：CloseComputer

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;
using System.Windows.Forms;
using System.Threading;

namespace ShutDownAndSystemManage
{
public class CloseComputer
{
#region 关机用到的API代码

[StructLayout(LayoutKind.Sequential, Pack = 1)]

internal struct TokPriv1Luid
{
public int Count;

public long Luid;

public int Attr;
}

[DllImport("kernel32.dll", ExactSpelling = true)]

internal static extern IntPtr GetCurrentProcess();

[DllImport("advapi32.dll", ExactSpelling = true, SetLastError = true)]

internal static extern bool OpenProcessToken(IntPtr h, int acc, ref IntPtr phtok);

[DllImport("advapi32.dll", SetLastError = true)]

internal static extern bool LookupPrivilegeValue(string host, string name, ref long pluid);

[DllImport("advapi32.dll", ExactSpelling = true, SetLastError = true)]

internal static extern bool AdjustTokenPrivileges(IntPtr htok, bool disall,

ref TokPriv1Luid newst, int len, IntPtr prev, IntPtr relen);

[DllImport("user32.dll", ExactSpelling = true, SetLastError = true)]

internal static extern bool ExitWindowsEx(int flg, int rea);

internal const int SE_PRIVILEGE_ENABLED = 0x00000002;

internal const int TOKEN_QUERY = 0x00000008;

internal const int TOKEN_ADJUST_PRIVILEGES = 0x00000020;

internal const string SE_SHUTDOWN_NAME = "SeShutdownPrivilege";

internal const int EWX_LOGOFF = 0x00000000;//注销

internal const int EWX_SHUTDOWN = 0x00000001;//关机

internal const int EWX_REBOOT = 0x00000002;//重新启动

internal const int EWX_FORCE = 0x00000004;//强制注销

internal const int EWX_POWEROFF = 0x00000008;//强制关机

internal const int EWX_FORCEIFHUNG = 0x00000010;

public static void DoExitWin(int flg)
{
bool ok;

TokPriv1Luid tp;

IntPtr hproc = GetCurrentProcess();

IntPtr htok = IntPtr.Zero;

ok = OpenProcessToken(hproc, TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, ref htok);

tp.Count = 1;

tp.Luid = 0;

tp.Attr = SE_PRIVILEGE_ENABLED;

ok = LookupPrivilegeValue(null, SE_SHUTDOWN_NAME, ref tp.Luid);

ok = AdjustTokenPrivileges(htok, false, ref tp, 0, IntPtr.Zero, IntPtr.Zero);

ok = ExitWindowsEx(flg, 0);
}

#endregion

#region 执行选定操作
/// <summary>
/// 执行选定操作
/// </summary>
public static void CheckCloseComputer(string action)
{
switch (action)
{
case "安全关机":
DoExitWin(EWX_SHUTDOWN);
break;
case "强制关机":
DoExitWin(EWX_POWEROFF);
break;
case "重新启动":
DoExitWin(EWX_REBOOT);
break;
case "注销登陆":
DoExitWin(EWX_LOGOFF);
break;
case "强制注销":
DoExitWin(EWX_FORCE);
break;
}
}
#endregion

#region 定时关机计算剩余时间部分
/// <summary>
/// 定时关机计算剩余时间部分
/// </summary>
/// <param name="lbl"></param>
/// <param name="EndTime"></param>
/// <param name="relbl"></param>
public static void CalcLastTime(Label lbl,string EndTime,Label relbl,ComboBox cbo)
{
while (true)
{
DateTime Now = DateTime.Parse(lbl.Text);
string EndYear = Now.Year.ToString();
string EndMonth = Now.Month.ToString();
DateTime End = DateTime.Parse(EndYear + "年" + EndMonth + "月" + EndTime);
TimeSpan Last = End.Subtract(Now);
relbl.Text = Last.Days + "天 " + Last.Hours + "小时" + Last.Minutes + "分" + Last.Seconds + "秒";
if (relbl.Text == "0天 0小时0分0秒")
{
CheckCloseComputer(cbo.Text);
}
Thread.Sleep(1000);
if (!NowThreadState.CloseTime)
{
Thread.CurrentThread.Abort();
}
}
}
#endregion

#region 倒计时关机计算剩余时间部分
/// <summary>
/// 倒计时关机计算剩余时间部分
/// </summary>
/// <param name="lbl"></param>
/// <param name="EndTime"></param>
/// <param name="relbl"></param>
public static void CalcUseLastTime(Label lbl, string EndTime, Label relbl, ComboBox cbo)
{
while (true)
{
DateTime Now = DateTime.Parse(lbl.Text);
string EndYear = Now.Year.ToString();
string EndMonth = Now.Month.ToString();
DateTime End = DateTime.Parse(EndYear + "年" + EndMonth + "月" + EndTime);
TimeSpan Last = End.Subtract(Now);
relbl.Text = Last.Days + "天 " + Last.Hours + "小时" + Last.Minutes + "分" + Last.Seconds + "秒";
if (relbl.Text == "0天 0小时0分0秒")
{
CheckCloseComputer(cbo.Text);
}
Thread.Sleep(1000);
if (!NowThreadState.UseTime)
{
Thread.CurrentThread.Abort();
}
}
}
#endregion

#region 判断CPU使用率关机
/// <summary>
/// 判断CPU使用率关机
/// </summary>
/// <param name="Rate"></param>
public static void CPURateClose(Label Rate,string cbo,string cbos,int Second)
{
int TimeCount = 0;
while (true)
{
string Rates = Rate.Text.Substring(0, Rate.Text.LastIndexOf("%"));
if (double.Parse(Rates) < double.Parse(cbo))
{
if (Second == TimeCount)
{
CheckCloseComputer(cbos);
}
TimeCount++;
}
TimeCount = 0;
Thread.Sleep(1000);
if (!NowThreadState.CPURate)
{
Thread.CurrentThread.Abort();
}
}
}
#endregion

#region 判断网络关机
/// <summary>
/// 判断网络关机
/// </summary>
/// <param name="lv"></param>
/// <param name="cbo"></param>
/// <param name="cbos"></param>
public static void NetSpeedClose(ListView lv, string cbo, string cbos, int Second)
{
int TimeCount = 0;
while (true)
{
string Rate = lv.Items[0].SubItems[3].Text;
string RateInfo = Rate.Substring(0,Rate.IndexOf(" "));
if (double.Parse(RateInfo) < double.Parse(cbo))
{
if (Second == TimeCount)
{
CheckCloseComputer(cbos);
}
TimeCount++;
}
TimeCount = 0;
Thread.Sleep(1000);
if (!NowThreadState.NetSpeed)
{
Thread.CurrentThread.Abort();
}
}
}
#endregion

#region 判断内存使用率关机
/// <summary>
/// 判断内存使用率关机
/// </summary>
/// <param name="lbl">动态内存使用率</param>
/// <param name="cbo">填写的使用率</param>
/// <param name="cbos">处理状态</param>
/// <param name="cbos">等待时间</param>
public static void MemoryRateClose(Label lbl,string cbo,string cbos,int Second)
{
int TimeCount = 0;
while (true)
{
string Rates = lbl.Text.Substring(0, lbl.Text.LastIndexOf("%"));
if (double.Parse(Rates) < double.Parse(cbo))
{
if (Second == TimeCount)
{
CheckCloseComputer(cbos);
}
TimeCount++;
}
TimeCount = 0;
Thread.Sleep(1000);
if (!NowThreadState.MemoryRate)
{
Thread.CurrentThread.Abort();
}
}
}
#endregion
}
}
...