NativeProcessPolicy.cs

using System.ComponentModel;
using System.Runtime.InteropServices;

namespace CodexProcessKeeper;

internal sealed record NativePolicyResult(
    bool Success,
    string PriorityLabel,
    bool EfficiencyModeOff,
    int ErrorCode,
    string Message);

internal static class NativeProcessPolicy
{
    private const uint ProcessSetInformation = 0x0200;
    private const uint ProcessQueryLimitedInformation = 0x1000;
    private const uint HighPriorityClass = 0x00000080;
    private const uint AboveNormalPriorityClass = 0x00008000;
    private const uint NormalPriorityClass = 0x00000020;
    private const uint BelowNormalPriorityClass = 0x00004000;
    private const uint IdlePriorityClass = 0x00000040;
    private const uint RealtimePriorityClass = 0x00000100;
    private const int ProcessPowerThrottling = 4;
    private const uint PowerThrottlingVersion = 1;
    private const uint PowerThrottlingExecutionSpeed = 0x1;
    private const uint PowerThrottlingIgnoreTimerResolution = 0x4;

    [StructLayout(LayoutKind.Sequential)]
    private struct PowerThrottlingState
    {
        internal uint Version;
        internal uint ControlMask;
        internal uint StateMask;
    }

    [DllImport("kernel32.dll", SetLastError = true)]
    private static extern nint OpenProcess(uint desiredAccess, bool inheritHandle, int processId);

    [DllImport("kernel32.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static extern bool CloseHandle(nint handle);

    [DllImport("kernel32.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static extern bool SetPriorityClass(nint processHandle, uint priorityClass);

    [DllImport("kernel32.dll", SetLastError = true)]
    private static extern uint GetPriorityClass(nint processHandle);

    [DllImport("kernel32.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static extern bool SetProcessInformation(
        nint processHandle,
        int informationClass,
        ref PowerThrottlingState processInformation,
        uint processInformationSize);

    [DllImport("kernel32.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static extern bool GetProcessInformation(
        nint processHandle,
        int informationClass,
        ref PowerThrottlingState processInformation,
        uint processInformationSize);

    internal static NativePolicyResult Apply(int processId)
    {
        nint processHandle = OpenProcess(
            ProcessSetInformation | ProcessQueryLimitedInformation,
            false,
            processId);

        if (processHandle == nint.Zero)
        {
            int errorCode = Marshal.GetLastWin32Error();
            return Failure(errorCode, "无法打开进程");
        }

        try
        {
            if (!SetPriorityClass(processHandle, HighPriorityClass))
            {
                int errorCode = Marshal.GetLastWin32Error();
                return Failure(errorCode, "无法设置高优先级");
            }

            PowerThrottlingState disabledState = new()
            {
                Version = PowerThrottlingVersion,
                ControlMask = PowerThrottlingExecutionSpeed | PowerThrottlingIgnoreTimerResolution,
                StateMask = 0
            };

            uint stateSize = (uint)Marshal.SizeOf<PowerThrottlingState>();
            if (!SetProcessInformation(
                    processHandle,
                    ProcessPowerThrottling,
                    ref disabledState,
                    stateSize))
            {
                int errorCode = Marshal.GetLastWin32Error();
                return Failure(errorCode, "无法关闭效率模式");
            }

            uint priorityClass = GetPriorityClass(processHandle);
            if (priorityClass == 0)
            {
                int errorCode = Marshal.GetLastWin32Error();
                return Failure(errorCode, "无法核验进程优先级");
            }

            PowerThrottlingState verifiedState = new() { Version = PowerThrottlingVersion };
            if (!GetProcessInformation(
                    processHandle,
                    ProcessPowerThrottling,
                    ref verifiedState,
                    stateSize))
            {
                int errorCode = Marshal.GetLastWin32Error();
                return Failure(errorCode, "无法核验效率模式");
            }

            bool priorityIsHigh = priorityClass == HighPriorityClass;
            bool efficiencyModeOff =
                (verifiedState.StateMask & PowerThrottlingExecutionSpeed) == 0;
            bool success = priorityIsHigh && efficiencyModeOff;

            return new NativePolicyResult(
                success,
                GetPriorityLabel(priorityClass),
                efficiencyModeOff,
                0,
                success ? "正常" : "策略核验未通过");
        }
        finally
        {
            CloseHandle(processHandle);
        }
    }

    private static NativePolicyResult Failure(int errorCode, string action)
    {
        string errorMessage = errorCode == 5
            ? "权限不足，请以管理员身份运行守护器"
            : new Win32Exception(errorCode).Message;

        return new NativePolicyResult(
            false,
            "未知",
            false,
            errorCode,
            $"{action}：{errorMessage}");
    }

    private static string GetPriorityLabel(uint priorityClass)
    {
        return priorityClass switch
        {
            RealtimePriorityClass => "实时",
            HighPriorityClass => "高",
            AboveNormalPriorityClass => "高于正常",
            NormalPriorityClass => "正常",
            BelowNormalPriorityClass => "低于正常",
            IdlePriorityClass => "低",
            _ => $"0x{priorityClass:X}"
        };
    }
}