Come spegnere il computer da C #

Qual è il modo migliore per spegnere il computer da un programma C #?

Ho trovato alcuni metodi che funzionano – li posterò qui sotto – ma nessuno di loro è molto elegante. Sto cercando qualcosa che sia più semplice e nativo.

Funziona a partire da Windows XP, non disponibile in win 2000 o inferiore:

Questo è il modo più veloce per farlo:

Process.Start("shutdown","/s /t 0"); 

Altrimenti usa P / Invoke o WMI come altri hanno detto.

Modifica: come evitare di creare una finestra

 var psi = new ProcessStartInfo("shutdown","/s /t 0"); psi.CreateNoWindow = true; psi.UseShellExecute = false; Process.Start(psi); 

Tratto da: un post Geekpedia

Questo metodo utilizza WMI per arrestare Windows.

Dovrai aggiungere un riferimento a System.Management al tuo progetto per usarlo.

 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); } } 

Questo thread fornisce il codice necessario: http://bytes.com/forum/thread251367.html

ma ecco il codice rilevante:

 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 ); } 

Uso:

 DoExitWin( EWX_SHUTDOWN ); 

o

 DoExitWin( EWX_REBOOT ); 

Diversi metodi:

A. System.Diagnostics.Process.Start("Shutdown", "-s -t 10");

B. Strumentazione gestione Windows (WMI)

C. System.Runtime.InteropServices Pinvoke

D. Gestione del sistema

Dopo averlo presentato, ho visto così tanti altri hanno postato …

Il brutto metodo della vecchia scuola. Utilizzare la funzione ExitWindowsEx dall’API Win32.

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

Nel codice di produzione dovresti controllare i valori di ritorno delle chiamate API, ma l’ho lasciato fuori per rendere più chiaro l’esempio.

Breve e dolce. Chiama un programma esterno:

  using System.Diagnostics; void Shutdown() { Process.Start("shutdown.exe", "-s -t 00"); } 

Nota: questo chiama il programma Shutdown.exe di Windows, quindi funzionerà solo se tale programma è disponibile. Potresti avere problemi con Windows 2000 (dove shutdown.exe è disponibile solo nel kit delle risorse) o XP Embedded .

 System.Diagnostics.Process.Start("shutdown", "/s /t 0") 

Dovrebbe funzionare.

Per il riavvio, è / r

Questo riavvierà il PC box direttamente e in modo pulito, senza windows di dialogo.

Puoi avviare il processo di spegnimento:

  • shutdown -s -t 0 – Shutdown
  • shutdown -r -t 0 – Riavvia

Ho avuto problemi a provare ad utilizzare il metodo WMI accettato sopra perché ho sempre avuto privilegi non mantenuti eccezioni nonostante l’esecuzione del programma come amministratore.

La soluzione era che il processo richiedesse il privilegio per se stesso. Ho trovato la risposta a http://www.dotnet247.com/247reference/msgs/58/292150.aspx scritta da un ragazzo di nome Richard Hill.

Ho incollato il mio uso di base della sua soluzione di seguito nel caso in cui quel collegamento invecchi.

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

Si noti che shutdown.exe è solo un wrapper di InitiateSystemShutdownEx , che fornisce alcune sottigliezze mancanti in ExitWindowsEx

Non esiste un metodo nativo .net per spegnere il computer. È necessario P / Richiamare la chiamata API ExitWindows o ExitWindowsEx.

Ho provato il metodo WMI di roomaroo per arrestare Windows 2003 Server, ma non funzionava fino a quando non ho aggiunto il modello di thread “[STAThread]” (cioè ” Single Threaded Apartment “) alla dichiarazione Main ():

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

Ho quindi provato a chiudere da una discussione, e per farlo funzionare ho dovuto impostare anche lo “Stato appartamento” della discussione su 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 } } 

Sono un noob C #, quindi non sono del tutto sicuro del significato dei thread STA in termini di arresto del sistema (anche dopo aver letto il link che ho postato sopra). Forse qualcun altro può elaborare …?

** Risposta elaborata …

 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); } } } } 

Se si desidera arrestare il computer in remoto, è ansible utilizzare

 Using System.Diagnostics; 

su qualsiasi pulsante clic

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

Utilizzare shutdown.exe. Per evitare problemi con il passaggio degli argomenti, l’esecuzione complessa, l’esecuzione da WindowForms utilizza lo script di esecuzione di PowerShell:

 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 PSOutput = PowerShellInstance.Invoke(); } 

System.Management.Automation.dll deve essere installato sul sistema operativo e disponibile in GAC.

Mi scusi per il mio inglese.

Solo per aggiungere alla risposta di Pop Catalin, ecco una fodera che spegne il computer senza visualizzare alcuna finestra:

 Process.Start(new ProcessStartInfo("shutdown", "/s /t 0"){CreateNoWindow = true, UseShellExecute = false}); 

Se aggiungi il riferimento System.Windows.Forms al tuo progetto, puoi trovare in questo spazio dei nomi la class Application che ha metodi statici. Uno di questi è ciò che vuoi / hai bisogno / che cerchi, ed è chiamato “SetSuspendState”. Ho usato questa funzione in passato, e con essa riesco a spegnere facilmente il mio computer. Ci sono opzioni su come vuoi spegnere il computer con questa funzione. Ci vogliono 3 parametri. Prima l’enum PowerState (Hibernate o Suspend), secondo la forza bool, e il terzo il bool disableWakeEvent. Puoi leggere di più su questa funzione in Internet. La seguente linea di esecuzione spegne il computer come previsto (lo spero):

 System.Windows.Forms.Application.SetSuspendState(PowerState.Hibernate, true, false); 
 #include #include int main() { system("C:\\Windows\\System32\\shutdown /s/t 0"); return 0; }