Simulate keyboard input in C#

Simulating Keyboard Input in C# for Automation and Testing

Learn how to programmatically simulate keyboard input in C# applications using various methods, from basic key presses to complex key combinations, for automation, testing, and accessibility.

Simulating keyboard input in C# is a powerful technique for automating tasks, conducting UI testing, and enhancing accessibility in applications. Whether you need to send a single keystroke, a sequence of characters, or complex key combinations, C# provides several approaches to achieve this. This article will explore the primary methods available, including the SendKeys class and the more robust Windows API functions, guiding you through their implementation and best practices.

Understanding the SendKeys Class

The System.Windows.Forms.SendKeys class is the simplest way to send keystrokes to an application. It's part of the Windows Forms namespace, but can be used in other application types (like WPF) by adding a reference to System.Windows.Forms.dll. SendKeys works by sending messages to the active window, mimicking user input. It supports a wide range of keys and key combinations, making it suitable for many basic automation tasks.

using System.Windows.Forms;
using System.Threading;

public class KeyboardSimulator
{
    public static void SimulateBasicInput()
    {
        // Ensure the target application is active (e.g., Notepad)
        // This is a simplified example; in a real scenario, you'd find the window handle.
        Thread.Sleep(2000); // Give time to switch to the target window manually for testing

        SendKeys.SendWait("Hello World!");
        SendKeys.SendWait("{ENTER}"); // Press Enter
        SendKeys.SendWait("This is a test.");
        SendKeys.SendWait("^+{HOME}"); // Ctrl+Shift+Home (selects to beginning of line)
        SendKeys.SendWait("{DELETE}"); // Delete selected text
    }

    public static void Main(string[] args)
    {
        // Call SimulateBasicInput() after ensuring a target application is ready.
        // For example, open Notepad before running this.
        // SimulateBasicInput();
    }
}

Basic keyboard input simulation using SendKeys.SendWait.

Advanced Simulation with Windows API (user32.dll)

For more precise control, including sending input to specific background windows or simulating hardware-level key presses, you'll need to P/Invoke functions from the Windows API, specifically user32.dll. The SendInput function is the most powerful and flexible method, allowing you to construct an array of INPUT structures to simulate a sequence of events, including key down and key up events, which is crucial for accurate key combinations.

flowchart TD
    A[Start Simulation] --> B{Determine Target Window?}
    B -- No --> C[Use SendKeys (Active Window)]
    B -- Yes --> D[Find Window Handle (FindWindow/EnumWindows)]
    D --> E{Prepare INPUT Structures}
    E --> F[Call SendInput (user32.dll)]
    F --> G[End Simulation]

Decision flow for choosing keyboard simulation method.

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

public class WinApiKeyboardSimulator
{
    // Define the INPUT type
    [StructLayout(LayoutKind.Sequential)]
    public struct INPUT
    {
        public uint type;
        public InputUnion U;
    }

    // Define the InputUnion for keyboard events
    [StructLayout(LayoutKind.Explicit)]
    public struct InputUnion
    {
        [FieldOffset(0)]
        public KEYBDINPUT ki;
    }

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

    // Constants for dwFlags
    public const int KEYEVENTF_EXTENDEDKEY = 0x0001;
    public const int KEYEVENTF_KEYUP = 0x0002;
    public const int KEYEVENTF_SCANCODE = 0x0008;
    public const int KEYEVENTF_UNICODE = 0x0004;

    // Virtual-key codes (example: 'A' key)
    public const ushort VK_A = 0x41;
    public const ushort VK_CONTROL = 0x11;

    // P/Invoke SendInput
    [DllImport("user32.dll", SetLastError = true)]
    private static extern uint SendInput(uint nInputs, INPUT[] pInputs, int cbSize);

    public static void SimulateKeyPress(ushort virtualKeyCode)
    {
        INPUT[] inputs = new INPUT[2];

        // Key Down
        inputs[0].type = 1; // INPUT_KEYBOARD
        inputs[0].U.ki.wVk = virtualKeyCode;
        inputs[0].U.ki.dwFlags = 0; // 0 for key down

        // Key Up
        inputs[1].type = 1; // INPUT_KEYBOARD
        inputs[1].U.ki.wVk = virtualKeyCode;
        inputs[1].U.ki.dwFlags = KEYEVENTF_KEYUP; // KEYEVENTF_KEYUP for key up

        SendInput((uint)inputs.Length, inputs, Marshal.SizeOf(typeof(INPUT)));
    }

    public static void SimulateCtrlC()
    {
        INPUT[] inputs = new INPUT[4];

        // Ctrl Down
        inputs[0].type = 1;
        inputs[0].U.ki.wVk = VK_CONTROL;
        inputs[0].U.ki.dwFlags = 0;

        // C Down
        inputs[1].type = 1;
        inputs[1].U.ki.wVk = (ushort)'C';
        inputs[1].U.ki.dwFlags = 0;

        // C Up
        inputs[2].type = 1;
        inputs[2].U.ki.wVk = (ushort)'C';
        inputs[2].U.ki.dwFlags = KEYEVENTF_KEYUP;

        // Ctrl Up
        inputs[3].type = 1;
        inputs[3].U.ki.wVk = VK_CONTROL;
        inputs[3].U.ki.dwFlags = KEYEVENTF_KEYUP;

        SendInput((uint)inputs.Length, inputs, Marshal.SizeOf(typeof(INPUT)));
    }

    public static void Main(string[] args)
    {
        // Example usage:
        // SimulateKeyPress(VK_A);
        // Thread.Sleep(500);
        // SimulateCtrlC();
    }
}

Simulating key presses and combinations using SendInput via P/Invoke.

Choosing the Right Method

The choice between SendKeys and SendInput depends on your specific requirements:

• SendKeys: Ideal for simple automation tasks where the target window is always active and precise timing or background interaction isn't critical. It's easier to implement and requires less boilerplate code.

• SendInput (via P/Invoke): Necessary for robust UI automation, testing, and scenarios where you need to send input to specific windows (even if not active), simulate hardware-level input, or handle complex key sequences with precise timing. It offers greater control but involves more complex setup due to P/Invoke.

For most modern UI automation, especially in enterprise environments, dedicated UI automation frameworks (like Selenium for web, or UI Automation for desktop applications) are often preferred as they provide more reliable and maintainable solutions than direct input simulation.

1. Identify Your Target

Determine which application or window you intend to send keyboard input to. This will influence whether you need to manage window focus or find a window handle.

2. Choose Your Method

Based on the complexity and reliability requirements, decide between SendKeys for simplicity or SendInput for advanced control and background interaction.

3. Implement and Test

Write your C# code using the chosen method. Thoroughly test your simulation, especially with different timings and application states, to ensure it behaves as expected.

4. Handle Focus (if using SendKeys)

If using SendKeys, ensure your target application is active. You might need to use SetForegroundWindow (another Windows API call) to bring the target window to the foreground before sending keys.