一个hook mouse message的类 国外抄来的 看不懂 不知道怎么用

Question

mousehook.csusing System;
using System.ComponentModel;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Windows.Forms;
namespace Agron.Services.Broadcasting
{
    /// <summary>
    /// An implementation of a Windows Hook for Mouse events.
    /// </summary>
    public sealed class MouseHook : IDisposable
    {
        private const int WH_MOUSE_LL = 0xE;        private SafeMouseHookHandle _hookHandle;
        private LowLevelMouseProc _hookProc;        /// <summary>
        /// Initializes a new instance of the <see cref="MouseHook"/> class.
        /// </summary>
        /// <res>
        /// Locked constructor to force callers to use <see cref="MouseHook.Initialize"/> to initialize the class
        /// since the operation may throw a <see cref="Win32Exception"/> if the hook initialization fails.
        /// </res>
        private MouseHook() { }        /// <summary>
        /// Initializes a new instance of the <see cref="MouseHook"/> class.
        /// </summary>
        /// <returns>Returns a new instance of the <see cref="MouseHook"/> class.</returns>
        /// <exception cref="Win32Exception">If the hook initialization (<c>User32::SetWindowsHookEx</c>) fails.</exception>
        public static MouseHook Initialize()
        {
            MouseHook classInstance = new MouseHook();            // Create the callback and make sure it doesn't get GC'd,
            // since it'll be called from unmanaged code.
            classInstance._hookProc = new LowLevelMouseProc(classInstance.HookCallback);            // Set the hook for just the GUI thread
            using (Process currentProcess = Process.GetCurrentProcess())
            using (ProcessModule currentModule = currentProcess.MainModule)
            {
                classInstance._hookHandle = NativeMethods.SetWindowsHookEx(
                    MouseHook.WH_MOUSE_LL, 
                    classInstance._hookProc, 
                    NativeMethods.GetModuleHandle(currentModule.ModuleName), 
                    0);
            }            if (classInstance._hookHandle.IsInvalid)
            {
                Win32Exception exception = new Win32Exception();
                classInstance.Dispose();
                throw exception;
            }            return classInstance;
        }        /// <summary>
        /// Releases unmanaged resources and performs other cleanup operations before the
        /// <see cref="MouseHook"/> is reclaimed by garbage collection.
        /// </summary>
        ~MouseHook()
        {
            this.Dispose();
        }        /// <summary>
        /// Occurs when a mouse button is pressed.
        /// </summary>
        public event EventHandler<MouseEventArgs> MouseDown;        /// <summary>
        /// Occurs when the mouse pointer is moved.
        /// </summary>
        public event EventHandler<MouseEventArgs> MouseMove;        /// <summary>
        /// Occurs when a mouse button is released.
        /// </summary>
        public event EventHandler<MouseEventArgs> MouseUp;        /// <summary>
        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
        /// </summary>
        public void Dispose()
        {
            if (null != _hookHandle)
            {
                this._hookHandle.Dispose();
                this._hookHandle = null;
            }            GC.SuppressFinalize(this);
        }        private void OnMouseDown(MouseEventArgs e)
        {
            EventHandler<MouseEventArgs> eventHandler = this.MouseDown;            if (null != eventHandler)
                eventHandler(this, e);
        }        private void OnMouseMove(MouseEventArgs e)
        {
            EventHandler<MouseEventArgs> eventHandler = this.MouseMove;            if (null != eventHandler)
                eventHandler(this, e);
        }        private void OnMouseUp(MouseEventArgs e)
        {
            EventHandler<MouseEventArgs> eventHandler = this.MouseUp;            if (null != eventHandler)
                eventHandler(this, e);
        }        private IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
        {
            MSLLHOOKSTRUCT hookData;            if (0 < nCode)
            {
                WindowsMessages message = (WindowsMessages) wParam;
                switch (message)
                {
                    case WindowsMessages.WM_LBUTTONDOWN:
                        hookData = (MSLLHOOKSTRUCT) Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT));
                        this.OnMouseDown(new MouseEventArgs(MouseButtons.Left, 1, hookData.pt.X, hookData.pt.Y, 0));
                        break;                    case WindowsMessages.WM_RBUTTONDOWN:
                        hookData = (MSLLHOOKSTRUCT) Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT));
                        this.OnMouseDown(new MouseEventArgs(MouseButtons.Right, 1, hookData.pt.X, hookData.pt.Y, 0));
                        break;                    case WindowsMessages.WM_MOUSEMOVE:
                        hookData = (MSLLHOOKSTRUCT) Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT));
                        this.OnMouseMove(new MouseEventArgs(MouseButtons.None, 0, hookData.pt.X, hookData.pt.Y, 0));
                        break;                    case WindowsMessages.WM_LBUTTONUP:
                        hookData = (MSLLHOOKSTRUCT) Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT));
                        this.OnMouseUp(new MouseEventArgs(MouseButtons.Left, 1, hookData.pt.X, hookData.pt.Y, 0));
                        break;                    case WindowsMessages.WM_RBUTTONUP:
                        hookData = (MSLLHOOKSTRUCT) Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT));
                        this.OnMouseUp(new MouseEventArgs(MouseButtons.Right, 1, hookData.pt.X, hookData.pt.Y, 0));
                        break;
                }
            }            return NativeMethods.CallNextHookEx(_hookHandle, nCode, wParam, lParam);
        }        static class NativeMethods
        {
            /// <summary>
            /// The SetWindowsHookEx function installs an application-defined hook procedure into a hook chain.
            /// </summary>
            /// <param name="idHook">Specifies the type of hook procedure to be installed.</param>
            /// <param name="lpfn">Pointer to the hook procedure.</param>
            /// <param name="hMod">Handle to the DLL containing the hook procedure pointed to by the lpfn parameter.</param>
            /// <param name="dwThreadId">Specifies the identifier of the thread with which the hook procedure is to be associated.</param>
            /// <returns>
            /// If the function succeeds, the return value is the handle to the hook procedure; otherwise, 0.
            /// </returns>
            [DllImport("user32.dll", SetLastError = true)]
            internal static extern SafeMouseHookHandle SetWindowsHookEx(int idHook, LowLevelMouseProc lpfn, IntPtr hMod, uint dwThreadId);            /// <summary>
            /// The CallNextHookEx function passes the hook information to the next hook procedure in the current hook chain.
            /// </summary>
            /// <param name="hhk">Handle to the current hook.</param>
            /// <param name="nCode">Specifies the hook code passed to the current hook procedure.</param>
            /// <param name="wParam">Specifies the wParam value passed to the current hook procedure.</param>
            /// <param name="lParam">Specifies the lParam value passed to the current hook procedure.</param>
            /// <returns>
            /// This value is returned by the next hook procedure in the chain.
            /// </returns>
            [DllImport("user32.dll", SetLastError = true)]
            internal static extern IntPtr CallNextHookEx(SafeMouseHookHandle hhk, int nCode, IntPtr wParam, IntPtr lParam);            /// <summary>
            /// Retrieves a module handle for the specified module. The module must have been loaded by the calling process
            /// </summary>
            /// <param name="lpModuleName">The name of the loaded module (either a .dll or .exe file).</param>
            /// <returns>
            /// If the function succeeds, the return value is a handle to the specified module.
            /// If the function fails, the return value is NULL.
            /// </returns>
            [DllImport("kernel32.dll", SetLastError = true)]
            internal static extern IntPtr GetModuleHandle(string lpModuleName);
        }
    }
}

Answer 1

LowLevelMouseProc.csusing System;
using System.Collections.Generic;
using System.Text;namespace Agron.Services.Broadcasting
{
    internal delegate IntPtr LowLevelMouseProc(int nCode, IntPtr wParam, IntPtr lParam);
}

Answer 2

SafeMouseHookHandle.cs
using Microsoft.Win32.SafeHandles;using System;
using System.Security;
using System.Security.Permissions;
using System.Runtime.ConstrainedExecution;
using System.Runtime.InteropServices;
namespace Agron.Services.Broadcasting
{
    /// <summary>
    /// A <see cref="SafeHandle"/> implementation for a <c>Windows Hook Handle</c>.
    /// </summary>
    [SecurityPermission(SecurityAction.LinkDemand, UnmanagedCode = true)]
    internal class SafeMouseHookHandle : SafeHandleMinusOneIsInvalid
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="SafeMouseHookHandle"/> class.
        /// </summary>
        private SafeMouseHookHandle() : base(true) { }        /// <summary>
        /// When overridden in a derived class, executes the code required to free the handle.
        /// </summary>
        /// <returns>
        /// true if the handle is released successfully; otherwise, in the event of a catastrophic failure, false. In this case, it generates a ReleaseHandleFailed Managed Debugging Assistant.
        /// </returns>
        protected override bool ReleaseHandle()
        {
            return NativeMethods.UnhookWindowsHookEx(handle);
        }        static class NativeMethods
        {
            /// <summary>The UnhookWindowsHookEx function removes a hook procedure installed in a hook chain by the SetWindowsHookEx function.</summary>
            /// <param name="hhk">Handle to the hook procedure</param>
            /// <returns>true on success; otherwise, false.</returns>
            [SuppressUnmanagedCodeSecurity]
            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
            [DllImport("user32.dll", SetLastError = true)]
            [return: MarshalAs(UnmanagedType.Bool)]
            internal static extern bool UnhookWindowsHookEx(IntPtr hhk);
        }
    }
}

Answer 3

WindowsMessages.csnamespace Agron.Services.Broadcasting
{
    internal enum WindowsMessages
    {
        WM_ACTIVATE = 0x6,
        WM_ACTIVATEAPP = 0x1C,
        WM_AFXFIRST = 0x360,
        WM_AFXLAST = 0x37F,
        WM_APP = 0x8000,
        WM_ASKCBFORMATNAME = 0x30C,
        WM_CANCELJOURNAL = 0x4B,
        WM_CANCELMODE = 0x1F,
        WM_CAPTURECHANGED = 0x215,
        WM_CHANGECBCHAIN = 0x30D,
        WM_CHAR = 0x102,
        WM_CHARTOITEM = 0x2F,
        WM_CHILDACTIVATE = 0x22,
        WM_CLEAR = 0x303,
        WM_CLOSE = 0x10,
        WM_COMMAND = 0x111,
        WM_COMPACTING = 0x41,
        WM_COMPAREITEM = 0x39,
        WM_CONTEXTMENU = 0x7B,
        WM_COPY = 0x301,
        WM_COPYDATA = 0x4A,
        WM_CREATE = 0x1,
        WM_CTLCOLORBTN = 0x135,
        WM_CTLCOLORDLG = 0x136,
        WM_CTLCOLOREDIT = 0x133,
        WM_CTLCOLORLISTBOX = 0x134,
        WM_CTLCOLORMSGBOX = 0x132,
        WM_CTLCOLORSCROLLBAR = 0x137,
        WM_CTLCOLORSTATIC = 0x138,
        WM_CUT = 0x300,
        WM_DEADCHAR = 0x103,
        WM_DELETEITEM = 0x2D,
        WM_DESTROY = 0x2,
        WM_DESTROYCLIPBOARD = 0x307,
        WM_DEVICECHANGE = 0x219,
        WM_DEVMODECHANGE = 0x1B,
        WM_DISPLAYCHANGE = 0x7E,
        WM_DRAWCLIPBOARD = 0x308,
        WM_DRAWITEM = 0x2B,
        WM_DROPFILES = 0x233,
        WM_ENABLE = 0xA,
        WM_ENDSESSION = 0x16,
        WM_ENTERIDLE = 0x121,
        WM_ENTERMENULOOP = 0x211,
        WM_ENTERSIZEMOVE = 0x231,
        WM_ERASEBKGND = 0x14,
        WM_EXITMENULOOP = 0x212,
        WM_EXITSIZEMOVE = 0x232,
        WM_FONTCHANGE = 0x1D,
        WM_GETDLGCODE = 0x87,
        WM_GETFONT = 0x31,
        WM_GETHOTKEY = 0x33,
        WM_GETICON = 0x7F,
        WM_GETMINMAXINFO = 0x24,
        WM_GETOBJECT = 0x3D,
        WM_GETSYSMENU = 0x313,
        WM_GETTEXT = 0xD,
        WM_GETTEXTLENGTH = 0xE,
        WM_HANDHELDFIRST = 0x358,
        WM_HANDHELDLAST = 0x35F,
        WM_HELP = 0x53,
        WM_HOTKEY = 0x312,
        WM_HSCROLL = 0x114,
        WM_HSCROLLCLIPBOARD = 0x30E,
        WM_ICONERASEBKGND = 0x27,
        WM_IME_CHAR = 0x286,
        WM_IME_COMPOSITION = 0x10F,
        WM_IME_COMPOSITIONFULL = 0x284,
        WM_IME_CONTROL = 0x283,
        WM_IME_ENDCOMPOSITION = 0x10E,
        WM_IME_KEYDOWN = 0x290,
        WM_IME_KEYLAST = 0x10F,
        WM_IME_KEYUP = 0x291,
        WM_IME_NOTIFY = 0x282,
        WM_IME_REQUEST = 0x288,
        WM_IME_SELECT = 0x285,
        WM_IME_SETCONTEXT = 0x281,
        WM_IME_STARTCOMPOSITION = 0x10D,
        WM_INITDIALOG = 0x110,
        WM_INITMENU = 0x116,
        WM_INITMENUPOPUP = 0x117,
        WM_INPUTLANGCHANGE = 0x51,
        WM_INPUTLANGCHANGEREQUEST = 0x50,
        WM_KEYDOWN = 0x100,
        WM_KEYFIRST = 0x100,
        WM_KEYLAST = 0x108,
        WM_KEYUP = 0x101,
        WM_KILLFOCUS = 0x8,
        WM_LBUTTONDBLCLK = 0x203,
        WM_LBUTTONDOWN = 0x201,
        WM_LBUTTONUP = 0x202,
        WM_MBUTTONDBLCLK = 0x209,
        WM_MBUTTONDOWN = 0x207,
        WM_MBUTTONUP = 0x208,
        WM_MDIACTIVATE = 0x222,
        WM_MDICASCADE = 0x227,
        WM_MDICREATE = 0x220,
        WM_MDIDESTROY = 0x221,
        WM_MDIGETACTIVE = 0x229,
        WM_MDIICONARRANGE = 0x228,
        WM_MDIMAXIMIZE = 0x225,
        WM_MDINEXT = 0x224,
        WM_MDIREFRESHMENU = 0x234,
        WM_MDIRESTORE = 0x223,
        WM_MDISETMENU = 0x230,
        WM_MDITILE = 0x226,
        WM_MEASUREITEM = 0x2C,
        WM_MENUCHAR = 0x120,
        WM_MENUCOMMAND = 0x126,
        WM_MENUDRAG = 0x123,
        WM_MENUGETOBJECT = 0x124,
        WM_MENURBUTTONUP = 0x122,
        WM_MENUSELECT = 0x11F,
        WM_MOUSEACTIVATE = 0x21,
        WM_MOUSEFIRST = 0x200,
        WM_MOUSEHOVER = 0x2A1,
        WM_MOUSELAST = 0x20A,
        WM_MOUSELEAVE = 0x2A3,
        WM_MOUSEMOVE = 0x200,
        WM_MOUSEWHEEL = 0x20A,
        WM_MOVE = 0x3,
        WM_MOVING = 0x216,
        WM_NCACTIVATE = 0x86,
        WM_NCCALCSIZE = 0x83,
        WM_NCCREATE = 0x81,
        WM_NCDESTROY = 0x82,
        WM_NCHITTEST = 0x84,
        WM_NCLBUTTONDBLCLK = 0xA3,
        WM_NCLBUTTONDOWN = 0xA1,
        WM_NCLBUTTONUP = 0xA2,
        WM_NCMBUTTONDBLCLK = 0xA9,
        WM_NCMBUTTONDOWN = 0xA7,
        WM_NCMBUTTONUP = 0xA8,
        WM_NCMOUSEHOVER = 0x2A0,
        WM_NCMOUSELEAVE = 0x2A2,
        WM_NCMOUSEMOVE = 0xA0,
        WM_NCPAINT = 0x85,
        WM_NCRBUTTONDBLCLK = 0xA6,
        WM_NCRBUTTONDOWN = 0xA4,
        WM_NCRBUTTONUP = 0xA5,
        WM_NEXTDLGCTL = 0x28,
        WM_NEXTMENU = 0x213,
        WM_NOTIFY = 0x4E,
        WM_NOTIFYFORMAT = 0x55,
        WM_NULL = 0x0,
        WM_PAINT = 0xF,
        WM_PAINTCLIPBOARD = 0x309,
        WM_PAINTICON = 0x26,
        WM_PALETTECHANGED = 0x311,
        WM_PALETTEISCHANGING = 0x310,
        WM_PARENTNOTIFY = 0x210,
        WM_PASTE = 0x302,
        WM_PENWINFIRST = 0x380,
        WM_PENWINLAST = 0x38F,
        WM_POWER = 0x48,
        WM_PRINT = 0x317,
        WM_PRINTCLIENT = 0x318,
        WM_QUERYDRAGICON = 0x37,
        WM_QUERYENDSESSION = 0x11,
        WM_QUERYNEWPALETTE = 0x30F,
        WM_QUERYOPEN = 0x13,
        WM_QUERYUISTATE = 0x129,
        WM_QUEUESYNC = 0x23,
        WM_QUIT = 0x12,
        WM_RBUTTONDBLCLK = 0x206,
        WM_RBUTTONDOWN = 0x204,
        WM_RBUTTONUP = 0x205,
        WM_RENDERALLFORMATS = 0x306,
        WM_RENDERFORMAT = 0x305,
        WM_SETCURSOR = 0x20,
        WM_SETFOCUS = 0x7,
        WM_SETFONT = 0x30,
        WM_SETHOTKEY = 0x32,
        WM_SETICON = 0x80,
        WM_SETREDRAW = 0xB,
        WM_SETTEXT = 0xC,
        WM_SETTINGCHANGE = 0x1A,
        WM_SHOWWINDOW = 0x18,
        WM_SIZE = 0x5,
        WM_SIZECLIPBOARD = 0x30B,
        WM_SIZING = 0x214,
        WM_SPOOLERSTATUS = 0x2A,
        WM_STYLECHANGED = 0x7D,
        WM_STYLECHANGING = 0x7C,
        WM_SYNCPAINT = 0x88,
        WM_SYSCHAR = 0x106,
        WM_SYSCOLORCHANGE = 0x15,
        WM_SYSCOMMAND = 0x112,
        WM_SYSDEADCHAR = 0x107,
        WM_SYSKEYDOWN = 0x104,
        WM_SYSKEYUP = 0x105,
        WM_SYSTIMER = 0x118,  // undocumented, see http://support.microsoft.com/?id=108938
        WM_TCARD = 0x52,
        WM_TIMECHANGE = 0x1E,
        WM_TIMER = 0x113,
        WM_UNDO = 0x304,
        WM_UNINITMENUPOPUP = 0x125,
        WM_USER = 0x400,
        WM_USERCHANGED = 0x54,
        WM_VKEYTOITEM = 0x2E,
        WM_VSCROLL = 0x115,
        WM_VSCROLLCLIPBOARD = 0x30A,
        WM_WINDOWPOSCHANGED = 0x47,
        WM_WINDOWPOSCHANGING = 0x46,
        WM_WININICHANGE = 0x1A,
        WM_XBUTTONDBLCLK = 0x20D,
        WM_XBUTTONDOWN = 0x20B,
        WM_XBUTTONUP = 0x20C
    }
}

Answer 4

What would you do it?

Answer 5

还没完呢 一次最多发3贴有点郁闷MSLLHOOKSTRUCT.csusing System;
using System.Runtime.InteropServices;
namespace Agron.Services.Broadcasting
{
    [StructLayout(LayoutKind.Sequential)]
    internal struct MSLLHOOKSTRUCT
    {
        public POINT pt;
        public uint mouseData;
        public uint flags;
        public uint time;
        public IntPtr dwExtraInfo;
    }
}POINT.csusing System;
using System.Drawing;
using System.Runtime.InteropServices;
namespace Agron.Services.Broadcasting
{
    [StructLayout(LayoutKind.Sequential)]
    internal struct POINT
    {
        public int X;
        public int Y;        public POINT(int x, int y)
        {
            this.X = x;
            this.Y = y;
        }        public static implicit operator Point(POINT nativePoint)
        {
            return new Point(nativePoint.X, nativePoint.Y);
        }        public static implicit operator POINT(Point managedPoint)
        {
            return new POINT(managedPoint.X, managedPoint.Y);
        }
    }
}

Answer 6

他的源代码里调用该类 我不出来 不知道为什么private MouseHook _mouseHook;
public void StartHost()
        {                // Initialize Mouse Hook
                this._mouseHook = MouseHook.Initialize();
                this._mouseHook.MouseDown += new EventHandler<System.Windows.Forms.MouseEventArgs>(OnMouseHookMouseDown);
                this._mouseHook.MouseMove += new EventHandler<System.Windows.Forms.MouseEventArgs>(OnMouseHookMouseMove);
                this._mouseHook.MouseUp += new EventHandler<System.Windows.Forms.MouseEventArgs>(OnMouseHookMouseUp);
         }
  public void StopHost()
        {
            
            this._mouseHook.Dispose();
        }
       protected virtual void OnMouseHookMouseUp(object sender, MouseEventArgs e)
        {
            if (MouseButtons.Left == e.Button)
            {
                this.NotifyLeftButtonUp(e.X, e.Y);
            }
            else if (MouseButtons.Right == e.Button)
            {
                this.NotifyRightButtonUp(e.X, e.Y);
            }
        }
       protected virtual void OnMouseHookMouseMove(object sender, MouseEventArgs e)
        {
            this.NotifyMove(e.X, e.Y);
        }
       protected virtual void OnMouseHookMouseDown(object sender, MouseEventArgs e)
        {
            if (MouseButtons.Left == e.Button)
            {
                this.NotifyLeftButtonDown(e.X, e.Y);
            }
            else if (MouseButtons.Right == e.Button)
            {
                this.NotifyRightButtonDown(e.X, e.Y);
            }
        }

Answer 7

doufuxadf
上面的Windows消息 我收藏了

Answer 8

 将其他的CS编译成dll，在调用的类中调用这个这个DLL试试