C# 捕获所有Windows消息

我想利用机器学习来模拟用户的意图，并可能自动执行通常执行的任务。要做到这一点，我想有一个消防水管的信息有关用户的行动和机器状态。为此，我目前的想法是，访问windows消息流可能是前进的方向

我希望获得尽可能多的信息，将信息过滤到我希望留给机器学习工具的相关信息

这将如何实现？（最好用C#）

请假设我知道如何管理和使用大量涌入的数据

任何帮助都将不胜感激。

您可以使用设置低级挂钩来捕获（特定）windows消息。 具体来说，这些钩子ID对于监视可能很有意义：

WH_CALLWNDPROC

（4）安装一个监视消息的钩子过程 在系统将它们发送到目标窗口程序之前。对于 更多信息，请参阅CallWndProc钩子过程

WH_CALLWNDPROCRET

（12）安装一个钩子过程来监视 由目标窗口处理后的消息 程序有关更多信息，请参阅CallWndRetProc挂钩 程序

我已经有一段时间没有实现它了，但是作为一个例子，我已经发布了用于钩住特定消息的基类。（例如，我在一个全局鼠标滚轮捕捉器中使用了它，它确保我的winforms应用程序的行为与internet explorer相同：将控件滚动到光标下方，而不是活动控件）

使用系统；
使用System.Collections.Generic；
使用System.Linq；
使用系统文本；
使用System.Runtime.InteropServices；
使用Subro.Win32；
名称空间子程序
{
/// 
///相对安全地注册全局windows钩子的基类
/// 
公共抽象类GlobalHookTrapper:FinalizerBase
{
[DllImport（“user32”，EntryPoint=“SetWindowsHookExA”）]
静态外部IntPtr SETWINDOWSHOOKX（int idHook、委托lpfn、IntPtr hmod、IntPtr dwThreadId）；
[DllImport（“user32”，EntryPoint=“unhookwindowshookx”）]
私有静态外部程序int unhookwindowshookx（IntPtr hHook）；
[DllImport（“user32”，EntryPoint=“CallNextHookEx”）]
静态外部int CallNextHook（IntPtr hHook、int ncode、IntPtr wParam、IntPtr lParam）；
[DllImport（“kernel32.dll”）]
静态外部IntPtr GetCurrentThreadId（）；
IntPtr钩；
公共只读int-HookId；
公共只读全局钩子类型钩子类型；
公共GlobalHookTrapper（GlobalHookTypes类型）：此（类型，false）
{
}
公共全局钩子捕捉器（全局钩子类型，bool-OnThread）
{
this.HookType=Type；
this.HookId=（int）类型；
del=ProcessMessage；
如果（阅读）
hook=SetWindowsHookEx（HookId，del，IntPtr.Zero，GetCurrentThreadId（））；
其他的
{
var hmod=IntPtr.Zero；//Marshal.GetHINSTANCE（GetType（）.Module）；
hook=SetWindowsHookEx（HookId、del、hmod、IntPtr.Zero）；
}
if（hook==IntPtr.Zero）
{
int err=Marshal.GetLastWin32Error（）；
如果（错误！=0）
onhook失败（err）；
}
}
受保护的虚拟void OnHookFailed（int错误）
{
抛出Win32Functions.TranslateError（错误）；
}
私有const int HC_ACTION=0；
[Marshallas（UnmanagedType.FunctionPtr）]
私信；
私有委托int MessageDelegate（int代码、IntPtr wparam、IntPtr lparam）；
私有int-ProcessMessage（int-hookcode、IntPtr-wparam、IntPtr-lparam）
{
如果（HC_动作==钩码）
{
尝试
{
if（Handle（wparam，lparam））返回1；
}
捕获{}
}
返回CallNextHook（hook、hookcode、wparam、lparam）；
}
受保护的抽象布尔句柄（IntPtr wparam、IntPtr lparam）；
受保护的覆盖密封无效OnDispose（）
{
解开钩（钩）；
后处理（）；
}
受保护的虚拟空间AfterDispose（）
{
}
}
公共枚举全局钩子类型
{
BeforeWindow=4，//WH_CALLWNDPROC
AfterWindow=12，//WH\u调用WndProcret
键盘=2，//WH\u键盘
键盘\u全局=13，//WH\u键盘\u LL
鼠标=7，//WH\u鼠标
鼠标\u全局=14，//WH\u鼠标\u LL
JournalRecord=0，//WH\u JournalRecord
JournalPlayback=1，//WH\u JournalPlayback
ForeGroundIdle=11，//WH\u ForeGroundIdle
SystemMessages=6，//WH\u SYSMSGFILTER
MessageQueue=3，//WH\u GETMESSAGE
基于计算机的培训=5，//WH\u CBT
硬件=8，//WH\u硬件
Debug=9，//WH\u Debug
Shell=10，//WH\u Shell
}
公共抽象类终结器基：IDisposable
{
受保护的只读AppDomain域；
公共终结器基（）
{
System.Windows.Forms.Application.ApplicationExit+=新事件处理程序（Application\u ApplicationExit）；
domain=AppDomain.CurrentDomain；
domain.ProcessExit+=新的事件处理程序（CurrentDomain_ProcessExit）；
domain.DomainUnload+=新的事件处理程序（domain\u DomainUnload）；
}
私人住宅；
public bool IsDisposed{get{return disposed；}}
公共空间处置（）
{
如果（！已处置）
{
总干事（本）；
如果（域！=null）
{
domain.ProcessExit-=新的事件处理程序（CurrentDomain\u ProcessExit）；
domain.DomainUnload-=新事件处理程序（域\域
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;
using Subro.Win32;

namespace Subro
{
    /// <summary>
    /// Base class to relatively safely register global windows hooks
    /// </summary>
    public abstract class GlobalHookTrapper : FinalizerBase
    {
        [DllImport("user32", EntryPoint = "SetWindowsHookExA")]
        static extern IntPtr SetWindowsHookEx(int idHook, Delegate lpfn, IntPtr hmod, IntPtr dwThreadId);

        [DllImport("user32", EntryPoint = "UnhookWindowsHookEx")]
        private static extern int UnhookWindowsHookEx(IntPtr hHook);

        [DllImport("user32", EntryPoint = "CallNextHookEx")]
        static extern int CallNextHook(IntPtr hHook, int ncode, IntPtr wParam, IntPtr lParam);

        [DllImport("kernel32.dll")]
        static extern IntPtr GetCurrentThreadId();

        IntPtr hook;
        public readonly int HookId;
        public readonly GlobalHookTypes HookType;

        public GlobalHookTrapper(GlobalHookTypes Type):this(Type,false)
        {
        }

        public GlobalHookTrapper(GlobalHookTypes Type, bool OnThread)
        {
            this.HookType = Type;
            this.HookId = (int)Type;
            del = ProcessMessage;
            if (OnThread)
                hook = SetWindowsHookEx(HookId, del, IntPtr.Zero, GetCurrentThreadId());
            else
            {
                var hmod = IntPtr.Zero; // Marshal.GetHINSTANCE(GetType().Module);
                hook = SetWindowsHookEx(HookId, del, hmod, IntPtr.Zero);
            }

            if (hook == IntPtr.Zero)
            {
                int err = Marshal.GetLastWin32Error();
                if (err != 0)
                    OnHookFailed(err);
            }
        }

        protected virtual void OnHookFailed(int Error)
        {
            throw Win32Functions.TranslateError(Error);
        }

        private const int HC_ACTION = 0;

        [MarshalAs(UnmanagedType.FunctionPtr)]
        private MessageDelegate del;

        private delegate int MessageDelegate(int code, IntPtr wparam, IntPtr lparam);

        private int ProcessMessage(int hookcode, IntPtr wparam, IntPtr lparam)
        {
            if (HC_ACTION == hookcode)
            {
                try
                {
                    if (Handle(wparam, lparam)) return 1;
                }
                catch { }
            }
            return CallNextHook(hook, hookcode, wparam, lparam);
        }

        protected abstract bool Handle(IntPtr wparam, IntPtr lparam);



        protected override sealed void OnDispose()
        {
            UnhookWindowsHookEx(hook);
            AfterDispose();
        }

        protected virtual void AfterDispose()
        {
        }

    }

    public enum GlobalHookTypes
    {
        BeforeWindow = 4, //WH_CALLWNDPROC 
        AfterWindow = 12, //WH_CALLWNDPROCRET 
        KeyBoard = 2, //WH_KEYBOARD
        KeyBoard_Global = 13,  //WH_KEYBOARD_LL
        Mouse = 7, //WH_MOUSE
        Mouse_Global = 14, //WH_MOUSE_LL
        JournalRecord = 0, //WH_JOURNALRECORD
        JournalPlayback = 1, //WH_JOURNALPLAYBACK
        ForeGroundIdle = 11, //WH_FOREGROUNDIDLE
        SystemMessages = 6, //WH_SYSMSGFILTER
        MessageQueue = 3, //WH_GETMESSAGE
        ComputerBasedTraining = 5, //WH_CBT 
        Hardware = 8, //WH_HARDWARE 
        Debug = 9, //WH_DEBUG 
        Shell = 10, //WH_SHELL
    }

    public abstract class FinalizerBase : IDisposable
    {
        protected readonly AppDomain domain;
        public FinalizerBase()
        {
            System.Windows.Forms.Application.ApplicationExit += new EventHandler(Application_ApplicationExit);
            domain = AppDomain.CurrentDomain;
            domain.ProcessExit += new EventHandler(CurrentDomain_ProcessExit);
            domain.DomainUnload += new EventHandler(domain_DomainUnload);            
        }

        private bool disposed;
        public bool IsDisposed{get{return disposed;}}
        public void Dispose()
        {
            if (!disposed)
            {
                GC.SuppressFinalize(this);
                if (domain != null)
                {
                    domain.ProcessExit -= new EventHandler(CurrentDomain_ProcessExit);
                    domain.DomainUnload -= new EventHandler(domain_DomainUnload);
                    System.Windows.Forms.Application.ApplicationExit -= new EventHandler(Application_ApplicationExit);
                }
                disposed = true;
                OnDispose();
            }
        }

        void Application_ApplicationExit(object sender, EventArgs e)
        {
            Dispose();
        }

        void domain_DomainUnload(object sender, EventArgs e)
        {
            Dispose();
        }

        void CurrentDomain_ProcessExit(object sender, EventArgs e)
        {
            Dispose();
        }

        protected abstract void OnDispose();
                /// Destructor
        ~FinalizerBase()
        {
            Dispose();
        }
    }


}