使用C#制作可以录制自动化执行Windows操作脚本工具——类似于按键精灵 ...

欢乐狗  金牌会员 | 2022-9-1 20:10:08 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 879|帖子 879|积分 2637

我们知道，如果要对一个网站进行自动化测试，可以使用Python的selenium对获取网页的元素进行一系列操作。同样，对于Windows应用，可以使用C#或者AutoIt（也是一种脚本语言，相比较与C#，AutoIt更适合做Windows应用的自动化脚本）捕获窗体句柄进行操作。
今天主要记录一下使用WPF制作可以录制自动化执行Windows操作脚本工具，类似于按键精灵的录制脚本的操作。主要使用勾子捕获鼠标键盘事件。
  1. <Window x:Class="AutoOperationTool.MainWindow"
  2.         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  3.         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  4.         xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
  5.         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
  6.         xmlns:local="clr-namespace:AutoOperationTool"
  7.         mc:Ignorable="d"
  8.         Title="自动化脚本" Height="450" Width="800">
  9.     <Grid>
  10.         <Grid.RowDefinitions>
  11.             <RowDefinition></RowDefinition>
  12.             <RowDefinition></RowDefinition>
  13.             <RowDefinition></RowDefinition>
  14.         </Grid.RowDefinitions>
  15.         <Grid VerticalAlignment="Bottom" Margin="0 0 0 30">
  16.             <Grid.ColumnDefinitions>
  17.                 <ColumnDefinition></ColumnDefinition>
  18.                 <ColumnDefinition></ColumnDefinition>
  19.             </Grid.ColumnDefinitions>
  20.             <Label Grid.Column="0" VerticalAlignment="Center" HorizontalAlignment="Right" Content="当前鼠标在屏幕的位置："></Label>
  21.             <Grid Grid.Column="1" VerticalAlignment="Center" HorizontalAlignment="Left">
  22.                 <Grid.ColumnDefinitions>
  23.                     <ColumnDefinition></ColumnDefinition>
  24.                     <ColumnDefinition></ColumnDefinition>
  25.                 </Grid.ColumnDefinitions>
  26.                 <Grid Grid.Column="0">
  27.                     <Grid.ColumnDefinitions>
  28.                         <ColumnDefinition></ColumnDefinition>
  29.                         <ColumnDefinition></ColumnDefinition>
  30.                     </Grid.ColumnDefinitions>
  31.                     <Label  Content="X："></Label>
  32.                     <TextBlock x:Name="xPoint" Grid.Column="1" HorizontalAlignment="Center" VerticalAlignment="Center"></TextBlock>
  33.                 </Grid>
  34.                 <Grid Grid.Column="1">
  35.                     <Grid.ColumnDefinitions>
  36.                         <ColumnDefinition></ColumnDefinition>
  37.                         <ColumnDefinition></ColumnDefinition>
  38.                     </Grid.ColumnDefinitions>
  39.                     <Label  Content="Y："></Label>
  40.                     <TextBlock x:Name="yPoint" Grid.Column="1" HorizontalAlignment="Center" VerticalAlignment="Center"></TextBlock>
  41.                 </Grid>
  42.             </Grid>
  43.         </Grid>
  44.         <Grid Grid.Row="1">
  45.             <Grid.ColumnDefinitions>
  46.                 <ColumnDefinition></ColumnDefinition>
  47.                 <ColumnDefinition></ColumnDefinition>
  48.             </Grid.ColumnDefinitions>
  49.             <Grid Grid.Column="0">
  50.                 <Grid.ColumnDefinitions>
  51.                     <ColumnDefinition></ColumnDefinition>
  52.                     <ColumnDefinition></ColumnDefinition>
  53.                 </Grid.ColumnDefinitions>
  54.                 <Label Content="设置循环次数：" VerticalAlignment="Center" HorizontalAlignment="Right"></Label>
  55.                 <Border Grid.Column="1" Width="120" Height="35" BorderBrush="Black" HorizontalAlignment="Left" BorderThickness="1">
  56.                     <TextBox Width="120" Height="35" x:Name="txtCycleCount" Text="1" VerticalAlignment="Center" HorizontalAlignment="Center"></TextBox>
  57.                 </Border>
  58.             </Grid>
  59.             <Grid Grid.Column="2">
  60.                 <Grid.ColumnDefinitions>
  61.                     <ColumnDefinition></ColumnDefinition>
  62.                     <ColumnDefinition Width="320"></ColumnDefinition>
  63.                 </Grid.ColumnDefinitions>
  64.                 <Label Content="脚本路径：" VerticalAlignment="Center" HorizontalAlignment="Right"></Label>
  65.                 <Border Grid.Column="1" Width="310" Height="35" BorderBrush="Black" HorizontalAlignment="Left" BorderThickness="1">
  66.                     <TextBox Width="310" Height="35" x:Name="txtScriptPath" VerticalAlignment="Center" HorizontalAlignment="Center" TextWrapping="Wrap"></TextBox>
  67.                 </Border>
  68.             </Grid>
  69.         </Grid>
  70.         <Grid Grid.Row="2" Margin="0 30 0 0" VerticalAlignment="Top">
  71.             <Grid.ColumnDefinitions>
  72.                 <ColumnDefinition></ColumnDefinition>
  73.                 <ColumnDefinition></ColumnDefinition>
  74.                 <ColumnDefinition></ColumnDefinition>
  75.                 <ColumnDefinition></ColumnDefinition>
  76.             </Grid.ColumnDefinitions>
  77.             <Button Grid.Column="0" x:Name="btnStart" Width="100" Height="40" Content="开始录制" Click="Start_OnClick"></Button>
  78.             <Button Grid.Column="1" x:Name="btnEnd" Width="100" Height="40" Content="结束录制" Click="End_OnClick"></Button>
  79.             <Button Grid.Column="2" x:Name="btnExec" Width="100" Height="40" Content="执行脚本" Click="Exec_OnClick"></Button>
  80.             <Button Grid.Column="3" x:Name="btnCancel" Width="100" Height="40" Content="取消执行" Click="CancelExec_OnClick"></Button>
  81.         </Grid>
  82.     </Grid>
  83. </Window>
复制代码
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Configuration;
  4. using System.IO;
  5. using System.Linq;
  6. using System.Threading;
  7. using System.Threading.Tasks;
  8. using System.Windows;
  9. using Newtonsoft.Json;
  10. using Path = System.IO.Path;
  12. namespace AutoOperationTool
  13. {
  14.     /// <summary>
  15.     /// MainWindow.xaml 的交互逻辑
  16.     /// </summary>
  17.     public partial class MainWindow : Window
  18.     {
  19.         // 用于取消任务的执行
  20.         private CancellationTokenSource cancelTokenSource = new CancellationTokenSource();
  22.         private Task ExecTask { get; set; }
  24.         private KeyAction KeyAction { get; set; }
  26.         public MainWindow()
  27.         {
  28.             InitializeComponent();
  29.             Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
  30.             txtScriptPath.Text = config.AppSettings.Settings["path"].Value;
  31.             KeyAction = new KeyAction();
  32.             btnEnd.IsEnabled = false;
  33.             btnCancel.IsEnabled = false;
  34.         }
  36.         private bool KMHook_MouseCallback(object arg)
  37.         {
  38.             if (arg is long[] arrs && arrs.Length == 3)
  39.             {
  40.                 var type = arrs[0];
  41.                 var x = arrs[1];
  42.                 var y = arrs[2];
  43.                 if (type == 1)
  44.                 {
  45.                     var model = new MouseOperation();
  46.                     model.MouseOperationType = MouseOperationTypeEnum.Click;
  47.                     model.Point = new Point(){ X = x, Y = y};
  48.                     model.Time = DateTime.Now;
  49.                     model.OperationType = OperationType.Mouse;
  50.                     PrintLog.WriteTxt.GetInstance().AppendInfoLog(JsonConvert.SerializeObject(model));
  51.                 }
  53.                 xPoint.Text = x.ToString();
  54.                 yPoint.Text = y.ToString();
  55.                 Console.WriteLine($"X:{x};Y:{y}");
  56.             }
  58.             return true;
  59.         }
  61.         private bool KMHook_KeyCallback(object arg)
  62.         {
  63.             if (arg is long[] arrs && arrs.Length == 3)
  64.             {
  65.                 var type = arrs[0];
  66.                 var code = arrs[1];
  67.                 var time = arrs[2];
  68.                 var model = new KeyOperation();
  69.                 if (type == 0)
  70.                 {
  71.                     model.KeyOperationType = KeyOperationTypeEnum.Press;
  72.                 }
  73.                 else if (type == 1)
  74.                 {
  75.                     model.KeyOperationType = KeyOperationTypeEnum.Up;
  76.                 }
  78.                 model.KeyCode = (Key)Enum.Parse(typeof(Key), code.ToString());
  79.                 model.OperationType = OperationType.Key;
  80.                 model.Time = DateTime.Now;
  81.                 PrintLog.WriteTxt.GetInstance().AppendInfoLog(JsonConvert.SerializeObject(model));
  82.             }
  84.             return true;
  85.         }
  87.         private void Start_OnClick(object sender, RoutedEventArgs e)
  88.         {
  89.             btnEnd.IsEnabled = true;
  90.             btnStart.IsEnabled = false;
  91.             btnExec.IsEnabled = false;
  92.             btnCancel.IsEnabled = false;
  94.             // 如果存在脚本名称，序号往前加
  95.             PrintLog.WriteTxt.GetInstance().FileLogName = "script1.txt";
  96.             var fileLogName = PrintLog.WriteTxt.GetInstance().FileLogName;
  97.             if (File.Exists(PrintLog.WriteTxt.GetInstance().FileStartupPath + PrintLog.WriteTxt.GetInstance().FileLogName))
  98.             {
  99.                 var fileName = PrintLog.WriteTxt.GetInstance().FileLogName;
  100.                 while (File.Exists(PrintLog.WriteTxt.GetInstance().FileStartupPath + fileName))
  101.                 {
  102.                     if (fileName.StartsWith("script") && fileName.EndsWith(".txt"))
  103.                     {
  104.                         var strCount = fileName.Replace("script", "").Replace(".txt", "");
  105.                         int count;
  106.                         if (int.TryParse(strCount, out count))
  107.                         {
  108.                             count++;
  109.                             fileName = $"script{count}.txt";
  110.                         }
  111.                     }
  112.                     else
  113.                     {
  114.                         Directory.Delete(PrintLog.WriteTxt.GetInstance().FileStartupPath + PrintLog.WriteTxt.GetInstance().FileLogName);
  115.                         break;
  116.                     }
  117.                 }
  119.                 fileLogName = fileName;
  120.             }
  122.             PrintLog.WriteTxt.GetInstance().FileLogName = fileLogName;
  123.             txtScriptPath.Text = Path.Combine(PrintLog.WriteTxt.GetInstance().FileStartupPath, fileLogName);
  124.             Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
  125.             config.AppSettings.Settings["path"].Value = txtScriptPath.Text;
  126.             config.Save();
  127.             KMHook.MouseCallback += KMHook_MouseCallback;
  128.             KMHook.KeyCallback += KMHook_KeyCallback;
  129.             KMHook.InsertHook();
  130.         }
  132.         private void End_OnClick(object sender, RoutedEventArgs e)
  133.         {
  134.             KMHook.MouseCallback -= KMHook_MouseCallback;
  135.             KMHook.KeyCallback -= KMHook_KeyCallback;
  136.             KMHook.RemoveHook();
  137.             btnStart.IsEnabled = true;
  138.             btnEnd.IsEnabled = !btnStart.IsEnabled;
  139.             btnExec.IsEnabled = true;
  140.             btnCancel.IsEnabled = !btnExec.IsEnabled;
  141.         }
  143.         private void Exec_OnClick(object sender, RoutedEventArgs e)
  144.         {
  145.             btnStart.IsEnabled = false;
  146.             btnEnd.IsEnabled = !btnStart.IsEnabled;
  147.             btnExec.IsEnabled = false;
  148.             btnCancel.IsEnabled = !btnExec.IsEnabled;
  149.             var listOperations = new List<Operation>();
  150.             var path = txtScriptPath.Text;
  151.             var listStrs = File.ReadLines(path)?.ToList();
  152.             if (listStrs != null && listStrs.Count > 0)
  153.             {
  154.                 foreach (var strScript in listStrs)
  155.                 {
  156.                     try
  157.                     {
  158.                         var operation = JsonConvert.DeserializeObject<Operation>(strScript);
  159.                         if (operation.OperationType == OperationType.Mouse)
  160.                         {
  161.                             var mouseOperation = JsonConvert.DeserializeObject<MouseOperation>(strScript);
  162.                             listOperations.Add(mouseOperation);
  163.                         }
  164.                         else if (operation.OperationType == OperationType.Key)
  165.                         {
  166.                             var keyOperation = JsonConvert.DeserializeObject<KeyOperation>(strScript);
  167.                             listOperations.Add(keyOperation);
  168.                         }
  169.                     }
  170.                     catch (Exception ex)
  171.                     {
  172.                         throw ex;
  173.                     }
  174.                 }
  175.             }
  177.             int count;
  178.             if (int.TryParse(txtCycleCount.Text, out count))
  179.             {
  180.                 ExecTask = Task.Factory.StartNew(() =>
  181.                 {
  182.                     if (count < 1) count = 1;
  183.                     for (int i = 0; i < count; i++)
  184.                     {
  185.                         DateTime lastTime = new DateTime();
  186.                         DateTime nextTime = new DateTime();
  187.                         for (int j = 0; j < listOperations.Count; j++)
  188.                         {
  189.                             if (lastTime == new DateTime())
  190.                             {
  191.                                 lastTime = listOperations[j].Time;
  193.                                 Exec(listOperations, j);
  194.                             }
  195.                             else
  196.                             {
  197.                                 nextTime = listOperations[j].Time;
  198.                                 if (j > 0)
  199.                                 {
  200.                                     lastTime = listOperations[j - 1].Time;
  201.                                 }
  203.                                 Thread.Sleep(nextTime - lastTime);
  204.                                 Exec(listOperations, j);
  205.                             }
  206.                         }
  208.                         Thread.Sleep(1000);
  209.                     }
  211.                     Application.Current.Dispatcher.Invoke(() =>
  212.                     {
  213.                         btnStart.IsEnabled = true;
  214.                         btnEnd.IsEnabled = !btnStart.IsEnabled;
  215.                         btnExec.IsEnabled = true;
  216.                         btnCancel.IsEnabled = !btnExec.IsEnabled;
  217.                     });
  218.                 }, cancelTokenSource.Token);
  219.             }
  220.         }
  222.         private void Exec(List<Operation> listOperations, int j)
  223.         {
  224.             if (listOperations[j].OperationType == OperationType.Mouse)
  225.             {
  226.                 var mouse = listOperations[j] as MouseOperation;
  227.                 MouseAction.DoClick((int)mouse.Point.X, (int)mouse.Point.Y);
  228.             }
  229.             else if (listOperations[j].OperationType == OperationType.Key)
  230.             {
  231.                 var key = listOperations[j] as KeyOperation;
  232.                 if (key.KeyOperationType == KeyOperationTypeEnum.Press)
  233.                 {
  234.                     KeyAction.MykeyDown(key.KeyCode);
  235.                 }
  236.                 else if (key.KeyOperationType == KeyOperationTypeEnum.Up)
  237.                 {
  238.                     KeyAction.MykeyUp(key.KeyCode);
  239.                 }
  240.             }
  241.         }
  243.         private void CancelExec_OnClick(object sender, RoutedEventArgs e)
  244.         {
  245.             if (ExecTask != null)
  246.             {
  247.                 for (int i = 0; i < 3; i++)
  248.                 {
  249.                     try
  250.                     {
  251.                         cancelTokenSource.Cancel();
  252.                         if (cancelTokenSource.IsCancellationRequested)
  253.                         {
  254.                             cancelTokenSource = new CancellationTokenSource();
  255.                             ExecTask.Dispose();
  256.                             btnStart.IsEnabled = true;
  257.                             btnEnd.IsEnabled = !btnStart.IsEnabled;
  258.                             btnExec.IsEnabled = true;
  259.                             btnCancel.IsEnabled = !btnExec.IsEnabled;
  260.                             break;
  261.                         }
  262.                     }
  263.                     catch (Exception)
  264.                     {
  265.                     }
  266.                 }
  267.             }
  268.         }
  269.     }
  270. }
复制代码
勾子监听键盘鼠标事件
  1. using System;
  2. using System.Runtime.InteropServices;
  4. namespace AutoOperationTool
  5. {
  6.     public class KMHook
  7.     {
  8.         public static bool InsertHook()
  9.         {
  10.             bool iRet;
  11.             iRet = InsertKeyboardHook();
  12.             if (!iRet)
  13.             {
  14.                 return false;
  15.             }
  17.             iRet = InsertMouseHook();
  18.             if (!iRet)
  19.             {
  20.                 removeKeyboardHook();
  21.                 return false;
  22.             }
  24.             return true;
  25.         }
  27.         public static bool RemoveHook()
  28.         {
  29.             bool iRet;
  30.             iRet = removeKeyboardHook();
  31.             if (iRet)
  32.             {
  33.                 iRet = removeMouseHook();
  34.             }
  36.             return iRet;
  37.         }
  39.         public static event Func<object, bool> MouseCallback;
  40.         public static event Func<object, bool> KeyCallback;
  42.         internal struct Keyboard_LL_Hook_Data
  43.         {
  44.             public UInt32 vkCode;
  45.             public UInt32 scanCode;
  46.             public UInt32 flags;
  47.             public UInt32 time;
  48.             public IntPtr extraInfo;
  49.         }
  51.         internal struct Mouse_LL_Hook_Data
  52.         {
  53.             internal long yx;
  54.             internal readonly int mouseData;
  55.             internal readonly uint flags;
  56.             internal readonly uint time;
  57.             internal readonly IntPtr dwExtraInfo;
  58.         }
  60.         private static IntPtr pKeyboardHook = IntPtr.Zero;
  61.         private static IntPtr pMouseHook = IntPtr.Zero;
  62.         //钩子委托声明
  63.         public delegate int HookProc(int code, IntPtr wParam, IntPtr lParam);
  64.         private static HookProc keyboardHookProc;
  65.         private static HookProc mouseHookProc;
  67.         //安装钩子
  68.         [DllImport("user32.dll")]
  69.         public static extern IntPtr SetWindowsHookEx(int idHook, HookProc lpfn, IntPtr pInstance, int threadID);
  71.         //卸载钩子
  72.         [DllImport("user32.dll", CallingConvention = CallingConvention.StdCall)]
  73.         public static extern bool UnhookWindowsHookEx(IntPtr pHookHandle);
  74.         [DllImport("user32.dll")]
  75.         public static extern int CallNextHookEx(IntPtr hhk, int nCode, IntPtr wParam, IntPtr lParam); //parameter 'hhk' is ignored.
  77.         private static int keyboardHookCallback(int code, IntPtr wParam, IntPtr lParam)
  78.         {
  79.             if (code < 0)
  80.             {
  81.                 return CallNextHookEx(IntPtr.Zero, code, wParam, lParam);
  82.             }
  84.             Keyboard_LL_Hook_Data khd = (Keyboard_LL_Hook_Data)Marshal.PtrToStructure(lParam, typeof(Keyboard_LL_Hook_Data));
  85.             System.Diagnostics.Debug.WriteLine($"key event:{wParam}, key code:{khd.vkCode}, event time:{khd.time}");
  87.             var keyType = 0L;
  88.             var iWParam = (int)wParam;
  89.             if (iWParam == 256)
  90.             {
  91.                 keyType = 0;
  92.             }
  93.             else if (iWParam == 257)
  94.             {
  95.                 keyType = 1;
  96.             }
  97.             else
  98.             {
  99.                 keyType = 0;
  100.             }
  101.             KeyCallback?.Invoke(new long[3] { keyType, (int)khd.vkCode, (int)khd.time });
  102.             return 0;
  103.         }
  105.         private static int mouseHookCallback(int code, IntPtr wParam, IntPtr lParam)
  106.         {
  107.             if (code < 0)
  108.             {
  109.                 return CallNextHookEx(IntPtr.Zero, code, wParam, lParam);
  110.             }
  112.             Mouse_LL_Hook_Data mhd = (Mouse_LL_Hook_Data)Marshal.PtrToStructure(lParam, typeof(Mouse_LL_Hook_Data));
  113.             System.Diagnostics.Debug.WriteLine($"mouse event:{wParam}, ({mhd.yx & 0xffffffff},{mhd.yx >> 32})");
  114.             var mouseType = 0L;
  115.             var iWParam = (int)wParam;
  116.             if (iWParam == 513)
  117.             {
  118.                 mouseType = 1;
  119.             }
  120.             else if (iWParam == 514)
  121.             {
  122.                 mouseType = 2;
  123.             }
  124.             else
  125.             {
  126.                 mouseType = 0;
  127.             }
  129.             MouseCallback?.Invoke(new long[3]{ mouseType , mhd.yx & 0xffffffff, mhd.yx >> 32 });
  130.             return 0;
  131.         }
  133.         //安装钩子方法
  134.         private static bool InsertKeyboardHook()
  135.         {
  136.             if (pKeyboardHook == IntPtr.Zero)//不存在钩子时
  137.             {
  138.                 //创建钩子
  139.                 keyboardHookProc = keyboardHookCallback;
  140.                 pKeyboardHook = SetWindowsHookEx(13, //13表示全局键盘事件。
  141.                     keyboardHookProc,
  142.                     (IntPtr)0,
  143.                     0);
  145.                 if (pKeyboardHook == IntPtr.Zero)//如果安装钩子失败
  146.                 {
  147.                     removeKeyboardHook();
  148.                     return false;
  149.                 }
  150.             }
  152.             return true;
  153.         }
  155.         private static bool InsertMouseHook()
  156.         {
  157.             if (pMouseHook == IntPtr.Zero)
  158.             {
  159.                 mouseHookProc = mouseHookCallback;
  160.                 pMouseHook = SetWindowsHookEx(14, //14表示全局鼠标事件
  161.                     mouseHookProc,
  162.                     (IntPtr)0,
  163.                     0);
  165.                 if (pMouseHook == IntPtr.Zero)
  166.                 {
  167.                     removeMouseHook();
  168.                     return false;
  169.                 }
  170.             }
  172.             return true;
  173.         }
  175.         private static bool removeKeyboardHook()
  176.         {
  177.             if (pKeyboardHook != IntPtr.Zero)
  178.             {
  179.                 if (UnhookWindowsHookEx(pKeyboardHook))
  180.                 {
  181.                     pKeyboardHook = IntPtr.Zero;
  182.                 }
  183.                 else
  184.                 {
  185.                     return false;
  186.                 }
  187.             }
  189.             return true;
  190.         }
  192.         private static bool removeMouseHook()
  193.         {
  194.             if (pMouseHook != IntPtr.Zero)
  195.             {
  196.                 if (UnhookWindowsHookEx(pMouseHook))
  197.                 {
  198.                     pMouseHook = IntPtr.Zero;
  199.                 }
  200.                 else
  201.                 {
  202.                     return false;
  203.                 }
  204.             }
  206.             return true;
  207.         }
  208.     }
  209. }
复制代码
操作键盘按键
  1. using System;
  2. using System.Runtime.InteropServices;
  4. namespace AutoOperationTool
  5. {
  6.     public class KeyAction
  7.     {
  8.         [DllImport("user32.dll", SetLastError = true)]
  9.         public static extern void keybd_event(byte bVk, byte bScan, uint dwFlags, UIntPtr dwExtraInfo);
  11.         /// key down
  12.         public void MykeyDown(Key vKeyCoad)
  13.         {
  14.             PressKey(vKeyCoad, false);
  15.         }
  17.         /// Key up
  18.         public void MykeyUp(Key vKeyCoad)
  19.         {
  20.             PressKey(vKeyCoad, true);
  21.         }
  23.         private void PressKey(Key key, bool up)
  24.         {
  25.             const int KEYEVENTF_EXTENDEDKEY = 0x1;
  26.             const int KEYEVENTF_KEYUP = 0x2;
  27.             if (up)
  28.             {
  29.                 keybd_event((byte)key, 0x45, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, (UIntPtr)0);
  30.             }
  31.             else
  32.             {
  33.                 keybd_event((byte)key, 0x45, KEYEVENTF_EXTENDEDKEY, (UIntPtr)0);
  34.             }
  35.         }
  36.     }
  37. }
复制代码
操作鼠标移动及单击
  1. using System.Runtime.InteropServices;
  3. namespace AutoOperationTool
  4. {
  5.     public class MouseAction
  6.     {
  7.         [DllImport("user32")]
  8.         public static extern int mouse_event(int dwFlags, int dx, int dy, int cButtons, int dwExtraInfo);
  10.         [DllImport("User32.dll")]
  11.         public static extern bool SetCursorPos(int X, int Y);
  13.         public static void DoClick(int x, int y)
  14.         {
  15.             SetCursorPos(x, y);
  16.             mouse_event((int)MouseType.MOUSEEVENTF_LEFTDOWN | (int)MouseType.MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
  17.         }
  18.     }
  19. }
复制代码
 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

欢乐狗

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

存储 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表