C# Window Process Message Processing WndProc
WinForm WndProc
Rewriting is generally used in WinFormWndProcMethod of processing specified messages received by windows or controls
Example: Prohibit closing the window through the close button or other means of sending WM_CLOSE messages
protected override void WndProc(ref Message m)
{
const int WM_CLOSE = 0x0010;
if( == WM_CLOSE)
{
// ("Close this window is prohibited");
return;
}
(ref m);
}There is also a DefWndProc window process in the Control class.
WPF HwndSource
WPF only has handles for native windows or HwndHost embedded controls, which can be passedHwndSourceAdd message processing
Example: Prohibit closing the window through the close button or other means of sending WM_CLOSE messages
HwndSource source = null;
protected override void OnSourceInitialized(EventArgs e)
{
(e);
IntPtr handle = new WindowInteropHelper(this).Handle;
source = (handle);
(WndProc);
}
protected override void OnClosed(EventArgs e)
{
source?.RemoveHook(WndProc);
(e);
}
private IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
{
const int WM_CLOSE = 0x0010;
if(msg == WM_CLOSE)
{
// ("Close this window is prohibited");
handled = true; // Marked as processed
}
return ;
}WinForm IMessageFilter
⚠ Note: 1. Message filters are unique to specific threads; 2. Using message filters may degrade program performance
IMessageFilterInterface allows programs to capture messages for preprocessing before scheduling messages to controls or windows.
The messages received by IMessageFilter’s PreFilterMessage and Control’s WndProc are in an intersection relationship. The messages received by the application come from the system message queue, which is relatively complete, but some messages will be sent directly to the window or control without entering the system message queue.
Implement IMessageFilter interface instance can preprocess the entire thread message loop and obtain the window or control handle for the message passing in according to the
Example: Intercept the program mouse suspended message, and the window title shows the current suspended control name
static class Program
{
[STAThread]
static void Main()
{
();
(false);
var filter = new SampleMsgFilter();
(filter); // Add to message pump
(new MainForm());
(filter); //Remove from the message pump
}
}
sealed class SampleMsgFilter : IMessageFilter
{
public bool PreFilterMessage(ref Message m)
{
const int WM_MOUSEHOVER = 0x02A1;
if( == WM_MOUSEHOVER && () is Control ctr)
{
().Text = ;
return true; // Filter messages do not continue to be distributed
}
return false; // Allow messages to be dispatched to the next filter or control
}
}WinForm NativeWindow
NativeWindowIt is a low-level package of IWin32Window, and it has the WndProc and DefWndProc methods like WinForm Control, so messages can also be processed by rewriting the WndProc method.
You can create a message-only window without a UI through CreateHandle(new CreateParams()). For example, tray iconsNotifyIconA NativeWindow will be created internally to receive taskbar creation messages WM_TASKBARCREATED ("TaskbarCreated"), and the icon will be recreated after the Explorer crashes and restarts.
Attach to another window
Since WinForm Control WndProc is sealed, the type must be inherited and rewritten when processing messages. When there are many windows or controls that require separate message processing, it is very invasive to the original code; while IMessageFilter is a message loop for the entire application. The official document says that using message filters may very likely reduce program performance; relatively speaking, since HwndSource AddHook and RemoveHook are not sealed, the WPF program can process window messages without invading the original code, which has an advantage in reusability. But if you look at the source code of NativeWindow, you will find that it is called internally.SetWindowLongGWL_WNDPROC (window subclassification), can be attached to any window or control through AssignHandle for message processing. This window does not restrict the type, and can even be attached to other program windows.
Here is a static auxiliary class that uses NativeWindow to simplify the processing of additional window message processes:
using System;
using;
using;
namespace
{
public delegate bool HookProc(ref Message m);
public static class MessageHooker
{
sealed class HookWindow: NativeWindow
{
List<KeyValuePair<HookProc, Action>> hooks;
public HookWindow(IntPtr hWnd)
{
AssignHandle(hWnd);
}
public void AddHookProc(HookProc hook, Action removedHandler)
{
if (hooks == null)
{
hooks = new List<KeyValuePair<HookProc, Action>>();
}
(0, new KeyValuePair<HookProc, Action>(hook, removedHandler));
}
public void RemoveHookProc(HookProc hook)
{
if (hooks != null)
{
for (int i = - 1; i >= 0; i--)
{
if (hooks[i].Key == hook)
{
hooks[i].Value?.Invoke();
(i);
}
}
}
}
protected override void WndProc(ref Message m)
{
if (hooks != null)
{
foreach (var hook in hooks)
{
if ((ref m)) return;
}
const int WM_NCDESTORY = 0x0082;
if ( == WM_NCDESTROY) // Remove all hooks when window is destroyed
{
for (int i = - 1; i >= 0; i--)
{
hooks[i].Value?.Invoke();
}
hooks = null;
}
(ref m);
}
}
}
/// <summary>Attach message processing process to window</summary>
/// <param name="handle">Window handle that requires additional message processing</param>
/// <param name="hook">Message processing</param>
/// <param name="removedHandler">Message processing removes callback</param>
public static void AddHook(IntPtr handle, HookProc hook, Action removedHandler = null)
{
if (!((handle) is HookWindow window))
{
window = new HookWindow(handle);
}
(hook, removedHandler);
}
/// <summary>Removing additional message processing from window</summary>
/// <param name="handle">The window handle of the message processing process needs to be removed</param>
/// <param name="hook">Message processing</param>
public static void RemoveHook(IntPtr handle, HookProc hook)
{
if ((handle) is HookWindow window)
{
(hook);
}
}
}
}