c# 获取当前活动窗口句柄,获取窗口大小及位置

时间 2020-09-20

标签 c# 获取当前活动窗口句柄大小位置栏目 C# 繁體版

原文原文链接

需调用API函数html

需在开头引入命名空间
using System.Runtime.InteropServices;数据库

获取当前窗口句柄:GetForegroundWindow()windows

[DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
public static extern IntPtr GetForegroundWindow();api

返回值类型是IntPtr,即为当前得到焦点窗口的句柄安全

使用方法 : IntPtr myPtr=GetForegroundWindow();app

获取到该窗口句柄后,能够对该窗口进行操做.好比,关闭该窗口或在该窗口隐藏后,使其显示函数

[DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
public static extern int ShowWindow(IntPtr hwnd, int nCmdShow);工具

其中ShowWindow(IntPtr hwnd, int nCmdShow);学习

nCmdShow的含义ui

0 关闭窗口

1 正常大小显示窗口

2 最小化窗口

3 最大化窗口

使用实例: ShowWindow(myPtr, 0);

获取窗口大小及位置:须要调用方法GetWindowRect(IntPtr hWnd, ref RECT lpRect)

        [DllImport("user32.dll")]
        [return: MarshalAs(UnmanagedType.Bool)]
        static extern bool GetWindowRect(IntPtr hWnd, ref RECT lpRect);

        [StructLayout(LayoutKind.Sequential)]
        public struct RECT
        {
            public int Left;                             //最左坐标
            public int Top;                             //最上坐标
            public int Right;                           //最右坐标
            public int Bottom;                        //最下坐标
        }

示例:

                    InPtr awin = GetForegroundWindow();    //获取当前窗口句柄
                    RECT rect = new RECT();
                    GetWindowRect(awin, ref rect);
                   int width = rc.Right - rc.Left;                        //窗口的宽度
                   int height = rc.Bottom - rc.Top;                   //窗口的高度
                    int x = rc.Left;
                    int y = rc.Top;

------------------------------------------------------------------------

C#中的FindWindow
  [System.Runtime.InteropServices.DllImport("user32.dll", EntryPoint="FindWindow")]
  public static extern int FindWindow (
            string lpClassName,
            string lpWindowName
           );
已知窗口标题"abc",怎么获得窗口句柄?

IntPtr hWnd = FindWindow(null, "abc");

-------------------------------------------------------

C#使用FindWindow()函数：

            [DllImport("coredll.dll", EntryPoint = "FindWindow")]
            private extern static IntPtr FindWindow(string lpClassName, string lpWindowName);
        这个函数有两个参数，第一个是要找的窗口的类，第二个是要找的窗口的标题。在搜索的时候不必定二者都知道，但至少要知道其中的一个。有的窗口的标题是比较容易获得的，如"计算器"，因此搜索时应使用标题进行搜索。但有的软件的标题不是固定的，如"记事本"，若是打开的文件不一样，窗口标题也不一样，这时使用窗口类搜索就比较方便。若是找到了知足条件的窗口，这个函数返回该窗口的句柄，不然返回0。看例子

IntPtr ParenthWnd = new IntPtr(0);

            ParenthWnd = FindWindow(null,"Word Mobile");
            //判断这个窗体是否有效
            if (ParenthWnd != IntPtr.Zero)
            {
                MessageBox.Show("找到窗口");
            }

else

MessageBox.Show("没有找到窗口");

从上面的讨论中能够看出，若是要搜索的外部程序的窗口标题比较容易获得，问题是比较简单的。可若是窗口的标题不固定或者根本就没有标题，怎么获得窗口的类呢？若是你安装了Visual C++，你可使用其中的Spy，在Spy++中有一个FindWindow工具，它容许你使用鼠标选择窗口，而后Spy++会显示这个窗口的类。
在Win32 API中还有一个FindWindowEx，它很是适合寻找子窗口。

FindWindowEx用法
函数功能：该函数得到一个窗口的句柄，该窗口的类名和窗口名与给定的字符串相匹配。这个函数查找子窗口，从排在给定的子窗口后面的下一个子窗口开始。在查找时不区分大小写。

函数原型：HWND FindWindowEx（HWND hwndParent，HWND hwndChildAfter，LPCTSTR lpszClass，LPCTSTR lpszWindow）；

参数：

hwndParent：要查找子窗口的父窗口句柄。

若是hwnjParent为NULL，则函数以桌面窗口为父窗口，查找桌面窗口的全部子窗口。

Windows NT5.0 and later：若是hwndParent是HWND_MESSAGE，函数仅查找全部消息窗口。

hwndChildAfter ：子窗口句柄。查找从在Z序中的下一个子窗口开始。子窗口必须为hwndPareRt窗口的直接子窗口而非后代窗口。若是HwndChildAfter为NULL，查找从hwndParent的第一个子窗口开始。若是hwndParent 和 hwndChildAfter同时为NULL，则函数查找全部的顶层窗口及消息窗口。

lpszClass：指向一个指定了类名的空结束字符串，或一个标识类名字符串的成员的指针。若是该参数为一个成员，则它必须为前次调用theGlobaIAddAtom函数产生的全局成员。该成员为16位，必须位于lpClassName的低16位，高位必须为0。

lpszWindow：指向一个指定了窗口名（窗口标题）的空结束字符串。若是该参数为 NULL，则为全部窗口全匹配。返回值：若是函数成功，返回值为具备指定类名和窗口名的窗口句柄。若是函数失败，返回值为NULL。

C#中使用该函数首先导入命名空间：

01.using System.Runtime.InteropServices;

而后写API引用部分的代码，放入 class 内部

01.[DllImport("user32.dll", EntryPoint = "FindWindow")]
02.private static extern IntPtr FindWindowEx( IntPtr hwndParent, IntPtr hwndChildAfter, string lpszClass, string lpszWindow )

例如：

01.const int BM_CLICK = 0xF5;
02.IntPtr maindHwnd = FindWindow(null, "QQ用户登陆"); //得到QQ登录框的句柄
03.if (maindHwnd != IntPtr.Zero)
04.{
05.    IntPtr childHwnd = FindWindowEx(maindHwnd, IntPtr.Zero, null, "登陆");   //得到按钮的句柄
06.    if (childHwnd != IntPtr.Zero)
07.    {
08.        SendMessage(childHwnd, BM_CLICK, 0, 0);     //发送点击按钮的消息
09.    }
10.    else
11.    {
12.        MessageBox.Show("没有找到子窗口");
13.    }
14.}
15.else
16.{
17.    MessageBox.Show("没有找到窗口");
18.}

今后学习网 http://item.congci.com/item/findwindowfindwindowex

---------------------------------------------------------------------------------------

DllImport("user32", SetLastError = true)]
public static extern int GetWindowText(
    IntPtr hWnd,//窗口句柄
    StringBuilder lpString,//标题
    int nMaxCount //最大值
    );

//获取类的名字
[DllImport("user32.dll")]
private static extern int GetClassName(
    IntPtr hWnd,//句柄
    StringBuilder lpString, //类名
    int nMaxCount //最大值
    );

//根据坐标获取窗口句柄
[DllImport("user32")]
private static extern IntPtr WindowFromPoint(
Point Point //坐标
);

private void timer1_Tick(object sender, EventArgs e)
{
    int x = Cursor.Position.X;
    int y = Cursor.Position.Y;
    Point p = new Point(x, y);
    IntPtr formHandle = WindowFromPoint(p);//获得窗口句柄
    StringBuilder title = new StringBuilder(256);
    GetWindowText(formHandle, title, title.Capacity);//获得窗口的标题
    StringBuilder className = new StringBuilder(256);
    GetClassName(formHandle, className, className.Capacity);//获得窗口的句柄
    this.textBox1.Text = title.ToString();
    this.textBox2.Text = formHandle.ToString();
    this.textBox3.Text = className.ToString();
}

--------------------------------------

文章不错，收藏备用。

设计初衷：
　　公司为了安全性考虑，不让密码被太多人知道，因此想实现一个自动登陆的模块。

设计思想：
　　主要是经过调用Windows API中的一些方法，找到目标窗口和进程以后把保存在数据库中的用户名密码自动填入输入框中，并登陆。

设计步骤：
1、调用Windows API。
　C#下调用Windows API方法以下：
　一、引入命名空间：using System.Runtime.InteropServices;
　二、引用须要使用的方法，格式：[DllImport("DLL文件")]方法的声明;
　[DllImport("user32.dll")]private static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);
　[DllImport("user32.dll")]private static extern bool SetForegroundWindow(IntPtr hWnd);
　[DllImport("user32.dll")]private static extern IntPtr FindWindow(string lpClassName,string lpWindowName);
　[DllImport("user32.dll")]private static extern int SendMessage(IntPtr hWnd,int Msg,int wParam,int lParam);
　[DllImport("user32.dll")]private static extern bool SetCursorPos(int X, int Y);
　[DllImport("user32.dll")]private static extern void mouse_event(int dwFlags, int dx, int dy, int dwData, int dwExtraInfo);
　[DllImport("user32.dll")]private static extern void keybd_event(byte bVk, byte bScan, uint dwFlags, uint dwExtraInfo);
　 [DllImport("user32.dll")]private static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndlnsertAfter, int X, int Y, int cx, int cy, uint Flags);
　//ShowWindow参数
　private const int SW_SHOWNORMAL = 1;
　private const int SW_RESTORE = 9;
　private const int SW_SHOWNOACTIVATE = 4;
　//SendMessage参数
　private const int WM_KEYDOWN = 0X100;
　private const int WM_KEYUP = 0X101;
　private const int WM_SYSCHAR = 0X106;
　private const int WM_SYSKEYUP = 0X105;
　private const int WM_SYSKEYDOWN = 0X104;
　private const int WM_CHAR = 0X102;

2、找到目标窗口
1)、根据窗口的标题获得句柄
　IntPtr myIntPtr = FindWindow(null,"窗口名"); //null为类名，能够用Spy++获得，也能够为空
　ShowWindow(myIntPtr, SW_RESTORE); //将窗口还原
　SetForegroundWindow(myIntPtr); //若是没有ShowWindow，此方法不能设置最小化的窗口
2)、遍历全部窗口获得句柄
1 定义委托方法CallBack，枚举窗口API（EnumWindows），获得窗口名API（GetWindowTextW）和获得窗口类名API（GetClassNameW）
　public delegate bool CallBack(int hwnd, int lParam);
　[DllImport("user32")]public static extern int EnumWindows(CallBack x, int y);
　 [DllImport("user32.dll")]private static extern int GetWindowTextW(IntPtr hWnd, [MarshalAs(UnmanagedType.LPWStr)]StringBuilder lpString, int nMaxCount);
　[DllImport("user32.dll")]private static extern int GetClassNameW(IntPtr hWnd, [MarshalAs(UnmanagedType.LPWStr)]StringBuilder lpString, int nMaxCount);
2 调用EnumWindows遍历窗口
　CallBack myCallBack = new CallBack(Recall);
　EnumWindows(myCallBack, 0);
3 回调方法Recall
　public bool Recall(int hwnd, int lParam)
　{
　　StringBuilder sb = new StringBuilder(256);
　　IntPtr PW = new IntPtr(hwnd);

　　GetWindowTextW(PW,sb,sb.Capacity); //获得窗口名并保存在strName中
　　string strName = sb.ToString();

　　GetClassNameW(PW,sb,sb.Capacity); //获得窗口类名并保存在strClass中
　　string strClass = sb.ToString();

　　if (strName.IndexOf("窗口名关键字") >= 0 && strClass.IndexOf("类名关键字") >= 0)
　　{
　　　return false; //返回false停止EnumWindows遍历
　　}
　　else
　　{
　　　return true; //返回true继续EnumWindows遍历
　　}
　}
3)、打开窗口获得句柄
1 定义设置活动窗口API（SetActiveWindow），设置前台窗口API（SetForegroundWindow）
　[DllImport("user32.dll")]static extern IntPtr SetActiveWindow(IntPtr hWnd);
　[DllImport("user32.dll")][return: MarshalAs(UnmanagedType.Bool)]static extern bool SetForegroundWindow(IntPtr hWnd);
2 打开窗口
　Process proc = Process.Start(@"目标程序路径");
　SetActiveWindow(proc.MainWindowHandle);
　SetForegroundWindow(proc.MainWindowHandle);

3、向指定的窗口输入数据
1 利用发送消息API（SendMessage）向窗口发送数据
　InputStr(myIntPtr, _GameID); //输入游戏ID
　SendMessage(myIntPtr, WM_SYSKEYDOWN, 0X09, 0); //输入TAB（0x09）
　SendMessage(myIntPtr, WM_SYSKEYUP, 0X09, 0);
　InputStr(myIntPtr, _GamePass); //输入游戏密码
　SendMessage(myIntPtr, WM_SYSKEYDOWN, 0X0D, 0); //输入ENTER（0x0d）
　SendMessage(myIntPtr, WM_SYSKEYUP, 0X0D, 0);

　/// <summary>
　/// 发送一个字符串
　/// </summary>
　/// <param name="myIntPtr">窗口句柄</param>
　/// <param name="Input">字符串</param>
　public void InputStr(IntPtr myIntPtr, string Input)
　{
　　byte[] ch = (ASCIIEncoding.ASCII.GetBytes(Input));
　　for (int i = 0; i < ch.Length; i++)
　　{
　　　SendMessage(PW, WM_CHAR, ch, 0);
　　}
　}
2 利用鼠标和键盘模拟向窗口发送数据
　SetWindowPos(PW, (IntPtr)(-1), 0, 0, 0, 0, 0x0040 | 0x0001); //设置窗口位置
　SetCursorPos(476, 177); //设置鼠标位置
　mouse_event(0x0002, 0, 0, 0, 0); //模拟鼠标按下操做
　mouse_event(0x0004, 0, 0, 0, 0); //模拟鼠标放开操做
　SendKeys.Send(_GameID); //模拟键盘输入游戏ID
　SendKeys.Send("{TAB}"); //模拟键盘输入TAB
　SendKeys.Send(_GamePass); //模拟键盘输入游戏密码
　SendKeys.Send("{ENTER}"); //模拟键盘输入ENTER

另：上面还提到了keybd_event方法，用法和mouse_event方法相似，做用和SendKeys.Send同样。

C# 别人软件里边作好的文本框,我如何给他赋值而且提交，最好有源码可供参考，若有合适的，将高额追加分
能够用WINDOWS api函数实现。
下面的WINDIWS API引用部分的代码，放入 class 内部

[DllImport ( "user32.dll", EntryPoint = "FindWindow", SetLastError = true )]
private static extern IntPtr FindWindow( string lpClassName, string lpWindowName );//查找窗口句柄
[DllImport ( "user32.dll", EntryPoint = "FindWindowEx", SetLastError = true )]
private static extern IntPtr FindWindowEx( IntPtr hwndParent, uint hwndChildAfter, string lpszClass, string lpszWindow );//查找窗口内控件句柄
[DllImport ( "user32.dll", EntryPoint = "SendMessage", SetLastError = true, CharSet = CharSet.Auto )]
private static extern int SendMessage( IntPtr hwnd, uint wMsg, int wParam, int lParam );//发送消息
[DllImport ( "user32.dll", EntryPoint = "SetForegroundWindow", SetLastError = true )]
private static extern void SetForegroundWindow( IntPtr hwnd );// 设置窗口为激活状态

哈哈，如今能够开工了。我就用QQ的自动登陆为列子
下面是你winfrom窗口的按钮事件：
private void button1_Click( object sender, EventArgs e )
{
const uint WM_SETTEXT = 0x000C;//设置文本框内容的消息
const uint BM_CLICK = 0xF5; //鼠标点击的消息，对于各类消息的数值，你仍是得去查查API手册
IntPtr hwndCalc = FindWindow ( null, "QQ2011" ); //查找QQ2011的窗口句柄
if ( hwndCalc != IntPtr.Zero )//找到啦
{
IntPtr hwndLogin= FindWindowEx ( hwndCalc, 0, null, "安全登陆" ); //获取登录按钮的句柄
IntPtr hwndQ = FindWindowEx ( hwndCalc, 0, “ComboBox”, "" ); //获取QQ号码输入框的控件句柄
IntPtr hwndP = FindWindowEx ( hwndCalc, 0,"Edit", “” ); //获取密码输入框的控件句柄 SetForegroundWindow ( hwndCalc );    //将QQ窗口设置为激活
System.Threading.Thread.Sleep ( 1000 );   //暂停1秒让你看到效果
SendMessage ( hwndQ, WM_SETTEXT, TextBox1.Text, 0 );//发送文本框1里面的内容（QQ号啦）
System.Threading.Thread.Sleep ( 1000 );   //暂停1秒让你看到效果
SendMessage( hwndP, WM_SETTEXT, TextBox2.Text, 0 );//发送文本框2里面的内容（QQpassword）

System.Threading.Thread.Sleep ( 1000);   //暂停1秒让你看到效果
SendMessage ( hwndLogin, BM_CLICK, 0, 0 );//点击登陆
}
else
{
MessageBox.Show ("没有启动 [QQ2011]");
}
}

---------------------------------------------------

C#查找指定窗口的子窗口的句柄

2009年更新
经过实验得知，FindWindowEx能够经过classname或caption（也就是窗口的title）查找窗口，且若是第一个参数传IntPtr.Zero的话，将从Windows最顶层窗口开始查找，可是窗口不少的话这样会很是的慢，因此加入Timeout的判断，若是超时还没找到，返回false。

用法：FindWindow fw = new FindWindow(IntPtr.Zero, null, "ThunderDFrame", 10);//查找Title为ThunderDFrame的窗口，若是10秒内还没找到，返回false

代码以下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;

namespace Util
{
    class FindWindow
    {
        [DllImport("user32")]
        [return: MarshalAs(UnmanagedType.Bool)]
        //IMPORTANT : LPARAM  must be a pointer (InterPtr) in VS2005, otherwise an exception will be thrown
        private static extern bool EnumChildWindows(IntPtr window, EnumWindowProc callback, IntPtr i);
        //the callback function for the EnumChildWindows
        private delegate bool EnumWindowProc(IntPtr hWnd, IntPtr parameter);

        //if found  return the handle , otherwise return IntPtr.Zero
        [DllImport("user32.dll", EntryPoint = "FindWindowEx")]
        private static extern IntPtr FindWindowEx(IntPtr hwndParent, IntPtr hwndChildAfter, string lpszClass, string lpszWindow);

        private string m_classname; // class name to look for
        private string m_caption; // caption name to look for

        private DateTime start;
        private int m_timeout;//If exceed the time. Indicate no windows found.

        private IntPtr m_hWnd; // HWND if found
        public IntPtr FoundHandle
        {
            get { return m_hWnd; }
        }

        private bool m_IsTimeOut;
        public bool IsTimeOut
        {
            get{return m_IsTimeOut;}
            set { m_IsTimeOut = value; }
        }

        // ctor does the work--just instantiate and go
        public FindWindow(IntPtr hwndParent, string classname, string caption, int timeout)
        {
            m_hWnd = IntPtr.Zero;
            m_classname = classname;
            m_caption = caption;
            m_timeout = timeout;
            start = DateTime.Now;
            FindChildClassHwnd(hwndParent, IntPtr.Zero);
        }

        /**/
        /// <summary>
        /// Find the child window, if found m_classname will be assigned 
        /// </summary>
        /// <param name="hwndParent">parent's handle</param>
        /// <param name="lParam">the application value, nonuse</param>
        /// <returns>found or not found</returns>
        //The C++ code is that  lParam is the instance of FindWindow class , if found assign the instance's m_hWnd
        private bool FindChildClassHwnd(IntPtr hwndParent, IntPtr lParam)
        {
            EnumWindowProc childProc = new EnumWindowProc(FindChildClassHwnd);
            IntPtr hwnd = FindWindowEx(hwndParent, IntPtr.Zero, m_classname, m_caption);
            if (hwnd != IntPtr.Zero)
            {
                this.m_hWnd = hwnd; // found: save it
                m_IsTimeOut = false;
                return false; // stop enumerating
            }

            DateTime end = DateTime.Now;

            if (start.AddSeconds(m_timeout) < end)
            {
                m_IsTimeOut = true;
                return false;
            }

            EnumChildWindows(hwndParent, childProc, IntPtr.Zero); // recurse  redo FindChildClassHwnd
            return true;// keep looking
        }

出处：https://blog.csdn.net/pangwenquan5/article/details/40317773