C#中阻止硬件休眠的多種實現(xiàn)方法

更新時間：2025年07月16日 11:17:00 作者：傻童:CPU

本文介紹了在C#中阻止系統(tǒng)休眠的多種方法,核心方案是通過調(diào)用Windows API的SetThreadExecutionState函數(shù),可控制顯示器關(guān)閉和系統(tǒng)休眠行為,感興趣的可以了解一下

C#中如何阻止硬件休眠

在 C# 中阻止系統(tǒng)進入休眠狀態(tài)（包括顯示關(guān)閉和系統(tǒng)休眠）需要使用 Windows API。以下是完整的實現(xiàn)方案，包含多種控制級別和實際應(yīng)用場景：

核心解決方案：使用 SetThreadExecutionState API

using System;
using System.Runtime.InteropServices;
using System.Windows.Forms;

public class SleepPreventer : IDisposable
{
    // 導(dǎo)入 Windows API
    [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
    private static extern uint SetThreadExecutionState(uint esFlags);

    // 執(zhí)行狀態(tài)標(biāo)志
    private const uint ES_CONTINUOUS = 0x80000000;
    private const uint ES_SYSTEM_REQUIRED = 0x00000001;
    private const uint ES_DISPLAY_REQUIRED = 0x00000002;
    private const uint ES_AWAYMODE_REQUIRED = 0x00000040;

    private uint _previousState;
    private bool _isDisposed;

    /// <summary>
    /// 初始化并阻止系統(tǒng)休眠
    /// </summary>
    /// <param name="preventDisplaySleep">是否阻止顯示器關(guān)閉</param>
    /// <param name="preventSystemSleep">是否阻止系統(tǒng)休眠</param>
    public SleepPreventer(bool preventDisplaySleep = true, bool preventSystemSleep = true)
    {
        uint newState = ES_CONTINUOUS;

        if (preventSystemSleep)
        {
            newState |= ES_SYSTEM_REQUIRED | ES_AWAYMODE_REQUIRED;
        }
        
        if (preventDisplaySleep)
        {
            newState |= ES_DISPLAY_REQUIRED;
        }

        // 設(shè)置新狀態(tài)并保存之前的狀態(tài)
        _previousState = SetThreadExecutionState(newState);
        
        if (_previousState == 0)
        {
            throw new Exception("設(shè)置執(zhí)行狀態(tài)失敗: " + Marshal.GetLastWin32Error());
        }
    }

    /// <summary>
    /// 恢復(fù)原始狀態(tài)（允許系統(tǒng)休眠）
    /// </summary>
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (!_isDisposed)
        {
            // 恢復(fù)之前的執(zhí)行狀態(tài)
            if (_previousState != 0)
            {
                SetThreadExecutionState(_previousState);
            }
            
            _isDisposed = true;
        }
    }

    ~SleepPreventer()
    {
        Dispose(false);
    }

    /// <summary>
    /// 臨時重置休眠計時器（推薦用于長時間操作）
    /// </summary>
    public static void ResetSleepTimer(bool resetDisplay = true)
    {
        uint flags = ES_SYSTEM_REQUIRED;
        if (resetDisplay) flags |= ES_DISPLAY_REQUIRED;
        
        SetThreadExecutionState(flags);
    }
}

使用示例

場景 1：長時間操作期間阻止休眠（如文件傳輸）

// 開始長時間操作
using (var sleepLock = new SleepPreventer())
{
    // 執(zhí)行耗時操作（如大文件傳輸）
    TransferLargeFile("source.zip", "destination.zip");
    
    // 在循環(huán)中定期重置計時器
    for (int i = 0; i < 100; i++)
    {
        DoWorkChunk(i);
        SleepPreventer.ResetSleepTimer(); // 每部分完成時重置計時器
    }
} // 離開 using 范圍后自動允許休眠

場景 2：媒體播放期間保持喚醒

public class MediaPlayer : IDisposable
{
    private SleepPreventer _sleepPreventer;
    
    public void Play()
    {
        // 播放開始時阻止休眠
        _sleepPreventer = new SleepPreventer(preventDisplaySleep: true);
        
        // 開始播放...
    }
    
    public void Pause()
    {
        // 暫停時允許休眠
        _sleepPreventer?.Dispose();
        _sleepPreventer = null;
    }
    
    public void Dispose()
    {
        _sleepPreventer?.Dispose();
    }
}

場景 3：后臺服務(wù)保持系統(tǒng)喚醒

public class BackgroundService
{
    private SleepPreventer _sleepPreventer;
    
    public void StartMonitoring()
    {
        // 阻止系統(tǒng)休眠但允許顯示器關(guān)閉
        _sleepPreventer = new SleepPreventer(preventDisplaySleep: false, 
                                            preventSystemSleep: true);
        
        // 開始監(jiān)控...
    }
    
    public void Stop()
    {
        _sleepPreventer?.Dispose();
    }
}

高級控制：使用 Windows 電源請求
對于更復(fù)雜的場景（需要系統(tǒng)完全保持喚醒狀態(tài)），可以使用 PowerCreateRequest API：

[DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
private static extern IntPtr PowerCreateRequest(ref POWER_REQUEST_CONTEXT context);

[DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
private static extern bool PowerSetRequest(IntPtr powerRequest, POWER_REQUEST_TYPE requestType);

[DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
private static extern bool PowerClearRequest(IntPtr powerRequest, POWER_REQUEST_TYPE requestType);

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
private struct POWER_REQUEST_CONTEXT
{
    public uint Version;
    public uint Flags;
    [MarshalAs(UnmanagedType.LPWStr)]
    public string SimpleReasonString;
}

private enum POWER_REQUEST_TYPE
{
    PowerRequestDisplayRequired,
    PowerRequestSystemRequired,
    PowerRequestAwayModeRequired
}

public class PowerRequest : IDisposable
{
    private IntPtr _handle;
    private bool _isDisposed;

    public PowerRequest(string reason)
    {
        var context = new POWER_REQUEST_CONTEXT
        {
            Version = 0,
            Flags = 0,
            SimpleReasonString = reason
        };

        _handle = PowerCreateRequest(ref context);
        
        if (_handle == IntPtr.Zero)
            throw new Win32Exception(Marshal.GetLastWin32Error());
        
        if (!PowerSetRequest(_handle, POWER_REQUEST_TYPE.PowerRequestSystemRequired))
            throw new Win32Exception(Marshal.GetLastWin32Error());
    }

    public void Dispose()
    {
        if (!_isDisposed)
        {
            if (_handle != IntPtr.Zero)
            {
                PowerClearRequest(_handle, POWER_REQUEST_TYPE.PowerRequestSystemRequired);
                CloseHandle(_handle);
                _handle = IntPtr.Zero;
            }
            _isDisposed = true;
        }
    }

    [DllImport("kernel32.dll", SetLastError = true)]
    private static extern bool CloseHandle(IntPtr hObject);
}

實際應(yīng)用技巧

最小化影響：

// 僅在必要時阻止休眠
if (operationWillTakeMoreThan(TimeSpan.FromMinutes(10)))
{
    using (var preventer = new SleepPreventer())
    {
        ExecuteLongOperation();
    }
}

用戶配置選項：

// 在設(shè)置中添加選項
if (Settings.PreventSleepDuringOperations)
{
    SleepPreventer.ResetSleepTimer();
}

處理系統(tǒng)電源事件：

Microsoft.Win32.SystemEvents.PowerModeChanged += (s, e) => 
{
    if (e.Mode == PowerModes.Suspend)
    {
        // 系統(tǒng)即將休眠，保存狀態(tài)
        SaveCurrentState();
    }
};

多顯示器場景：

// 檢測是否有外接顯示器
bool hasExternalDisplay = Screen.AllScreens.Length > 1;

// 僅在無外接顯示器時阻止顯示器關(guān)閉
using (var preventer = new SleepPreventer(
    preventDisplaySleep: !hasExternalDisplay))
{
    // 執(zhí)行操作...
}

超時處理

// 設(shè)置最大阻止時間
using (var timeout = new System.Threading.Timer(_ => 
{
    preventer?.Dispose();
}, null, TimeSpan.FromHours(2), Timeout.InfiniteTimeSpan))
{
    using (var preventer = new SleepPreventer())
    {
        // 長時間操作...
    }
}

其他使用

public class SystemSleepAPI
{
    //定義API函數(shù)
    [DllImport("kernel32.dll")]
    static extern uint SetThreadExecutionState(ExecutionFlag flags);

    [Flags]
    enum ExecutionFlag : uint
    {
        System = 0x00000001,
        Display = 0x00000002,
        Continus = 0x80000000,
    }

    /// <summary>
    ///阻止系統(tǒng)休眠，直到線程結(jié)束恢復(fù)休眠策略
    /// </summary>
    /// <param name="includeDisplay">是否阻止關(guān)閉顯示器</param>
    public static void PreventSleep(bool includeDisplay = false)
    {
        try
        {
            if (includeDisplay)
                SetThreadExecutionState(ExecutionFlag.System | ExecutionFlag.Display | ExecutionFlag.Continus);
            else
                SetThreadExecutionState(ExecutionFlag.System | ExecutionFlag.Continus);
        }
        catch { }
    }

    /// <summary>
    ///恢復(fù)系統(tǒng)休眠策略
    /// </summary>
    public static void ResotreSleep()
    {
        try { SetThreadExecutionState(ExecutionFlag.Continus); } catch { }
    }

    /// <summary>
    ///重置系統(tǒng)休眠計時器
    /// </summary>
    /// <param name="includeDisplay">是否阻止關(guān)閉顯示器</param>
    public static void ResetSleepTimer(bool includeDisplay = false)
    {
        try
        {
            if (includeDisplay)
                SetThreadExecutionState(ExecutionFlag.System | ExecutionFlag.Display);
            else
                SetThreadExecutionState(ExecutionFlag.System);
        }
        catch { }
    }
}

使用實例