A simulação de entrada de teclado é uma técnica comum em automação de tarefas e integração de sistemas onde APIs convencionais não estão disponíveis. No ecossistema .NET, isso pode ser alcançado através da invocação de funções nativas do Windows (P/Invoke), especificamente utilizando a user32.dll.

1. Importação da API Nativa

Para interagir com o subsistema de entrada do Windows, utilizamos a função keybd_event. Esta função sintetiza pressionamentos de teclas enviando mensagens diretamente ao driver de teclado.

using System;
using System.Runtime.InteropServices;
using System.Collections.Generic;
using System.Threading;

public class SimuladorTeclado
{
    [DllImport("user32.dll")]
    private static extern void keybd_event(byte bVk, byte bScan, uint dwFlags, int dwExtraInfo);

    private const uint KEYEVENTF_KEYUP = 0x0002;
    private const uint KEYEVENTF_KEYDOWN = 0x0000;
}

2. Mapeamento de Códigos de Teclas Virtuais

O Windows identifica as teclas através de Virtual-Key Codes (VK). Para facilitar o uso, podemos estruturar um dicionário que mapeia caracteres comuns aos seus respectivos bytes hexadecimais.

private static readonly Dictionary<char, byte> MapaTeclas = new Dictionary<char, byte>
{
    {'A', 0x41}, {'B', 0x42}, {'C', 0x43},
    {'1', 0x31}, {'2', 0x32}, {'.', 0x6E},
    {'-', 0x6D}, {' ', 0x20}
};

3. Simulação de Digitação de Texto

Ao processar uma string para simular a digitação, é crucial considerar o tempo de resposat do sistema operacional. Enviar comandos de forma excessivamente rápida pode resultar na perda de caracteres.

public static void EnviarTexto(string conteudo)
{
    foreach (char c in conteudo.ToUpper())
    {
        if (MapaTeclas.ContainsKey(c))
        {
            byte vk = MapaTeclas[c];
            // Pressiona a tecla
            keybd_event(vk, 0, KEYEVENTF_KEYDOWN, 0);
            Thread.Sleep(20); 
            // Libera a tecla
            keybd_event(vk, 0, KEYEVENTF_KEYUP, 0);
            Thread.Sleep(30);
        }
    }
}

4. Execução de Atalhos e Combinações de Teclas

Para simular atalhos como "Ctrl + V", devemos seguir uma ordem lógica: pressionar as teclas modificadoras, pressionar a tecla de ação, liberar a tecla de ação e, por fim, liberar as modificadoras.

public static void SimularColar()
{
    const byte VK_CONTROL = 0x11;
    const byte VK_V = 0x56;

    // Segura CTRL e pressiona V
    keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYDOWN, 0);
    keybd_event(VK_V, 0, KEYEVENTF_KEYDOWN, 0);

    // Libera V e depois libera CTRL
    keybd_event(VK_V, 0, KEYEVENTF_KEYUP, 0);
    keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
}

5. Simulação da Tecla Enter com Delay

Algumas ações exigem um intervalo maior para que a interface gráfica processe o comando, como no caso da tecla Enter após preencher um formulário.

public static void PressionarEnter()
{
    const byte VK_RETURN = 0x0D;

    keybd_event(VK_RETURN, 0, KEYEVENTF_KEYDOWN, 0);
    // Pausa necessária para emular o comportamento humano e processamento do SO
    Thread.Sleep(50); 
    keybd_event(VK_RETURN, 0, KEYEVENTF_KEYUP, 0);
}