public static void DoKeyPress(VirtualKeyCode aKey)
 {
     InputSimulator.SimulateKeyDown(aKey);
     Thread.Sleep(200);
     InputSimulator.SimulateKeyUp(aKey);
     Thread.Sleep(200);
 }

        public static void AsyncHoldKey(VirtualKeyCode keycode)
        {
            if (InputSimulator.asyncHoldThread == null || !InputSimulator.asyncHoldThread.IsAlive)
            {
                InputSimulator.asyncHoldThread = new System.Threading.Thread( new System.Threading.ThreadStart(() =>
                {
                    while (InputSimulator.currentAsyncHoldKeys.Count > 0)
                    {
                        lock (InputSimulator.currentAsyncHoldKeys)
                        {
                            foreach (VirtualKeyCode iter in InputSimulator.currentAsyncHoldKeys)
                            {
                                Console.WriteLine(iter);
                                WindowsInput.InputSimulator.SimulateKeyDown(iter);
                            }
                        }
                        System.Threading.Thread.Sleep(10);
                    }
                }));
                InputSimulator.asyncHoldThread.IsBackground = true;
                InputSimulator.asyncHoldThread.Start();
            }

            currentAsyncHoldKeys.Add(keycode);
        }

        public static void SimulateKeyPress(VirtualKeyCode keyCode)
        {
            var down = new Input();
            down.Type = (UInt32)InputType.KEYBOARD;
            down.Data.Keyboard = new KeybdInput
                                     {
                                         Vk = (UInt16) keyCode,
                                         Scan = 0,
                                         Flags = 0,
                                         Time = 0,
                                         ExtraInfo = IntPtr.Zero
                                     };

            var up = new Input();
            up.Type = (UInt32)InputType.KEYBOARD;
            up.Data.Keyboard = new KeybdInput
                                   {
                                       Vk = (UInt16) keyCode,
                                       Scan = 0,
                                       Flags = (UInt32) KeyboardFlag.KEYUP,
                                       Time = 0,
                                       ExtraInfo = IntPtr.Zero
                                   };

            var inputList = new Input[2];
            inputList[0] = down;
            inputList[1] = up;

            var numberOfSuccessfulSimulatedInputs = User32.SendInput(2, inputList, Marshal.SizeOf(typeof(Input)));
            if (numberOfSuccessfulSimulatedInputs == 0) throw new Exception(string.Format("The key press simulation for {0} was not successful.", keyCode));
        }

 public ModifierKey(VirtualKeyCode key, params VirtualKeyCode[] additional)
 {
     _key = key;
     _additional = additional;
     if(_additional == null)
         _additional = new VirtualKeyCode[0];
 }

 public static void UpKey(VirtualKeyCode keyCode)
 {
     if (Status.isKeyEnabled && InputSimulator.IsKeyDown(keyCode))
     {
         InputSimulator.SimulateKeyUp(keyCode);
     }
 }

        public static Command GenerateCommand(InstructionData instruction)
        {
            VirtualKeyCode[] keys=new VirtualKeyCode[Values.GetLength(0)];
            Values.CopyTo(keys, 0);

            switch (instruction.commandType)
            {
                case InstructionData_CommandType.JOYSTICKAXIS:
                    return new Command(new JoystickCommandData(0,(JoystickDataType)instruction.axis,(short)instruction.value));
                case InstructionData_CommandType.JOYSTICKBUTTON_PRESS:
                    return new Command(new JoystickCommandData(0, JoystickDataType.BUTTON_PRESS, 0, instruction.value));
                case InstructionData_CommandType.JOYSTICKBUTTON_HOLD:
                    return new Command(new JoystickCommandData(0, JoystickDataType.BUTTON_HOLD, 0, instruction.value));
                case InstructionData_CommandType.JOYSTICKBUTTON_RELEASE:
                    return new Command(new JoystickCommandData(0, JoystickDataType.BUTTON_RELEASE, 0, instruction.value));
                case InstructionData_CommandType.KEYBOARD_PRESS:
                    return new Command(new KeyboardCommandData(keys[instruction.value], KeyboardCommandType.PRESS, instruction.control, instruction.shift));
                case InstructionData_CommandType.KEYBOARD_HOLD:
                    return new Command(new KeyboardCommandData(keys[instruction.value], KeyboardCommandType.HOLD, instruction.control, instruction.shift));
                case InstructionData_CommandType.KEYBOARD_RELEASE:
                    return new Command(new KeyboardCommandData(keys[instruction.value], KeyboardCommandType.RELEASE, instruction.control, instruction.shift));
            }

            return null;
        }

 public static void PressKey(VirtualKeyCode keyCode)
 {
     if (Status.isKeyEnabled)
     {
         InputSimulator.SimulateKeyPress(keyCode);
     }
 }

 /// <summary>
 /// Эмулирует действие 'нажать и держать' над кнопкой.
 /// </summary>
 /// <param name="keyCode">
 /// Ключ целевой кнопки.
 /// </param>
 public IKeyboard KeyDown(VirtualKeyCode keyCode)
 {
     this.logger.Info("Key down '{0}'", keyCode.ToString());
     this.keyboardSimulator.KeyDown(keyCode);
     Thread.Sleep(250);
     return this;
 }

 public KeyboardCommandData(VirtualKeyCode key, KeyboardCommandType type, bool control = false, bool shift = false)
 {
     this.key = key;
     this.type = type;
     this.control = control;
     this.shift = shift;
 }

 public void Set(VirtualKeyCode key, KeyState keyState)
 {
     if(_modifierKeyState.ContainsKey(key))
         _modifierKeyState[key] = keyState;
     else
         _modifierKeyState.Add(key, keyState);
 }

 public static void DoBuff(VirtualKeyCode aKey, bool aSelf)
 {
     Point OldMousePos = MouseGetPos();;
     if (aSelf) CenterMouse();
     DoSkill(aKey);
     if (aSelf) MouseMove(OldMousePos);
 }

 public ShiftSensitiveKey(VirtualKeyCode keyCode, string normal, string modified, string displayText)
 {
     _keyCode = keyCode;
     _normal = normal;
     _modified = modified;
     _displayText = displayText;
     Display = !string.IsNullOrEmpty(_displayText) ? _displayText : _normal;
 }

 private void AddKeyInput(VirtualKeyCode keyCode, bool isKeyUp)
 {
     INPUT input = new INPUT();
     input.Type = InputType.InputKeyboard;
     input.Data.Keyboard = new KEYBDINPUT();
     input.Data.Keyboard.wVk = keyCode;
     if (isKeyUp) input.Data.Keyboard.dwFlags = KeyboardEventFlags.KEYEVENTF_KEYUP;
     InputList.Add(input);
 }

        public static void AsyncReleaseKey(VirtualKeyCode keycode)
        {
            lock (InputSimulator.currentAsyncHoldKeys)
            {
                InputSimulator.SimulateKeyUp(keycode);

                InputSimulator.currentAsyncHoldKeys.RemoveAll(key => key.Equals(keycode));
            }
        }

 public MultiCharacterKey(VirtualKeyCode keyCode, IList<string> keyDisplays) :
     base(keyCode)
 {
     if (keyDisplays == null) throw new ArgumentNullException("keyDisplays");
     if (keyDisplays.Count <= 0)
         throw new ArgumentException("Please provide a list of one or more keyDisplays", "keyDisplays");
     KeyDisplays = keyDisplays;
     DisplayName = keyDisplays[0];
 }

        public VirtualKey(VirtualKeyCode virtualKey,
            string displayText,
            List<int> characters,
            bool isAffectedByCapsLock)
        {
            _virtualKey = virtualKey;
            _characters = characters;
            _isAffectedByCapsLock = isAffectedByCapsLock;
            _displayText = displayText;

            for (var x = 0; x < characters.Count; x++)
            {
                var character = default(char);
                var value = characters[x];
                if (value == Definitions.WCH_DEAD)
                {
                    character = ' ';
                }
                else if (value == Definitions.WCH_LGTR)
                {
                    character = ' ';
                }
                else if (value == Definitions.WCH_NONE)
                {
                    character = ' ';
                }
                else
                {
                    character = (char)value;
                }

                switch (x)
                {
                    case 0:
                        characterBase = character;
                        break;
                    case 1:
                        characterShift = character;
                        break;
                    case 2:
                        characterAltGraphics = character;
                        break;
                    case 3:
                        characterControl = character;
                        break;
                    case 4:
                        characterShiftControl = character;
                        break;
                    case 5:
                        characterShiftAltGraphics = character;
                        break;
                }
            }

            Display = GetDisplayValue(false, false);
        }

        /// <summary>
        /// Calls the Win32 SendInput method with a KeyDown and KeyUp message in the same input sequence in order to simulate a Key PRESS.
        /// </summary>
        /// <param name="keyCode">The <see cref="VirtualKeyCode"/> to press</param>
        public void KeyPress(VirtualKeyCode keyCode)
        {
            var inputList =
                new InputBuilder()
                    .AddKeyDown(keyCode)
                    .AddKeyUp(keyCode)
                    .ToArray();

            SendSimulatedInput(inputList);
        }

        public static void PressKey(VirtualKeyCode S)
        {
            if (WindowHandle == null) {
                Console.WriteLine("Cant Send Keypress to Null Window");
                return;
            }

            InputSimulator.SimulateKeyPress(S);
            Console.WriteLine("Sent Key");
        }

        public void SendMessage(VirtualKeyCode key, VirtualKeyCode? modifier = null)
        {
            SetForegroundWindow(hWndLast);

            if (modifier != null)
            {
                InputSimulator.SimulateModifiedKeyStroke((VirtualKeyCode)modifier, key);
                return;
            }

            InputSimulator.SimulateKeyPress(key);
        }

 public void KeyUp(VirtualKeyCode virtualKeyCode)
 {
     try
     {
         Log.DebugFormat("Simulating key up: {0}", virtualKeyCode);
         inputSimulator.Keyboard.KeyUp(virtualKeyCode);
     }
     catch (Exception exception)
     {
         PublishError(this, exception);
     }
 }