Como desligar o computador do c #

Qual é a melhor maneira de desligar o computador de um programa c #?

Eu encontrei alguns methods que funcionam – vou publicá-los abaixo – mas nenhum deles é muito elegante. Eu estou procurando por algo que é mais simples e nativa.

Funciona a partir do Windows XP, não disponível no win 2000 ou inferior:

Esta é a maneira mais rápida de fazer isso:

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

Caso contrário, use P / Invoke ou WMI como outros disseram.

Editar: como evitar a criação de uma janela

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

Retirado de: um post de Geekpedia

Esse método usa o WMI para janelas de desligamento.

Você precisará adicionar uma referência ao System.Management ao seu projeto para usar isso.

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

Este tópico fornece o código necessário: http://bytes.com/forum/thread251367.html

mas aqui está o código relevante:

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

ou

 DoExitWin( EWX_REBOOT ); 

Métodos diferentes:

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

B. Instrumentação de Gerenciamento do Windows (WMI)

C. System.Runtime.InteropServices Pinvoke

D. Gerenciamento de Sistemas

Depois de enviar, eu vi muitos outros também postaram …

O método feio da velha escola. Use a function ExitWindowsEx da API do 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); 

No código de produção, você deve verificar os valores de retorno das chamadas da API, mas deixei isso para deixar o exemplo mais claro.

Curto e grosso. Ligue para um programa externo:

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

Nota: Isso chama o programa Shutdown.exe do Windows, por isso só funcionará se esse programa estiver disponível. Você pode ter problemas no Windows 2000 (onde o shutdown.exe está disponível apenas no kit de resources) ou no XP Embedded .

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

Deveria trabalhar.

Para reiniciar, é / r

Isso irá reiniciar a checkbox do PC diretamente e de forma limpa, com NO diálogos.

Você pode iniciar o processo de desligamento:

  • shutdown -s -t 0 – desligamento
  • shutdown -r -t 0 – Reiniciar

Eu tive problemas tentando usar o método WMI aceito acima, porque sempre obtive privilégios que não continham exceções, apesar de executar o programa como um administrador.

A solução foi que o processo solicitasse o privilégio para si mesmo. Eu encontrei a resposta em http://www.dotnet247.com/247reference/msgs/58/292150.aspx escrito por um cara chamado Richard Hill.

Eu colei meu uso básico de sua solução abaixo, caso esse link fique velho.

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

Observe que o shutdown.exe é apenas um wrapper em torno do InitiateSystemShutdownEx , que fornece algumas sutilezas ausentes no ExitWindowsEx

Não existe um método nativo do .net para desligar o computador. Você precisa P / Invocar a chamada da API ExitWindows ou ExitWindowsEx.

Eu tentei o método Woma do roomaroo para desligar o Windows 2003 Server, mas não iria funcionar até que eu adicionei `[STAThread] ‘(ou seja, modelo de threading” Single Threaded Apartment “) à declaração Main ():

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

Eu tentei desligar de um thread, e para fazer isso funcionar eu tive que configurar o “Apartment State” do thread para STA também:

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

Eu sou um noob C #, então eu não estou inteiramente certo da importância dos segmentos STA em termos de desligar o sistema (mesmo depois de ler o link que eu postei acima). Talvez outra pessoa possa elaborar …?

** Resposta Elaborada …

 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 você quiser desligar o computador remotamente, então você pode usar

 Using System.Diagnostics; 

em qualquer clique de botão

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

Use o shutdown.exe. Para evitar problemas com argumentos de passagem, execução complexa, execução de WindowForms use o script de execução do 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 ser instalado no sistema operacional e disponível no GAC.

Desculpe pelo meu Inglês.

Apenas para adicionar à resposta do Pop Catalin, aqui está um forro que desliga o computador sem exibir nenhuma janela:

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

Se você adicionar a referência System.Windows.Forms ao seu projeto, poderá encontrar nesse namespace a class Application que possui methods estáticos. Um deles é o que você quer / precisa / procura, e é chamado de “SetSuspendState”. Eu usei essa function no passado, e com ela consegui desligar meu computador facilmente. Há opções de como você deseja desligar seu computador com esta function. Leva 3 parâmetros. Primeiro, o enum PowerState (Hibernate ou Suspend), segundo a força do bool, e terceiro o bool disableWakeEvent. Você pode ler mais sobre essa function na Internet. A linha de execução a seguir desligará seu computador como você esperava (espero que sim):

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