C#控制台程序keyeventf_keyup未释放按键问题求助

Hey there! Let's figure out why your C# console app works fine in text-based apps like Notepad or browsers but acts up in games—specifically that stuck spacebar issue where you have to press it manually to reset things.

The core problem is that games handle input differently from regular desktop apps:

• Apps like Notepad use the standard Windows message loop (WM_KEYDOWN/WM_KEYUP), so simple methods like SendKeys or SendMessage work just fine.
• Most modern games rely on DirectInput or raw input APIs, which bypass the normal message system. They also often run with higher privilege levels, meaning basic input simulations don't get picked up correctly.
• The stuck spacebar happens because your app's simulated keyup event never registers with the game—it thinks the spacebar is still held down until you physically press it to reset the state.

SendInput is a low-level Windows API that injects input events directly into the system's input stream. It's far more reliable for games than higher-level methods like SendKeys. Here's how to implement it:

First, create a helper class to handle input simulation:

using System;
using System.Runtime.InteropServices;
using System.Threading;

public class GameInputSimulator
{
    // Import SendInput and required structures
    [DllImport("user32.dll", SetLastError = true)]
    private static extern uint SendInput(uint nInputs, INPUT[] pInputs, int cbSize);

    [StructLayout(LayoutKind.Sequential)]
    private struct INPUT
    {
        public uint type;
        public InputUnion u;
    }

    [StructLayout(LayoutKind.Explicit)]
    private struct InputUnion
    {
        [FieldOffset(0)] public MOUSEINPUT mi;
        [FieldOffset(0)] public KEYBDINPUT ki;
        [FieldOffset(0)] public HARDWAREINPUT hi;
    }

    [StructLayout(LayoutKind.Sequential)]
    private struct KEYBDINPUT
    {
        public ushort wVk;
        public ushort wScan;
        public uint dwFlags;
        public uint time;
        public IntPtr dwExtraInfo;
    }

    [StructLayout(LayoutKind.Sequential)]
    private struct MOUSEINPUT
    {
        public int dx;
        public int dy;
        public uint mouseData;
        public uint dwFlags;
        public uint time;
        public IntPtr dwExtraInfo;
    }

    [StructLayout(LayoutKind.Sequential)]
    private struct HARDWAREINPUT
    {
        public uint uMsg;
        public ushort wParamL;
        public ushort wParamH;
    }

    // Keyboard event constants
    private const uint INPUT_KEYBOARD = 1;
    private const uint KEYEVENTF_KEYUP = 0x0002;
    private const ushort VK_SPACE = 0x20;

    // Simulate a full spacebar press (down + up)
    public static void TriggerSpacebar()
    {
        // Create press event
        INPUT pressEvent = new INPUT
        {
            type = INPUT_KEYBOARD,
            u = new InputUnion
            {
                ki = new KEYBDINPUT { wVk = VK_SPACE, dwFlags = 0 }
            }
        };

        // Create release event
        INPUT releaseEvent = new INPUT
        {
            type = INPUT_KEYBOARD,
            u = new InputUnion
            {
                ki = new KEYBDINPUT { wVk = VK_SPACE, dwFlags = KEYEVENTF_KEYUP }
            }
        };

        // Send both events
        INPUT[] inputSequence = new INPUT[] { pressEvent, releaseEvent };
        SendInput((uint)inputSequence.Length, inputSequence, Marshal.SizeOf(typeof(INPUT)));
    }
}

Next, use GetAsyncKeyState to reliably check if the middle mouse button is held down (this works better than message-based detection for games):

public class MouseStateChecker
{
    [DllImport("user32.dll")]
    private static extern short GetAsyncKeyState(int vKey);

    private const int VK_MIDDLE_BUTTON = 0x04;

    // Check if middle mouse button is currently pressed
    public static bool IsMiddleButtonHeld()
    {
        // The highest bit of the return value indicates if the key is held
        return (GetAsyncKeyState(VK_MIDDLE_BUTTON) & 0x8000) != 0;
    }
}

Finally, update your Main method to handle the loop correctly:

static void Main(string[] args)
{
    Console.WriteLine("Hold middle mouse button to trigger spacebar. Press any key to exit...");
    bool wasMiddleButtonPressed = false;

    while (!Console.KeyAvailable)
    {
        bool isMiddleButtonPressed = MouseStateChecker.IsMiddleButtonHeld();

        // Only trigger spacebar when the button is first pressed (not held continuously)
        if (isMiddleButtonPressed && !wasMiddleButtonPressed)
        {
            GameInputSimulator.TriggerSpacebar();
            // Add a small delay to prevent spamming (adjust based on your game's needs)
            Thread.Sleep(120);
        }

        wasMiddleButtonPressed = isMiddleButtonPressed;
        // Reduce CPU usage with a tiny sleep
        Thread.Sleep(10);
    }
}

• Run as Administrator: Many games block input simulations from non-admin processes. Right-click your executable and select "Run as administrator" to test this.
• Adjust Delays: The Thread.Sleep values can be tweaked to match your game's jump cooldown—too short and you'll spam jumps, too long and it won't feel responsive.
• Use Scan Codes: If some games still don't recognize the spacebar, replace the wVk field with a scan code (set dwFlags to 0x0008 for scan code mode). This works for games that prioritize hardware scan codes over virtual keys.
• Background Execution: Console apps can lose input focus when minimized. If you need it to run in the background, consider converting it to a Windows Forms/WPF app with a hidden window, or use SetForegroundWindow to keep focus (though games often override this).

内容的提问来源于stack exchange，提问作者GhostyIs1337