Simuler l'appui d'une touche en C#

Version imprimable

Bonjour à tous ,

Je suis étudiant en informatique, et j'aime la programmation.
En ce moment je code en C# et je cherche à faire une application qui puisse à partir du nom de processus en cours
Obtenir les noms de fenêtre et ensuite Générer ou simuler l'appui de plusieurs touches du clavier uniquement dans cette fenêtre cible.

Je travaille avec WPF et je suis en Framework 4.5.1 je travaille sur Visual Studio 2013 :mrgreen:

J'ai déjà fais un petit bout du travail, à savoir la partie concernant les processus .
Code:

1 2 3 4 5 6 7 8 9 10 11 12 // JE CRÉE UN TABLEAU AVEC TOUS MES PROCESSUS DEDANS Process[] myProcesses = Process.GetProcesses(); // JE PARCOURS LE TABLEAU ET AJOUTE TOUTES LES VALEURS DANS LA COMBO BOX foreach (Process myProcess in myProcesses) { MaCombobox.Items.Add(myProcess.ProcessName ); }
Ce bout de code prend tous les processus en cours et les affiche dans une ComboBox .
N'oubliez pas que si vous voulez utiliser mon code vous devez rajouter "using System.Diagnostics;" :mouarf:

Merci d'avance

13/06/2014, 17h36
Pol63

sendkeys

pour les fenetres il faudra s'orienter vers des api de windows
13/06/2014, 18h01
aldebaran974

SendKey , justement à ce propos ! je n'arrive pas à l'utiliser peut importe comment je m'y prend il me met toujours une erreur ( soulignement rouge )
SendKey n'est donc pas reconnue comme il devrait l’être .

Merci pour ton aide , j'ai trouvé du coté de winAPI .

Je donne mon code pour être constructif :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
 
 
// Je déclare ceci dans ma classe
 
        [DllImport("user32.dll", SetLastError = true)]
 
        // Voici ma fonction qui va servir à simuler l'appuie des touches
 
        static extern void keybd_event(byte bVk, byte bScan, int dwFlags, int dwExtraInfo);
 
        public const int KEYEVENTF_EXTENDEDKEY = 0x0001; //Appuie  de la  touche
        public const int KEYEVENTF_KEYUP = 0x0002; //Relachement  de la  touche
 
 
 
        //Les codes ci-après ne sont pas toujours juste ( 4 premières lettres testées )
 
        public const int A = 0x41;
        public const int B = 0x42;
        public const int C = 0x43;
        public const int D = 0x44;
        public const int E = 0x45;        
        public const int F = 0x46;
        public const int G = 0x47;
        public const int H = 0x48;
        public const int I = 0x49;
        public const int J = 0x50;
        public const int K = 0x51;
        public const int L = 0x52;
        public const int M = 0x53;
        public const int N = 0x54;
        public const int O = 0x55;
        public const int P = 0x56;
        public const int Q = 0x57;
        public const int R = 0x58;
        public const int S = 0x59;
        public const int T = 0x60;
        public const int U = 0x61;
        public const int V = 0x62;
        public const int W = 0x63;
        public const int X = 0x64;
        public const int Y = 0x65;
        public const int Z = 0x66;
 
 
 
// Je crée ma fonction qui va appuyer sur les touches
 
        public static void PressKeys()
        {
 
            System.Threading.Thread.Sleep(5000);
 
 
            // APPUIE DE LA TOUCHE A
 
            keybd_event(A, 0, KEYEVENTF_EXTENDEDKEY, 0); //appuie 
            keybd_event(A, 0, KEYEVENTF_KEYUP, 0); //relache
 
            // PAUSE (temps en miliseconde)
            System.Threading.Thread.Sleep(1000);
 
            // APPUIE DE LA TOUCHE B
            keybd_event(B, 0, KEYEVENTF_EXTENDEDKEY, 0);
            keybd_event(B, 0, KEYEVENTF_KEYUP, 0);
 
 
            System.Threading.Thread.Sleep(1000);
 
 
            // APPUIE DE LA TOUCHE C
            keybd_event(C, 0, KEYEVENTF_EXTENDEDKEY, 0);
            keybd_event(C, 0, KEYEVENTF_KEYUP, 0);
 
 
            System.Threading.Thread.Sleep(1000);
 
 
            // APPUIE DE LA TOUCHE D
            keybd_event(D, 0, KEYEVENTF_EXTENDEDKEY, 0);
            keybd_event(D, 0, KEYEVENTF_KEYUP, 0);  
 
 
        }
// Et j’appelle ma fonction ou bon me semble

Donc que fais ce code ? :weird:

Résumons !

Citation:

Il va écrire :
A (J'attend 1 seconde)
B (J'attend 1 seconde)
C (J'attend 1 seconde )
D (J'attend 1 seconde )

14/06/2014, 21h10
aldebaran974

:calim2:

Quelqu'un pourrait-il m'aider ?! Il me reste à récupéré la fenêtre cible pour la simulation d'appuie de touche ...

Je ne sais pas comment faire .

:oops:
15/06/2014, 02h01
Pol63

http://msdn.microsoft.com/fr-fr/library/system.windows.forms.sendkeys%28v=vs.110%29.aspx

https://www.google.fr/?gws_rd=ssl#q=...ctive%20window
15/06/2014, 10h19
aldebaran974

Je répète que SendKeys de marche pas en WPF :aie:
Au secours ! :(
15/06/2014, 10h45
Etanne

Bonjour,

Deux solutions :
Ajoutez la référence System.Windows.Forms et utilisez SendKeys.SendWait
ou utilisez un Pinvoke sur SendInput : SendInput (user32)

Etanne

Merci Etanne , J'en prend note , la référence ne veut pas s'ajouter a cause d'un truc ambiguë donc je laisse tombé je vais plutôt me penché du coté du pinvoke.

Tu aurais peut être un exemple à me fournir ?

cela m'aiderai beaucoup , je pense qu'il serait aussi utile pour moi , et pour les autres :oops: .

En te remerciant pour tes réponses.:mouarf:

Question tout à fait par hasard :

Est ce que avec keybd_event je peux choisir la destination ? ( vers processus ou fenêtre ou Handle )

Merci à tous

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
//Je Déclare mes clés de touche pavé numérique
 
        public const int PAD1 = 0x61;
        public const int PAD2 = 0x62;
        public const int PAD3 = 0x63;
        public const int PAD4 = 0x64;
        public const int PAD5 = 0x65;
        public const int PAD6 = 0x66; 
        public const int PAD7 = 0x67;
        public const int PAD8 = 0x68;
        public const int PAD9 = 0x69;
 
        public const int SPACEBAR = 0x20;
 
    const int WM_KEYDOWN = 0x0100;
    const int WM_KEYUP = 0x0101;
    const int WM_CHAR = 0x0102;
 
        [DllImport("user32.dll")]
        static extern bool PostMessage(IntPtr hWnd, uint Msg, int wParam, int lParam);
 
        [DllImport("user32.dll", EntryPoint = "FindWindow")]
        private static extern int FindWindow(string sClass, string sWindow);
 
        [DllImport("user32.dll", SetLastError = true)]
        static extern void keybd_event(byte bVk, byte bScan, int dwFlags, int dwExtraInfo);
 
        [DllImport("user32.dll")]
        static extern byte VkKeyScan(char ch);
 
        [DllImport("user32.dll", CharSet = CharSet.Auto)]
        private static extern int SendMessage(IntPtr hWnd, int wMsg, IntPtr wParam, IntPtr lParam);
 
 
                public static void PressSpaceBar()
        {
 
            while (true)
            {
                System.Threading.Thread.Sleep(500);
 
//Que dois-je faire pour qu"il envoie une touche pavé numérique à la fenêtre bloc-notes ? 
 
                FindWindow("edit", "Sans titre - Blocnotes");
 
                SendMessage(FindWindow, 0x100, "edit", FindWindow);
                                                //Ou 
               PostMessage(IntPtr hWnd, uint Msg, int wParam, int lParam);
//Comment utiliser post et send ? Que sont les arguments à mettre à l'intérieur de celle-ci ?
 
            }
 
        }

16/06/2014, 15h31
ebastien

Bonjour,

Citation:

Envoyé par aldebaran974

Est ce que avec keybd_event je peux choisir la destination ? ( vers processus ou fenêtre ou Handle )

Non, Keybd_event envoie à la fenêtre ayant le focus. Pour l'envoyer vers une autre fenêtre, il faut utiliser PostMessage. J'ai bossé là-dessus il y a très longtemps en Delphi. Donc ce sont de vieux souvenirs.

PostMessage(IntPtr hWnd, uint Msg, int wParam, int lParam);

hWnd : Le handle de fenêtre sur laquelle tu veux envoyer ton caractère,
Msg : Le message windows. Ici ce sera WM_CHAR (= 0x0102)
wParam : le code ascii du caractère à envoyer.
lParam : En envoyant 0, ça devrait fonctionner.

Maintenant pour employer keybd_event (qui permettra d'envoyer aussi des caractères étendus genre Control, Alt etc.), il suffit de donner le focus à la fenêtre désirée.
Encore une fois ce sont de vieux souvenirs ...

J'avais fait un bot en c#, un exemple pour envoyer la touche F5 à notepad en WPF.
Xaml:

Code:

1
2
3
4
5
6
7
8
9
10
11
 
<Window x:Class="SendKey.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="350" Width="525">
    <Grid>
        <Button Content="Send Key" Height="23" HorizontalAlignment="Left" Margin="348,20,0,0" Name="btnSendKey" VerticalAlignment="Top" Width="75" Click="btnSendKey_Click" />
        <ComboBox Height="23" HorizontalAlignment="Left" ItemsSource="{Binding}" SelectedValuePath="MainWindowHandle"  DisplayMemberPath="MainWindowTitle" Margin="29,20,0,0" Name="cbProcess" VerticalAlignment="Top" Width="168" />
        <Button Content="Refresh" Height="23" HorizontalAlignment="Right" Margin="0,20,169,0" Name="btnRefresh" VerticalAlignment="Top" Width="75" Click="btnRefresh_Click" />
    </Grid>
</Window>

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Threading;
 
namespace SendKey
{
    /// <summary>
    /// Logique d'interaction pour MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        [return: MarshalAs(UnmanagedType.Bool)]
        [DllImport("user32.dll", SetLastError = true)]
        static extern bool PostMessage(IntPtr hWnd, uint Msg, int wParam, int lParam);
 
        [DllImport("user32.dll")]
        public static extern long SetForegroundWindow(IntPtr hWnd);
 
        const uint WM_KEYDOWN = 0x100;
        const uint WM_KEYUP = 0x101;
        private const int VK_F5 = 116;
 
        public MainWindow()
        {
            InitializeComponent();
            BindProcess("Notepad");
        }
 
 
        /// <summary>
        /// Permet d'afficher tous les processus avec ce nom dans la combobox
        /// </summary>
        /// <param name="name"></param>
        private void BindProcess(string name)
        {
            Process[] prog = Process.GetProcessesByName(name);
            cbProcess.DataContext = prog;
        }
 
        private void btnRefresh_Click(object sender, RoutedEventArgs e)
        {
            BindProcess("Notepad");
        }
 
 
 
        private void btnSendKey_Click(object sender, RoutedEventArgs e)
        {
            if (cbProcess.SelectedValue != null)
            {
                IntPtr idProcess = (IntPtr)cbProcess.SelectedValue;
                SetForegroundWindow(idProcess);
                Thread.Sleep(50);
                PostMessage(idProcess, WM_KEYDOWN, VK_F5, 0);
                Thread.Sleep(50);
                PostMessage(idProcess, WM_KEYUP, VK_F5, 1);
            }
        }
    }
}

18/06/2014, 21h02
aldebaran974

Franchement chapeau , pour vos réponses ! Simple clair et nette , je suis sur que ce post rendra service à plus d'un , et vous remercie gracieusement :mouarf:
Merciii énorme à Ebastien et à youtpout978 qui ont résolus le poste avec brio .
19/06/2014, 19h01
aldebaran974

Malgré votre explication plus que satisfaisante , j'aimerais savoir si il y aurait pas par hasard un moyen simple pour obtenir un Handle de fenêtre à partir d'un processus en cours !?

:aie: Merci encore
20/06/2014, 07h46
youtpout978

Pourquoi c'est pas assez simple mon exemple ?
20/06/2014, 10h00
aldebaran974

BindProcess("Notepad"); ?

Ton code est sans erreur mais il n'y a aucun commentaire :calim2:

Bein la méthode si
Code:

1 2 3 4 5 6 7 8 9 /// <summary> /// Permet d'afficher tous les processus avec ce nom dans la combobox /// </summary> /// <param name="name"></param> private void BindProcess(string name) { Process[] prog = Process.GetProcessesByName(name); cbProcess.DataContext = prog; }
Permet d'afficher tous les processus avec ce nom dans la combobox.
Pour la méthode GetProcessesByName tu trouveras tout ce qu'il te faut sur le msdn.
Pour l'affichage dans la combobox:
Code:

1 2 <ComboBox Height="23" HorizontalAlignment="Left" ItemsSource="{Binding}" SelectedValuePath="MainWindowHandle" DisplayMemberPath="MainWindowTitle" Margin="29,20,0,0" Name="cbProcess" VerticalAlignment="Top" Width="168" />
Le selectedValuePath indiquera sur quoi sera bindé la propriété SelectedValue de la combobox (dans ce cas la propriété MainWindowHandle de l'objet process) et le DisplayMemberPath indiquera sur quoi sera bindé la propriété d'affichage (celle qui est affiché à l'écran) de la combobox (dans ce cas la propriété MainWindowTitlede l'objet process).

Je pensais pas que tu ne comprendrais pas :aie:

Quelque lien pour t'aider:
http://msdn.microsoft.com/fr-fr/libr...vs.110%29.aspx
http://nathanaelmarchand.developpez....t-silverlight/

20/06/2014, 16h03
aldebaran974

Par-contre ton code ne m'affiche pas les processus en cours ... c'est normal ?
20/06/2014, 17h19
youtpout978

Il faut qu'il soit exécuter lorsque le processus est lancé, si tu lances le processus après l'appli elle sera pas mise à jour automatiquement et c'est à ça que me sert le bouton rafraichir à rappeler ce code au cas où je lance de nouveau processus.