Procedura: Simulare eventi mouse e tastiera nel codice

Windows Form offre diverse opzioni per simulare a livello di codice l'input del mouse e della tastiera. In questo argomento viene fornita una panoramica di queste opzioni.

Simulare l'input del mouse

Il modo migliore per simulare gli eventi del mouse consiste nel chiamare il metodo EventName che genera l'evento del mouse da simulare. Questa opzione è in genere possibile solo all'interno di controlli e moduli personalizzati, perché i metodi che generano eventi sono protetti e non possono essere accessibili all'esterno del controllo o del modulo. Ad esempio, i passaggi seguenti illustrano come simulare il clic con il pulsante destro del mouse nel codice.

Per fare clic sul pulsante destro del mouse programmaticamente

1. Creare un MouseEventArgs la cui proprietà Button è impostata sul valore MouseButtons.Right.

2. Chiamare il metodo OnMouseClick con questo MouseEventArgs come argomento.

Per ulteriori informazioni sui controlli personalizzati, consultare Sviluppo di controlli di Windows Forms durante la fase di progettazione.

Esistono altri modi per simulare l'input del mouse. Ad esempio, è possibile impostare a livello di codice una proprietà di controllo che rappresenta uno stato in genere impostato tramite l'input del mouse, ad esempio la proprietà Checked del controllo CheckBox, oppure è possibile chiamare direttamente il delegato associato all'evento da simulare.

Simulazione dell'input da tastiera

Sebbene sia possibile simulare l'input da tastiera usando le strategie descritte in precedenza per l'input del mouse, Windows Form fornisce anche la classe SendKeys per l'invio di sequenze di tasti all'applicazione attiva.

<appSettings>
 <add key="SendKeys" value="SendInput"/>
</appSettings>

Per inviare una sequenza di tasti alla stessa applicazione

1. Chiamare il metodo Send o SendWait della classe SendKeys. Le sequenze di tasti specificate verranno ricevute dal controllo attivo dell'applicazione. L'esempio di codice seguente usa Send per simulare la pressione del tasto INVIO quando l'utente fa doppio clic sulla superficie del modulo. In questo esempio si presuppone un Form con un singolo controllo Button con un indice di tabulazione pari a 0.

       // Send a key to the button when the user double-clicks anywhere
       // on the form.
   private:
       void Form1_DoubleClick(Object^ sender, EventArgs^ e)
       {
           // Send the enter key to the button, which triggers the click
           // event for the button. This works because the tab stop of
           // the button is 0.
           SendKeys::Send("{ENTER}");
       }
   

   // Send a key to the button when the user double-clicks anywhere
   // on the form.
   private void Form1_DoubleClick(object sender, EventArgs e)
   {
       // Send the enter key to the button, which raises the click
       // event for the button. This works because the tab stop of
       // the button is 0.
       SendKeys.Send("{ENTER}");
   }
   

   ' Send a key to the button when the user double-clicks anywhere 
   ' on the form.
   Private Sub Form1_DoubleClick(ByVal sender As Object, _
       ByVal e As EventArgs) Handles Me.DoubleClick
   
       ' Send the enter key to the button, which raises the click 
       ' event for the button. This works because the tab stop of 
       ' the button is 0.
       SendKeys.Send("{ENTER}")
   End Sub
   

Per inviare una sequenza di tasti a un'applicazione diversa

1. Attivare la finestra dell'applicazione che riceverà le sequenze di tasti e quindi chiamare il metodo Send o SendWait. Poiché non esiste alcun metodo gestito per attivare un'altra applicazione, è necessario usare metodi Windows nativi per forzare il focus su altre applicazioni. L'esempio di codice seguente usa platform invoke per chiamare i metodi FindWindow e SetForegroundWindow per attivare la finestra dell'applicazione Calculator e quindi chiama SendWait per inviare una serie di calcoli all'applicazione Calculator.

   Nota

   I parametri corretti della chiamata FindWindow che individua l'applicazione Calculator variano in base alla versione di Windows. Il codice seguente trova l'applicazione Calculator in Windows 7. In Windows Vista modificare il primo parametro in "SciCalc". È possibile usare lo strumento Spy++, incluso in Visual Studio, per determinare i parametri corretti.

       // Get a handle to an application window.
   public:
       [DllImport("USER32.DLL", CharSet = CharSet::Unicode)]
       static IntPtr FindWindow(String^ lpClassName, String^ lpWindowName);
   public:
       // Activate an application window.
       [DllImport("USER32.DLL")]
       static bool SetForegroundWindow(IntPtr hWnd);
   
       // Send a series of key presses to the Calculator application.
   private:
       void button1_Click(Object^ sender, EventArgs^ e)
       {
           // Get a handle to the Calculator application. The window class
           // and window name were obtained using the Spy++ tool.
           IntPtr calculatorHandle = FindWindow("CalcFrame", "Calculator");
   
           // Verify that Calculator is a running process.
           if (calculatorHandle == IntPtr::Zero)
           {
               MessageBox::Show("Calculator is not running.");
               return;
           }
   
           // Make Calculator the foreground application and send it
           // a set of calculations.
           SetForegroundWindow(calculatorHandle);
           SendKeys::SendWait("111");
           SendKeys::SendWait("*");
           SendKeys::SendWait("11");
           SendKeys::SendWait("=");
       }
   

   // Get a handle to an application window.
   [DllImport("USER32.DLL", CharSet = CharSet.Unicode)]
   public static extern IntPtr FindWindow(string lpClassName,
       string lpWindowName);
   
   // Activate an application window.
   [DllImport("USER32.DLL")]
   public static extern bool SetForegroundWindow(IntPtr hWnd);
   
   // Send a series of key presses to the Calculator application.
   private void button1_Click(object sender, EventArgs e)
   {
       // Get a handle to the Calculator application. The window class
       // and window name were obtained using the Spy++ tool.
       IntPtr calculatorHandle = FindWindow("CalcFrame","Calculator");
   
       // Verify that Calculator is a running process.
       if (calculatorHandle == IntPtr.Zero)
       {
           MessageBox.Show("Calculator is not running.");
           return;
       }
   
       // Make Calculator the foreground application and send it
       // a set of calculations.
       SetForegroundWindow(calculatorHandle);
       SendKeys.SendWait("111");
       SendKeys.SendWait("*");
       SendKeys.SendWait("11");
       SendKeys.SendWait("=");
   }
   

   ' Get a handle to an application window.
   Declare Auto Function FindWindow Lib "USER32.DLL" ( _
       ByVal lpClassName As String, _
       ByVal lpWindowName As String) As IntPtr
   
   ' Activate an application window.
   Declare Auto Function SetForegroundWindow Lib "USER32.DLL" _
       (ByVal hWnd As IntPtr) As Boolean
   
   ' Send a series of key presses to the Calculator application.
   Private Sub button1_Click(ByVal sender As Object, _
       ByVal e As EventArgs) Handles button1.Click
   
       ' Get a handle to the Calculator application. The window class
       ' and window name were obtained using the Spy++ tool.
       Dim calculatorHandle As IntPtr = FindWindow("CalcFrame", "Calculator")
   
       ' Verify that Calculator is a running process.
       If calculatorHandle = IntPtr.Zero Then
           MsgBox("Calculator is not running.")
           Return
       End If
   
       ' Make Calculator the foreground application and send it 
       ' a set of calculations.
       SetForegroundWindow(calculatorHandle)
       SendKeys.SendWait("111")
       SendKeys.SendWait("*")
       SendKeys.SendWait("11")
       SendKeys.SendWait("=")
   End Sub
   

Esempio

L'esempio di codice seguente è l'applicazione completa per gli esempi di codice precedenti.

#using <System.Drawing.dll>
#using <System.Windows.Forms.dll>
#using <System.dll>

using namespace System;
using namespace System::Runtime::InteropServices;
using namespace System::Drawing;
using namespace System::Windows::Forms;

namespace SimulateKeyPress
{

    public ref class Form1 : public Form
    {
    public:
        Form1()
        {
            Button^ button1 = gcnew Button();
            button1->Location = Point(10, 10);
            button1->TabIndex = 0;
            button1->Text = "Click to automate Calculator";
            button1->AutoSize = true;
            button1->Click += gcnew EventHandler(this, &Form1::button1_Click);

            this->DoubleClick += gcnew EventHandler(this, 
                &Form1::Form1_DoubleClick);
            this->Controls->Add(button1);
        }

        // Get a handle to an application window.
    public:
        [DllImport("USER32.DLL", CharSet = CharSet::Unicode)]
        static IntPtr FindWindow(String^ lpClassName, String^ lpWindowName);
    public:
        // Activate an application window.
        [DllImport("USER32.DLL")]
        static bool SetForegroundWindow(IntPtr hWnd);

        // Send a series of key presses to the Calculator application.
    private:
        void button1_Click(Object^ sender, EventArgs^ e)
        {
            // Get a handle to the Calculator application. The window class
            // and window name were obtained using the Spy++ tool.
            IntPtr calculatorHandle = FindWindow("CalcFrame", "Calculator");

            // Verify that Calculator is a running process.
            if (calculatorHandle == IntPtr::Zero)
            {
                MessageBox::Show("Calculator is not running.");
                return;
            }

            // Make Calculator the foreground application and send it
            // a set of calculations.
            SetForegroundWindow(calculatorHandle);
            SendKeys::SendWait("111");
            SendKeys::SendWait("*");
            SendKeys::SendWait("11");
            SendKeys::SendWait("=");
        }

        // Send a key to the button when the user double-clicks anywhere
        // on the form.
    private:
        void Form1_DoubleClick(Object^ sender, EventArgs^ e)
        {
            // Send the enter key to the button, which triggers the click
            // event for the button. This works because the tab stop of
            // the button is 0.
            SendKeys::Send("{ENTER}");
        }
    };
}

[STAThread]
int main()
{
    Application::EnableVisualStyles();
    Application::Run(gcnew SimulateKeyPress::Form1());
}

using System;
using System.Runtime.InteropServices;
using System.Drawing;
using System.Windows.Forms;

namespace SimulateKeyPress
{
    class Form1 : Form
    {
        private Button button1 = new Button();

        [STAThread]
        public static void Main()
        {
            Application.EnableVisualStyles();
            Application.Run(new Form1());
        }

        public Form1()
        {
            button1.Location = new Point(10, 10);
            button1.TabIndex = 0;
            button1.Text = "Click to automate Calculator";
            button1.AutoSize = true;
            button1.Click += new EventHandler(button1_Click);

            this.DoubleClick += new EventHandler(Form1_DoubleClick);
            this.Controls.Add(button1);
        }

        // Get a handle to an application window.
        [DllImport("USER32.DLL", CharSet = CharSet.Unicode)]
        public static extern IntPtr FindWindow(string lpClassName,
            string lpWindowName);

        // Activate an application window.
        [DllImport("USER32.DLL")]
        public static extern bool SetForegroundWindow(IntPtr hWnd);

        // Send a series of key presses to the Calculator application.
        private void button1_Click(object sender, EventArgs e)
        {
            // Get a handle to the Calculator application. The window class
            // and window name were obtained using the Spy++ tool.
            IntPtr calculatorHandle = FindWindow("CalcFrame","Calculator");

            // Verify that Calculator is a running process.
            if (calculatorHandle == IntPtr.Zero)
            {
                MessageBox.Show("Calculator is not running.");
                return;
            }

            // Make Calculator the foreground application and send it
            // a set of calculations.
            SetForegroundWindow(calculatorHandle);
            SendKeys.SendWait("111");
            SendKeys.SendWait("*");
            SendKeys.SendWait("11");
            SendKeys.SendWait("=");
        }

        // Send a key to the button when the user double-clicks anywhere
        // on the form.
        private void Form1_DoubleClick(object sender, EventArgs e)
        {
            // Send the enter key to the button, which raises the click
            // event for the button. This works because the tab stop of
            // the button is 0.
            SendKeys.Send("{ENTER}");
        }
    }
}

Imports System.Runtime.InteropServices
Imports System.Drawing
Imports System.Windows.Forms

Namespace SimulateKeyPress

    Class Form1
        Inherits Form
        Private WithEvents button1 As New Button()

        <STAThread()> _
        Public Shared Sub Main()
            Application.EnableVisualStyles()
            Application.Run(New Form1())
        End Sub

        Public Sub New()
            button1.Location = New Point(10, 10)
            button1.TabIndex = 0
            button1.Text = "Click to automate Calculator"
            button1.AutoSize = True
            Me.Controls.Add(button1)
        End Sub

        ' Get a handle to an application window.
        Declare Auto Function FindWindow Lib "USER32.DLL" ( _
            ByVal lpClassName As String, _
            ByVal lpWindowName As String) As IntPtr

        ' Activate an application window.
        Declare Auto Function SetForegroundWindow Lib "USER32.DLL" _
            (ByVal hWnd As IntPtr) As Boolean

        ' Send a series of key presses to the Calculator application.
        Private Sub button1_Click(ByVal sender As Object, _
            ByVal e As EventArgs) Handles button1.Click

            ' Get a handle to the Calculator application. The window class
            ' and window name were obtained using the Spy++ tool.
            Dim calculatorHandle As IntPtr = FindWindow("CalcFrame", "Calculator")

            ' Verify that Calculator is a running process.
            If calculatorHandle = IntPtr.Zero Then
                MsgBox("Calculator is not running.")
                Return
            End If

            ' Make Calculator the foreground application and send it 
            ' a set of calculations.
            SetForegroundWindow(calculatorHandle)
            SendKeys.SendWait("111")
            SendKeys.SendWait("*")
            SendKeys.SendWait("11")
            SendKeys.SendWait("=")
        End Sub

        ' Send a key to the button when the user double-clicks anywhere 
        ' on the form.
        Private Sub Form1_DoubleClick(ByVal sender As Object, _
            ByVal e As EventArgs) Handles Me.DoubleClick

            ' Send the enter key to the button, which raises the click 
            ' event for the button. This works because the tab stop of 
            ' the button is 0.
            SendKeys.Send("{ENTER}")
        End Sub

    End Class
End Namespace

Compilazione del codice

Questo esempio richiede:

• Riferimenti agli assembly System, System.Drawing e System.Windows.Forms.

Vedere anche

• input utente in Windows Form