Fatal编程技术网
  • csharp/
  • C# 如何从C关闭计算机#

C# 如何从C关闭计算机#

c# .net windows

C# 如何从C关闭计算机#,c#,.net,windows,shutdown,C#,.net,Windows,Shutdown,从C程序关闭计算机的最佳方式是什么 我发现了一些有效的方法——我将在下面发布——但没有一种是非常优雅的。我正在寻找一种更简单、本机支持的.net。您可以启动关闭过程： 关机-s-t 0关机 关机-r-t0重新启动 摘自： 此方法用于关闭windows 您需要将对System.Management的引用添加到您的项目中才能使用它 using System.Management; void Shutdown() { ManagementBaseObject mboShutdown = n

从C程序关闭计算机的最佳方式是什么

我发现了一些有效的方法——我将在下面发布——但没有一种是非常优雅的。我正在寻找一种更简单、本机支持的.net。

您可以启动关闭过程：

  • 关机-s-t 0
    关机
  • 关机-r-t0
    重新启动
摘自：

此方法用于关闭windows

您需要将对System.Management的引用添加到您的项目中才能使用它

using System.Management;

void Shutdown()
{
    ManagementBaseObject mboShutdown = null;
    ManagementClass mcWin32 = new ManagementClass("Win32_OperatingSystem");
    mcWin32.Get();

    // You can't shutdown without security privileges
    mcWin32.Scope.Options.EnablePrivileges = true;
    ManagementBaseObject mboShutdownParams =
             mcWin32.GetMethodParameters("Win32Shutdown");

     // Flag 1 means we want to shut down the system. Use "2" to reboot.
    mboShutdownParams["Flags"] = "1";
    mboShutdownParams["Reserved"] = "0";
    foreach (ManagementObject manObj in mcWin32.GetInstances())
    {
        mboShutdown = manObj.InvokeMethod("Win32Shutdown", 
                                       mboShutdownParams, null);
    }
}
又短又甜。调用外部程序：

    using System.Diagnostics;

    void Shutdown()
    {
        Process.Start("shutdown.exe", "-s -t 00");
    }
注意：这将调用Windows的Shutdown.exe程序，因此只有该程序可用时，它才会工作。
您可能在Windows 2000（其中shutdown.exe仅在资源工具包中可用）或。

此线程提供了必要的代码：

但以下是相关代码：

using System.Runtime.InteropServices;

[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;

private 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 );
    }
用法：

DoExitWin( EWX_SHUTDOWN );
或

没有用于关闭计算机的.net本机方法。您需要P/调用ExitWindows或exitwindowsecx API调用。

旧的方法。使用Win32 API中的

ExitWindowsEx
函数

using System.Runtime.InteropServices;

void Shutdown2()
{
    const string SE_SHUTDOWN_NAME = "SeShutdownPrivilege";
    const short SE_PRIVILEGE_ENABLED = 2;
    const uint EWX_SHUTDOWN = 1;
    const short TOKEN_ADJUST_PRIVILEGES = 32;
    const short TOKEN_QUERY = 8;
    IntPtr hToken;
    TOKEN_PRIVILEGES tkp;

    // Get shutdown privileges...
    OpenProcessToken(Process.GetCurrentProcess().Handle, 
          TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, out hToken);
    tkp.PrivilegeCount = 1;
    tkp.Privileges.Attributes = SE_PRIVILEGE_ENABLED;
    LookupPrivilegeValue("", SE_SHUTDOWN_NAME, out tkp.Privileges.pLuid);
    AdjustTokenPrivileges(hToken, false, ref tkp, 0U, IntPtr.Zero, 
          IntPtr.Zero);

    // Now we have the privileges, shutdown Windows
    ExitWindowsEx(EWX_SHUTDOWN, 0);
}

// Structures needed for the API calls
private struct LUID
{
    public int LowPart;
    public int HighPart;
}
private struct LUID_AND_ATTRIBUTES
{
    public LUID pLuid;
    public int Attributes;
}
private struct TOKEN_PRIVILEGES
{
    public int PrivilegeCount;
    public LUID_AND_ATTRIBUTES Privileges;
}

[DllImport("advapi32.dll")]
static extern int OpenProcessToken(IntPtr ProcessHandle, 
                     int DesiredAccess, out IntPtr TokenHandle);

[DllImport("advapi32.dll", SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
static extern bool AdjustTokenPrivileges(IntPtr TokenHandle,
    [MarshalAs(UnmanagedType.Bool)]bool DisableAllPrivileges,
    ref TOKEN_PRIVILEGES NewState,
    UInt32 BufferLength,
    IntPtr PreviousState,
    IntPtr ReturnLength);

[DllImport("advapi32.dll")]
static extern int LookupPrivilegeValue(string lpSystemName, 
                       string lpName, out LUID lpLuid);

[DllImport("user32.dll", SetLastError = true)]
static extern int ExitWindowsEx(uint uFlags, uint dwReason);
在生产代码中，您应该检查API调用的返回值，但为了使示例更清楚，我省略了它。

从windows XP开始工作，在win 2000或更低版本中不可用：

这是最快的方法：

Process.Start("shutdown","/s /t 0");
否则，像其他人所说的那样使用p/Invoke或WMI

编辑：如何避免创建窗口

var psi = new ProcessStartInfo("shutdown","/s /t 0");
psi.CreateNoWindow = true;
psi.UseShellExecute = false;
Process.Start(psi);
不同的方法：

A.
System.Diagnostics.Process.Start（“Shutdown”，“-s-t10”）

B.Windows管理工具（WMI）


    

  • 

  • 


C.System.Runtime.InteropServices Pinvoke


    

  • 


D.系统管理


    

  • 



在我提交后，我看到很多其他人也发布了
 如果您想远程关闭计算机，则可以使用


Using System.Diagnostics;


在任何按钮上单击


{
    Process.Start("Shutdown","-i");
}


我试图关闭Windows 2003 Server，但在将“[StatThread]”（即“线程模型”）添加到Main（）声明之前，它无法工作：


[STAThread]
public static void Main(string[] args) {
    Shutdown();
}


然后我尝试从一个线程关闭，为了让它正常工作，我还必须将线程的“单元状态”设置为STA：


using System.Management;
using System.Threading;

public static class Program {

    [STAThread]
    public static void Main(string[] args) {
        Thread t = new Thread(new ThreadStart(Program.Shutdown));
        t.SetApartmentState(ApartmentState.STA);
        t.Start();
        ...
    }

    public static void Shutdown() {
        // roomaroo's code
    }
}



我是一个C#noob，所以我不完全确定STA线程在关闭系统方面的意义（即使在阅读了我上面发布的链接之后）。也许其他人可以详细说明…？
请注意，
shutdown.exe
只是一个包装，它提供了
ExitWindowsEx
中缺少的一些细节


using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
// Remember to add a reference to the System.Management assembly
using System.Management;
using System.Diagnostics;

namespace ShutDown
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void btnShutDown_Click(object sender, EventArgs e)
        {
            ManagementBaseObject mboShutdown = null;
            ManagementClass mcWin32 = new ManagementClass("Win32_OperatingSystem");
            mcWin32.Get();

            // You can't shutdown without security privileges
            mcWin32.Scope.Options.EnablePrivileges = true;
            ManagementBaseObject mboShutdownParams = mcWin32.GetMethodParameters("Win32Shutdown");

            // Flag 1 means we want to shut down the system
            mboShutdownParams["Flags"] = "1";
            mboShutdownParams["Reserved"] = "0";

            foreach (ManagementObject manObj in mcWin32.GetInstances())
            {
                mboShutdown = manObj.InvokeMethod("Win32Shutdown", mboShutdownParams, null);
            }
        }
    }
}



我在尝试使用上面接受的WMI方法时遇到困难，因为尽管以管理员身份运行该程序，但我始终获得权限未保留异常

解决方案是让进程为自己请求特权。我找到了一个叫理查德·希尔的人写的答案

我已经在下面粘贴了他的解决方案的基本用法，以防链接变旧


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Management;
using System.Runtime.InteropServices;
using System.Security;
using System.Diagnostics;

namespace PowerControl
{
    public class PowerControl_Main
    {


        public void Shutdown()
        {
            ManagementBaseObject mboShutdown = null;
            ManagementClass mcWin32 = new ManagementClass("Win32_OperatingSystem");
            mcWin32.Get();

            if (!TokenAdjuster.EnablePrivilege("SeShutdownPrivilege", true))
            {
                Console.WriteLine("Could not enable SeShutdownPrivilege");
            }
            else
            {
                Console.WriteLine("Enabled SeShutdownPrivilege");
            }

            // You can't shutdown without security privileges
            mcWin32.Scope.Options.EnablePrivileges = true;
            ManagementBaseObject mboShutdownParams = mcWin32.GetMethodParameters("Win32Shutdown");

            // Flag 1 means we want to shut down the system
            mboShutdownParams["Flags"] = "1";
            mboShutdownParams["Reserved"] = "0";

            foreach (ManagementObject manObj in mcWin32.GetInstances())
            {
                try
                {
                    mboShutdown = manObj.InvokeMethod("Win32Shutdown",
                                                   mboShutdownParams, null);
                }
                catch (ManagementException mex)
                {
                    Console.WriteLine(mex.ToString());
                    Console.ReadKey();
                }
            }
        }


    }


    public sealed class TokenAdjuster
    {
        // PInvoke stuff required to set/enable security privileges
        [DllImport("advapi32", SetLastError = true),
        SuppressUnmanagedCodeSecurityAttribute]
        static extern int OpenProcessToken(
        System.IntPtr ProcessHandle, // handle to process
        int DesiredAccess, // desired access to process
        ref IntPtr TokenHandle // handle to open access token
        );

        [DllImport("kernel32", SetLastError = true),
        SuppressUnmanagedCodeSecurityAttribute]
        static extern bool CloseHandle(IntPtr handle);

        [DllImport("advapi32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        static extern int AdjustTokenPrivileges(
        IntPtr TokenHandle,
        int DisableAllPrivileges,
        IntPtr NewState,
        int BufferLength,
        IntPtr PreviousState,
        ref int ReturnLength);

        [DllImport("advapi32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        static extern bool LookupPrivilegeValue(
        string lpSystemName,
        string lpName,
        ref LUID lpLuid);

        [StructLayout(LayoutKind.Sequential)]
        internal struct LUID
        {
            internal int LowPart;
            internal int HighPart;
        }

        [StructLayout(LayoutKind.Sequential)]
        struct LUID_AND_ATTRIBUTES
        {
            LUID Luid;
            int Attributes;
        }

        [StructLayout(LayoutKind.Sequential)]
        struct _PRIVILEGE_SET
        {
            int PrivilegeCount;
            int Control;
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)] // ANYSIZE_ARRAY = 1
            LUID_AND_ATTRIBUTES[] Privileges;
        }

        [StructLayout(LayoutKind.Sequential)]
        internal struct TOKEN_PRIVILEGES
        {
            internal int PrivilegeCount;
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
            internal int[] Privileges;
        }
        const int SE_PRIVILEGE_ENABLED = 0x00000002;
        const int TOKEN_ADJUST_PRIVILEGES = 0X00000020;
        const int TOKEN_QUERY = 0X00000008;
        const int TOKEN_ALL_ACCESS = 0X001f01ff;
        const int PROCESS_QUERY_INFORMATION = 0X00000400;

        public static bool EnablePrivilege(string lpszPrivilege, bool
        bEnablePrivilege)
        {
            bool retval = false;
            int ltkpOld = 0;
            IntPtr hToken = IntPtr.Zero;
            TOKEN_PRIVILEGES tkp = new TOKEN_PRIVILEGES();
            tkp.Privileges = new int[3];
            TOKEN_PRIVILEGES tkpOld = new TOKEN_PRIVILEGES();
            tkpOld.Privileges = new int[3];
            LUID tLUID = new LUID();
            tkp.PrivilegeCount = 1;
            if (bEnablePrivilege)
                tkp.Privileges[2] = SE_PRIVILEGE_ENABLED;
            else
                tkp.Privileges[2] = 0;
            if (LookupPrivilegeValue(null, lpszPrivilege, ref tLUID))
            {
                Process proc = Process.GetCurrentProcess();
                if (proc.Handle != IntPtr.Zero)
                {
                    if (OpenProcessToken(proc.Handle, TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
                    ref hToken) != 0)
                    {
                        tkp.PrivilegeCount = 1;
                        tkp.Privileges[2] = SE_PRIVILEGE_ENABLED;
                        tkp.Privileges[1] = tLUID.HighPart;
                        tkp.Privileges[0] = tLUID.LowPart;
                        const int bufLength = 256;
                        IntPtr tu = Marshal.AllocHGlobal(bufLength);
                        Marshal.StructureToPtr(tkp, tu, true);
                        if (AdjustTokenPrivileges(hToken, 0, tu, bufLength, IntPtr.Zero, ref ltkpOld) != 0)
                        {
                            // successful AdjustTokenPrivileges doesn't mean privilege could be changed
                            if (Marshal.GetLastWin32Error() == 0)
                            {
                                retval = true; // Token changed
                            }
                        }
                        TOKEN_PRIVILEGES tokp = (TOKEN_PRIVILEGES)Marshal.PtrToStructure(tu,
                        typeof(TOKEN_PRIVILEGES));
                        Marshal.FreeHGlobal(tu);
                    }
                }
            }
            if (hToken != IntPtr.Zero)
            {
                CloseHandle(hToken);
            }
            return retval;
        }

    }
}


应该有用

对于重新启动，它是/r


这将直接、干净地重新启动PC机，没有对话框。
使用shutdown.exe。要避免传递参数、复杂执行时出现问题，请使用PowerShell执行脚本从WindowForms执行：


using System.Management.Automation;
...
using (PowerShell PowerShellInstance = PowerShell.Create())
{
    PowerShellInstance.AddScript("shutdown -a; shutdown -r -t 100;");
    // invoke execution on the pipeline (collecting output)
    Collection<PSObject> PSOutput = PowerShellInstance.Invoke();
} 



使用System.Management.Automation；
...
使用（PowerShell PowerShellInstance=PowerShell.Create（））
{
AddScript（“shutdown-a；shutdown-r-t100；”；
//在管道上调用执行（收集输出）
集合PSOutput=PowerShellInstance.Invoke（）；
} 


System.Management.Automation.dll应安装在操作系统上，并在GAC中可用


对不起，我说的是英语。
为了补充Pop Catalin的回答，这里有一个单行线，它关闭计算机而不显示任何窗口：


Process.Start（新的ProcessStartInfo（“关机”），“/s/t0”）{
CreateNoWindow=true，UseShellExecute=false
});

对于Windows 10，我需要添加/f选项，以便在没有任何问题和等待时间的情况下关闭电脑


//This did not work for me
Process.Start("shutdown", "/s /t 0");

//But this worked
Process.Start("shutdown", "/s /f /t 0");



使用WMI可以更容易地跟踪错误。如果shutdown命令因某种原因无法运行，会发生什么情况？我正在使用此方法关闭windows，三分之二的时候它会告诉我我没有权限，但第三次，它不会“放弃”并重新启动计算机。怎么回事？这个解决方案不适合我。即使我在管理员用户下运行程序，也会出现“特权未保留”异常。@roomaroo此方法不起作用。它抛出异常：管理异常，未持有特权。如果要强制关闭，应使用mboShutdownParams[“Flags”]=“5”；值5表示强制关机。B和D是相同的方法（WMI）E。Powershell从代码执行脚本这似乎也在服务中工作（至少在我关注的场景中）。我从未能够使WMI或ExitWindowsEx方法在服务中工作。@James这是因为服务通常没有权限。使用此方法后，机器的功耗状态与使用传统的关机对话框窗口后不同。按下电源按钮以重新启动会消耗大约80-85毫安，而不是标准的300+毫安。如果我找到原因，我会发回来的。这应该不会影响大多数用户。这非常有效，但如果您在WPF中，这会在一瞬间生成一个控制台窗口，看起来不太专业。这很有效，尽管我不喜欢不知道为什么。我真的想知道我是否应该使用“shutdown”命令…实际上，只有调用WMI的线程需要是STA线程。如果这不是主线程，
main（）
不需要
[STAThread]
。您可以在这里了解其他EWX常量的功能：将数值常量移植到C时，最佳做法是使用枚举。这就是枚举的设计目的。它能很好地打字

using System.Management.Automation;
...
using (PowerShell PowerShellInstance = PowerShell.Create())
{
    PowerShellInstance.AddScript("shutdown -a; shutdown -r -t 100;");
    // invoke execution on the pipeline (collecting output)
    Collection<PSObject> PSOutput = PowerShellInstance.Invoke();
} 



//This did not work for me
Process.Start("shutdown", "/s /t 0");

//But this worked
Process.Start("shutdown", "/s /f /t 0");