C# 收发和处理自定义的WINDOWS消息

http://blog.sina.com.cn/s/blog_45eaa01a01013zbs.html

　　为了程序启动后自动执行主函数，在Form1_Load中直接执行启动函数，可能造成没有

反应。当然，在Form1_Load中加入较长时间（比如２秒）的定时器，在定时器函数中关闭

定时器（仅需要执行一次），再执行主函数会好些，但是我们不知道初始话的精确时间，这

样的方法也存在危险。
　　我们知道WINDOWS应用程序是靠消息驱动的，最好的方法就是在Form1_Load中发送

消息，自己截获消息后，才开始执行比较安全。下面分3步说明相关的方法步骤。

一、创建一个 C# 项目，并选择 Windows 应用程序，名称默认

WindowsFormsApplication1

　　为了简单，所有项目都按默认值处理。

二、添加处理Windows 消息的方法，即重载 DefWndProc方法
　　点选菜单[视图]->[对象浏览器]，打开对象浏览窗口(有的可能在[其他窗口])，在其中找

到自己应用程序名WindowsFormsApplication1(一般在最下部)，展开它并选中基类型Form

，这时在右边的窗口列出所有Form类的成员函数，你也可以更改本窗口上边的[对象浏览器

设置]，从中勾选更多选项，以便出现更多的函数，如图所示：
protected override void DefWndProc(ref System.Windows.Forms.Message m)

　　我们选中DefWndProc(ref System.Windows.Forms.Message)，此时在下面窗口会显

示完整的函数protected override void DefWndProc(ref

System.Windows.Forms.Message m)，我们右击这行说明字符串，点选复制将其复制下来

。转到窗口Form1.cs，粘贴到Form1类里面，注意前面的override关键字，适当修改就可以

处理自定义消息了。
　　protected override void DefWndProc(ref System.Windows.Forms.Message m)
　　{
　　 switch (m.Msg)
　　　　{
　　　 case USER+1:
　　　 //string message = string.Format("收到自己消息的参数:{0},{1}", m.WParam,

m.LParam);
　　　　　 //处理启动函数MessageBox.Show(message);//显示一个消息框
　　　　　　StartProcess();
　　　　　　 break;
　　　　　default:
　　　　　 base.DefWndProc(ref m);//一定要调用基类函数，以便系统处理其它消息。
　　　　　　　break;
　　 }
　　}
三、引入发送消息的函数
　　我们需要PostMessage发送自定义消息，所以用如下语句引用它：
　　[DllImport("user32.dll")]
　　public static extern void PostMessage(IntPtr hWnd, int msg, int wParam, int

lParam);
　　自定义消息号一般开始于0x0400，也定义一个常量 public const int USER = 0x0400;
这样就可以在Form1_Load中发送消息，以便自动开始执行程序。
　　private void Form1_Load(object sender, EventArgs e)
　　{
　　 //Thread.Sleep(100); //等待100毫秒
　　 PostMessage(this.Handle, USER + 1, 168, 51898);
　　}
四引用关键字的命名空间
　　对于上面的关键字DllImport，字符要正确，大小写也要正确，此时是黑色字体，还不认

识，那就需要引用它的命名空间，方法如下，使用鼠标右击关键字DllImport，——解析—

—点选using System.Runtime.InteropServices　，即将所用的命名空间using

System.Runtime.InteropServices;加入到项目中，关键字DllImport的字体变成绿色。

五完整代码如下：
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Threading;
using System.Runtime.InteropServices;
namespace WindowsFormsApplication1
{
public partial class Form1 : Form
{
public const int USER = 0x0400;//用户自定义消息的开始数值

[DllImport("user32.dll")]
public static extern void PostMessage(IntPtr hWnd, int msg, int wParam, int

lParam);

public Form1()
{
InitializeComponent();
}
private void Form1_Load(object sender, EventArgs e)
{
//Thread.Sleep(100); //等待100毫秒
PostMessage(this.Handle, USER + 1, 168, 51898);
}
private void StartProcess()
{
MessageBox.Show("具备条件，可以正常运行了！");
}
protected override void DefWndProc(ref System.Windows.Forms.Message m)
{
switch (m.Msg)
{
case USER+1:
//string message = string.Format("收到自己消息的参数:{0},{1}",

m.WParam, m.LParam);
StartProcess();
break;
default:
base.DefWndProc(ref m);//一定要调用基类函数，以便系统处理其它消息。
break;
}
}
}
}
六有关的图片
点此查看有关的图片
C# 收发和处理自定义的WINDOWS消息
1.建立项目的图片

C# 收发和处理自定义的WINDOWS消息
2.弹出对象浏览器的图片

C# 收发和处理自定义的WINDOWS消息
3.选择基类型Form的图片说明

C# 收发和处理自定义的WINDOWS消息
4.对象浏览器设置的图片说明

C# 收发和处理自定义的WINDOWS消息
5.加入重载方法DefWndProc的图片说明

C# 收发和处理自定义的WINDOWS消息
6.引用关键字命名空间的图片说明

==更多可以参考网上内容==
==１==
c# Windows消息列表
http://www.beijibear.com/index.php?aid=139
==２==
「C#：windows消息大全－详细－有解释」
http://www.mox.cc/018e4d33b5bc0402-ddec43ad9d5cedd0.htm
==３==
c# Windows消息处理过程探究
http://blog.csdn.net/jjjfox/article/details/7360378
　
一、消息概述
Windows下应用程序的执行是通过消息驱动的。消息是整个应用程序的工作引擎，我们

需要理解掌握编程语言是如何封装消息的原理。
1 什么是消息(Message)
消息就是通知和命令。在.NET框架类库中的System.Windows.Forms命名空间中微软采

用面对对象的方式重新定义了Message。新的消息(Message)结构的公共部分属性基本与早

期的一样，不过它是面对对象的。
公共属性：
HWnd 获取或设定消息的处理函数
Msg 获取或设定消息的ID号
Lparam 指定消息的LParam字段
Wparam 指定消息的WParam字段
Result 指定为响应消息处理函数而向OS系统返回的值
2 消息驱动的过程
所有的外部事件，如键盘输入、鼠标移动、按动鼠标都由OS系统转换成相应的消息发送到

应用程序的消息队列。每个应用程序都有一段相应的程序代码来检索、分发这些消息到对应

的窗体，然后由窗体的处理函数来处理。
二、C#中的消息的封装
C#对消息重新进行了面对对象的封装，在C#中消息被封装成了事件。
System.Windows.Forms.Application类具有用于启动和停止应用程序和线程以及处理

Windows消息的方法。
调用Run以启动当前线程上的应用程序消息循环，并可以选择使其窗体可见。
调用Exit或ExitThread来停止消息循环。
C#中用Application类来处理消息的接收和发送的。消息的循环是由它负责的。
从本质上来讲，每个窗体一般都对应一个窗体过程处理函数。那么，C#的一个Form实例(

相当于一个窗体)收到消息后是如何处理消息的？其实，这个问题的分析也就是展示了C#的

消息封装原理。
三、C#中消息的工作流程：
1、 Application类有一个AddMessageFilter的静态方法，通过它我们可以添加消息筛选器

，以便在向目标传递Windows消息时，检视这些消息。
使用消息筛选器来防止引发特定事件，或在将某事件传递给事件处理程序之前使用消息

筛选器对其执行特殊操作。
我们必须提供IMessageFilter接口的一个实现，然后才可以使用消息筛选器。
2、 C#中的消息被Application类从应用程序消息队列中取出，如果有消息筛选器，先执行

消息筛选，然后分发到消息对应的窗体。
1）窗体对象的第一个响应函数是窗口过程函数，即对象中的protected override void

WndProc(ref System.Windows.Forms.Message e)方法。
2）再根据消息的类型调用默认的消息响应函数(如OnMouseDown)
3）再根据用户自定义的事件处理函数，按订阅顺序分别执行(如

Form1_MouseDown1)。

四、示例：

namespace WindowsApplication27
{
partial class Form1
{
///
/// 必需的设计器变量。
///
private System.ComponentModel.IContainer components = null;
///
/// 清理所有正在使用的资源。
///
/// 如果应释放托管资源，为 true；否则为 false。
protected override void Dispose(bool disposing)
{
if (disposing && (components != null))
{
components.Dispose();
}
base.Dispose(disposing);
}
#region Windows 窗体设计器生成的代码
///
/// 设计器支持所需的方法 - 不要
/// 使用代码编辑器修改此方法的内容。
///
private void InitializeComponent()
{
this.SuspendLayout();
//
// Form1
//
this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 12F);
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
this.ClientSize = new System.Drawing.Size(292, 266);
this.Name = "Form1";
this.Text = "Form1";
//这里订阅了事件
this.MouseDown += new System.Windows.Forms.MouseEventHandler

(this.Form1_MouseDown);
this.ResumeLayout(false);
}
#endregion
}
}

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
namespace WindowsApplication27
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
Application.AddMessageFilter((new msgFilter()));
}
private void Form1_MouseDown(object sender, MouseEventArgs e)
{
MessageBox.Show("3");
}
protected override void OnMouseDown(MouseEventArgs e)
{
MessageBox.Show("2");
base.OnMouseDown(e);
}

protected override void WndProc(ref Message m)
{
//MouseDown Msg Id
if (m.Msg==0x0201)
MessageBox.Show("1");
base.WndProc(ref m);
}
}
public class msgFilter : IMessageFilter
{
public bool PreFilterMessage(ref Message m)
{
if (m.Msg == 0x0201)
MessageBox.Show("0");
return false;
}
}
static class Program
{
///
/// 应用程序的主入口点。
///
[STAThread]
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());
}
}
}
========

C#中消息处理机制(事件与委托)

http://blog.sina.com.cn/s/blog_87a692aa0101q8pl.html

编写过Windows桌面应用程序的人都知道，微软的Windows操作系统与应用程序之间的通

信绝大部分是基于消息循环机制的。在VC++中，程序使用GetMessage，

TranslateMessage，DispatchMessage语句从消息队列中获取消息，转换消息并且将消息

分发到目标窗口的过程函数，并由过程函数对不同的Windows消息进行分别处理。
当你将开发平台转向C#的时候，由于C#对消息进行了面向对象的封装，消息被封装成了事

件，使我们对消息传送机制的理解蒙上了一层迷雾，下面我们就从实际的代码着手，抽丝剥

茧，逐步了解C# WinForm中的消息处理机制.当我们新建一个WinForm程序后在

Program.cs中我们看到Application.Run(new Form1());Application类具有用于启动和停止

应用程序和线程以及处理Windows消息的方法。通过此语句，当前线程上开始运行标准应用

程序消息循环，并使指定窗口可见，消息循环被封装进了Application类的Run()静态方法中

。程序结束时调用Exit或者ExitThread来停止消息循环，程序也就随之终止。　　我们为

Form1窗体中创建鼠标点击事件MyClick，程序自动为我们增加一些代码。

this.MouseClick+=new System.Windows.Forms.MouseEventHandler(this.MyClick);上

面this.MouseClick是C#中定义的鼠标单击事件。它被定义为： public event

MouseEventHandler MouseClick;而MouseEventHandler的定义是public delegate void

MouseEventHandler(object sender, MouseEventArgs e);该语句定义了一个名为

MouseEventHandler的委托，那什么是委托呢？　　委托类型可以理解成在C++中的函数

指针，但不同的是，委托是完全面向对象的，同时封装了对象的实例和方法。本质上，委托

把一个实例和该实例上的方法函数封装成一个可调用的实体，它是面向对象的、安全的.我们

可以把第一句代码理解成为this.MouseClick事件添加了一个指向MyClick处理函数的函数指

针。C#中事件的处理方法需要使用委托类型对事件进行注册.当然，你也可以再次调用这句语

句对事件添加另一个处理函数如MyClick2，这些对该事件的处理会形成处理函数列表。则在

程序运行过程中点击鼠标后在完成MyClick函数后会继续运行MyClick2函数。
由上我们可以大致猜测其封装过程：　
Application类将对象发送过来的消息从应用程序消息队列中提取出来后，分发到相应的窗体

，并转换成事件。NET框架定义了一个特殊的类型(Delegate委托)，该类型提供函数指针的

功能。这样，委托就等效于一个类型安全的函数指针或一个回调函数。C#中通过Delegate委

托机制将事件与响应函数的函数地址关联起来，并形成一种函数指针列表，当消息到来的时

候，即可通过这些函数指针列表逐一调用这些响应函数。我们通过以下方法自定义一个事件

触发，来验证我们以上的猜测。我们通过手动添加代码来实现自定义的代理事件（同VC++

中的自定义消息）
1、声明事件委托。此处int para仅是方便实验，代表所需要的参数列表，但要注意参数列表

需要和第3步的参数列表相统一。 public delegate void MyEventHandler(int para);
2、声明事件，event 关键字用于在发行者类中声明事件，委托MyEventHandler作为事件

的类型。 public event MyEventHandler MyEvent;
3、添加事件的处理程序（响应事件的方法）。 public void OnMyEvent(int para) {

MessageBox.Show(""事件触发，参数为:""+para); }
4、将指定的事件处理程序邦定到要处理的事件上（订阅事件）,注意，此语句需要写在程序

执行语句中，如Form_Lord函数内。 this.MyEvent += new MyEventHandler

(OnMyEvent);
5、触发事件（调用事件的触发方法）。 MyEvent(3);
6、通过事件委托的回调，执行我们需要的事件处理程序。弹出消息框“事件触发，参数

为:3”。
以上实验可以得出结论，C#中的消息通过Application转换成事件以后，通过以上6个步骤完

成了事件与处理程序之间的对应关系，在用户触发事件以后，相应的时间处理程序得到准确

执行。也可通过以上方法，增加用户自定义事件。
========

c#消息处理

http://blog.163.com/zhouchunping_99/blog/static/78379988201052914755764/

一、消息概述

Windows下应用程序的执行是通过消息驱动的。消息是整个应用程序的工作引擎，我们

需要理解掌握我们使用的编程语言是如何封装消息的原理。

1 什么是消息(Message)

消息就是通知和命令。在.NET框架类库中的System.Windows.Forms命名空间中微软采

用面对对象的方式重新定义了Message。新的消息(Message)结构的公共部分属性基本与早

期的一样，不过它是面对对象的。
公共属性：

HWnd 获取或设定消息的处理函数
Msg 获取或设定消息的ID号
Lparam 指定消息的LParam字段
Wparam 指定消息的WParam字段
Result 指定为响应消息处理函数而向OS系统返回的值

2 消息驱动的过程

所有的外部事件，如键盘输入、鼠标移动、按动鼠标都由OS系统转换成相应的消息发送

到应用程序的消息队列。每个应用程序都有一段相应的程序代码来检索、分发这些消息到对

应的窗体，然后由窗体的处理函数来处理。

二、C#中的消息的封装

C#对消息重新进行了面对对象的封装，在C#中消息被封装成了事件。
System.Windows.Forms.Application类具有用于启动和停止应用程序和线程以及处理

(相当于一个窗体)收到消息后是如何处理消息的？其实，这个问题的分析也就是展示了C#的

消息封装原理。

实现鼠标左键按下的消息的响应(WM_LBUTTONDOWN)

this.MouseDown += new System.Windows.Forms.MouseEventHandler

(this.Form1_MouseDown1);
this.MouseDown += new System.Windows.Forms.MouseEventHandler

(this.Form1_MouseDown2);

private void Form1_MouseDown1(object sender,

System.Windows.Forms.MouseEventArgs e)
{
if(e.Button==System.Windows.Forms.MouseButtons.Left)
System.Windows.Forms.MessageBox.Show("消息被Form1_MouseDown1函数响应

");
}

private void Form1_MouseDown2(object sender,

System.Windows.Forms.MouseEventArgs e)
{
if(e.Button==System.Windows.Forms.MouseButtons.Left)
System.Windows.Forms.MessageBox.Show("消息被Form1_MouseDown2函数响应

");
}

上面this.MouseDown是C#中的一个事件。它的定义如下：

public event MouseEventHandler MouseDown;

而MouseEventHandler的定义为：

public delegate void MouseEventHandler( object sender,MouseEventArgs e);

实际上，上面定义了一个委托类型MouseEventHandler。委托了启用了其它编程语言中

的函数指针的解决方案。与C++的函数指针不同，委托是完全面向对象的，同时封装了对象

实例和方法。本质上，委托把一个实例和该实例上的方法函数封装成一个可调用的实体，它

是面对对象的、安全的。

我们可以把
this.MouseDown += new System.Windows.Forms.MouseEventHandler

(this.Form1_MouseDown1);
这条语句看成向this.MouseDown添加一个函数指针。

事件是对象发送的消息，以发送信号通知操作的发生。引发(触发)事件的对象叫做事件发

送方。捕获事件并对事件作出响应的对象叫做事件接收方。在事件通讯中，事件发送方类并

不知道哪个对象或方法将接收到(处理)它引发的事件。所需要的是在发送方和接收方之间存

在一个媒介(类似指针的机制)。.NET框架定义了一个特殊的类型(Delegate委托)，该类型提

供函数指针的功能。这样，委托就等效于一个类型安全的函数指针或一个回调函数。

前面我们向this.MouseDown事件添加了两个委托。
this.MouseDown += new System.Windows.Forms.MouseEventHandler

(this.Form1_MouseDown1);
this.MouseDown += new System.Windows.Forms.MouseEventHandler

(this.Form1_MouseDown2);
结果，我们的两个函数Form1_MouseDown1、Form1_MouseDown2在我们单击鼠标

左键的时候都会被调用，而且调用的顺序和我们添加委托的顺序一致。

WM_LBUTTONDOWN消息首先被Application类从应用程序消息队列中取出，然后分发

到相应的窗体。窗体使用MouseDown事件中的函数指针调用已经添加的响应函数。所以C#

中的事件字段实质上是一个函数指针列表，用来维护一些消息到达时的响应函数的地址。

三、结论

C#中消息的工作流程：

C#中的消息被Application类从应用程序消息队列中取出，然后分发到消息对应的窗体，

窗体对象的第一个响应函数是对象中的protected override void WndProc(ref

System.Windows.Forms.Message e)方法。
它再根据消息的类型调用默认的消息响应函数(如OnMouseDown)，默认的响应函数然

后根据对象的事件字段(如this.MouseDown )中的函数指针列表，调用用户所加入的响应函

数(如Form1_MouseDown1和Form1_MouseDown2)，而且调用顺序和用户添加顺序一致

。

四、再回首Application类

Application类有一个AddMessageFilter的静态方法，通过它我们可以添加消息筛选器，

以便在向目标传递Windows消息时，检视这些消息。
使用消息筛选器来防止引发特定事件，或在将某事件传递给事件处理程序之前使用消息筛

选器对其执行特殊操作。我们必须提供IMessageFilter接口的一个实现，然后才可以使用消

息筛选器。以下的示范代码将演示在消息发往窗体前我们如何拦截它。我们拦截的同样是

WM_LBUTTONDOWN消息。

using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;

namespace MessageMech3
{
//实现消息过滤器接口
public class CLButtonDownFilter : IMessageFilter
{
public bool PreFilterMessage(ref Message m)
{
if (m.Msg==0x0201)// WM_LBUTTONDOWN
{
System.Windows.Forms.MessageBox.Show("App中鼠标左键按下");
//返回值为true，表示消息已被处理，不要再往后传递，因此消息被截获
//返回值为false，表示消息未被处理，需要再往后传递，因此消息未被截获
return true;
}
return false;
}
}

/// <summary>
/// Summary description for WinForm.
/// </summary>
public class WinForm : System.Windows.Forms.Form
{
/// <summary>
/// Required designer variable.
/// </summary>
private System.Windows.Forms.Label label1;
private System.ComponentModel.Container components = null;

public WinForm()
{
//
// Required for Windows Form Designer support
//
InitializeComponent();

//
// TODO: Add any constructor code after InitializeComponent call
//
//安装自己的过滤器
CLButtonDownFilter MyFilter=new CLButtonDownFilter();
System.Windows.Forms.Application.AddMessageFilter(MyFilter);
}

/// <summary>
/// Clean up any resources being used.
/// </summary>
protected override void Dispose (bool disposing)
{
if (disposing)
{
if (components != null)
{
components.Dispose();
}
}
base.Dispose(disposing);
}

#region Windows Form Designer generated code
/// <summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// </summary>
private void InitializeComponent()
{
this.label1 = new System.Windows.Forms.Label();
this.SuspendLayout();
//
// label1
//
this.label1.BackColor = System.Drawing.Color.Transparent;
this.label1.Dock = System.Windows.Forms.DockStyle.Top;
this.label1.ForeColor = System.Drawing.Color.DarkViolet;
this.label1.Name = "label1";
this.label1.Size = new System.Drawing.Size(440, 32);
this.label1.TabIndex = 0;
this.label1.Text = "演示如何在App对象中处理消息,请点鼠标左键";
this.label1.TextAlign = System.Drawing.ContentAlignment.BottomCenter;
//
// Form1
//
this.AutoScaleBaseSize = new System.Drawing.Size(7, 22);
this.BackColor = System.Drawing.Color.WhiteSmoke;
this.ClientSize = new System.Drawing.Size(440, 273);
this.Controls.AddRange(new System.Windows.Forms.Control[] {this.label1});
this.Font = new System.Drawing.Font("华文行楷", 15F,

System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point,

((System.Byte)(134)));
this.Name = "WinForm";
this.Text = "WinForm";

//消息响应函数的调用顺序和添加委托的顺序一致
//即：以下命令将先调用Form1_MouseDown1再调用Form1_MouseDown2

//通过委托添加自己的鼠标按键消息响应函数1
this.MouseDown += new System.Windows.Forms.MouseEventHandler

(this.Form1_MouseDown1);
//通过委托添加自己的鼠标按键消息响应函数2
this.MouseDown += new System.Windows.Forms.MouseEventHandler

(this.Form1_MouseDown2);

this.ResumeLayout(false);
}
#endregion

/// <summary>
/// 应用程序的主入口点。
/// </summary>
[STAThread]
static void Main()
{
Application.Run(new WinForm()); //启动当前Form线程上的应用程序消息循环
}

//要点1
// 通过C#提供的事件接口添加自己的鼠标按键事件的响应函数
//
private void Form1_MouseDown1(object sender,

System.Windows.Forms.MouseEventArgs e)
{
if(e.Button==System.Windows.Forms.MouseButtons.Left)
System.Windows.Forms.MessageBox.Show("消息被Form1_MouseDown1函数

响应");

}
private void Form1_MouseDown2(object sender,

System.Windows.Forms.MouseEventArgs e)
{
if(e.Button==System.Windows.Forms.MouseButtons.Left)
System.Windows.Forms.MessageBox.Show("消息被Form1_MouseDown2函数

响应");

}
//要点2
//通过覆盖基类的事件引发函数拦截消息
//
protected override void OnMouseDown( MouseEventArgs e)
{
if(e.Button==System.Windows.Forms.MouseButtons.Left)
System.Windows.Forms.MessageBox.Show("消息被OnMouseDown函数响应");

//如果需要截获消息，可将base.OnMouseDown(e);语句注释掉
base.OnMouseDown(e);
}
//要点3
//通过覆盖基类的窗体函数拦截消息
//
protected override void WndProc(ref System.Windows.Forms.Message e)
{
//如果需要截获消息，
//if(e.Msg==0x0201)// WM_LBUTTONDOWN
// System.Windows.Forms.MessageBox.Show("消息被WndProc函数响应");
//else
// base.WndProc(ref e);

//不需要截获消息则为
if(e.Msg==0x0201)// WM_LBUTTONDOWN
System.Windows.Forms.MessageBox.Show("消息被WndProc函数响应");
base.WndProc(ref e);
}

}
}

以上代码我们首先用类CLButtonDownFilter实现了IMessageFilter接口，在WinForm初

始化的时候我们安装了消息筛选器。程序实际执行的时候，在点击鼠标左键的时候，程序仅

仅会弹出一个"App中鼠标左键按下"的消息框。因为我们在消息发往窗体前拦截了它，所以

窗体将接收不到WM_LBUTTONDOWN消息。
如果我们把

if (m.Msg==0x0201)// WM_LBUTTONDOWN
{
System.Windows.Forms.MessageBox.Show("App中鼠标左键按下");
return true;
}
改成

if (m.Msg==0x0201)// WM_LBUTTONDOWN
{
System.Windows.Forms.MessageBox.Show("App中鼠标左键按下");
return false;
}
那么，我们在Application类处理消息后，消息将继续发往窗体。窗体的函数将可以处理

此消息。程序执行效果是顺序弹出5个消息框。
1：<<App中鼠标左键按下>>
2：<<消息被WndProc函数响应>>
3：<<消息被OnMouseDown函数响应>>
4：<<消息被Form1_MouseDown1函数响应>>
5：<<消息被Form1_MouseDown2函数响应>>

其实本文中已经说的挺详细的.弹出的对话框只是为了让你更直观的看出导致的结果.

先定义没过滤时的效果.
this.MouseDown += new System.Windows.Forms.MouseEventHandler

(this.Form1_MouseDown1);
private void Form1_MouseDown1(object sender,

System.Windows.Forms.MouseEventArgs e)
{
if (e.Button == System.Windows.Forms.MouseButtons.Left)
MessageBox.Show("消息被Form1_MouseDown1函数响应");
}
主要有两种方法过滤实现过滤
第一种:
protected override void WndProc(ref Message m)
{
if (m.Msg == 0x0201)
return;
else
base.WndProc(ref m);
}
第二种
不重写WndProc

//实现消息过滤器接口
public class CLButtonDownFilter : IMessageFilter
{
public bool PreFilterMessage(ref Message m)
{
if (m.Msg == 0x0201)// WM_LBUTTONDOWN
{
//返回值为true，表示消息已被处理，不要再往后传递，因此消息被截获
//返回值为false，表示消息未被处理，需要再往后传递，因此消息未被截获
return true;
}
return false;
}
}

CLButtonDownFilter MyFilter = new CLButtonDownFilter();
System.Windows.Forms.Application.AddMessageFilter(MyFilter);
========

c# Windows消息处理过程探究

http://blog.csdn.net/jjjfox/article/details/7360378
一、消息概述

Windows下应用程序的执行是通过消息驱动的。消息是整个应用程序的工作引擎，我们

需要理解掌握编程语言是如何封装消息的原理。

1 什么是消息(Message)

消息就是通知和命令。在.NET框架类库中的System.Windows.Forms命名空间中微软采

用面对对象的方式重新定义了Message。新的消息(Message)结构的公共部分属性基本与早

期的一样，不过它是面对对象的。
公共属性：

2 消息驱动的过程

所有的外部事件，如键盘输入、鼠标移动、按动鼠标都由OS系统转换成相应的消息发送到

应用程序的消息队列。每个应用程序都有一段相应的程序代码来检索、分发这些消息到对应

的窗体，然后由窗体的处理函数来处理。

二、C#中的消息的封装

C#对消息重新进行了面对对象的封装，在C#中消息被封装成了事件。
System.Windows.Forms.Application类具有用于启动和停止应用程序和线程以及处理

相当于一个窗体)收到消息后是如何处理消息的？其实，这个问题的分析也就是展示了C#的

消息封装原理。

三、C#中消息的工作流程：

1、 Application类有一个AddMessageFilter的静态方法，通过它我们可以添加消息筛选器

，以便在向目标传递Windows消息时，检视这些消息。
使用消息筛选器来防止引发特定事件，或在将某事件传递给事件处理程序之前使用消息

筛选器对其执行特殊操作。

我们必须提供IMessageFilter接口的一个实现，然后才可以使用消息筛选器。

2、 C#中的消息被Application类从应用程序消息队列中取出，如果有消息筛选器，先执行

消息筛选，然后分发到消息对应的窗体。

1）窗体对象的第一个响应函数是窗口过程函数，即对象中的protected override void

WndProc(ref System.Windows.Forms.Message e)方法。

2）再根据消息的类型调用默认的消息响应函数(如OnMouseDown)

3）再根据用户自定义的事件处理函数，按订阅顺序分别执行(如

Form1_MouseDown1)。

四、示例：
namespace WindowsApplication27
{
partial class Form1
{
/// <summary>
/// 必需的设计器变量。
/// </summary>
private System.ComponentModel.IContainer components = null;

/// <summary>
/// 清理所有正在使用的资源。
/// </summary>
/// <param name="disposing">如果应释放托管资源，为 true；否则为 false。

</param>
protected override void Dispose(bool disposing)
{
if (disposing && (components != null))
{
components.Dispose();
}
base.Dispose(disposing);
}

#region Windows 窗体设计器生成的代码

/// <summary>
/// 设计器支持所需的方法 - 不要
/// 使用代码编辑器修改此方法的内容。
/// </summary>
private void InitializeComponent()
{
this.SuspendLayout();
//
// Form1
//
this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 12F);
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
this.ClientSize = new System.Drawing.Size(292, 266);
this.Name = "Form1";
this.Text = "Form1";

//这里订阅了事件
this.MouseDown += new System.Windows.Forms.MouseEventHandler

(this.Form1_MouseDown);
this.ResumeLayout(false);

}

#endregion

}
}

using System;

using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

namespace WindowsApplication27
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();

Application.AddMessageFilter((new msgFilter()));
}

private void Form1_MouseDown(object sender, MouseEventArgs e)
{
MessageBox.Show("3");
}
protected override void OnMouseDown(MouseEventArgs e)
{
MessageBox.Show("2");
base.OnMouseDown(e);
}

protected override void WndProc(ref Message m)
{
//MouseDown Msg Id
if (m.Msg==0x0201)
MessageBox.Show("1");
base.WndProc(ref m);
}
}

public class msgFilter : IMessageFilter
{
public bool PreFilterMessage(ref Message m)
{

if (m.Msg == 0x0201)
MessageBox.Show("0");
return false;
}
}
static class Program
{
/// <summary>
/// 应用程序的主入口点。
/// </summary>
[STAThread]
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());
}
}
}
========

C#委托与事件、消息、WndProc用法

http://blog.csdn.net/suncherrydream/article/details/8088338

c#用委托来实现事件通知机制。委托相当与c++函数指针。整个过程涉及一个呼叫者，一个

被呼叫者,还有就是这个委托。

- 实现步骤
有以下几步: 1. 申明委托, 2.定义呼叫者和调用的函数， 3.定义被呼叫者和具体实现的函数（

被调用的函数）

1.申明委托，在包里或者类里，public
public delegate void PlayGame(Object sender, EventArgs e);
2.定义呼叫者(类LetsGame）和调用委托的函数，在呼叫者里要有委托的实例（呼叫者扔出

一个委托，被呼叫者给这个委托赋值）
class LetsGame{
public event PlayGame theGame;
public void startPlay(EventArgs e){
if(theGame != null){
theGame(this,e);
}
}

3. 定义被呼叫者（类MS）和具体实现的函数（被调用的函数），也就是concrete class的实

现或者叫函数指针实例。打个比方，在一个叫MS的类中实现.MS中对呼叫者中委托的实例进

行赋值.
class MS {
public MS(LetsGame lg) {
lg.theGame += new PlayGame(MSPlayGame);
}
public void MSPlayGame(Object sender, EventArgs e){
Console.WriteLine("Who laughs the last who wins");
}
}

这样当调用LetsGame.startPlay的时候就会调用MS.MSPlayGame.

- 实际应用
对照一下c#的GUI事件处理或者asp.NET的web控件事件处理,能帮我们更好的理解委托和事

件.大家一定很熟悉asp.Net里下面的代码
private void InitializeComponent()
{

this.Button1.Click += new System.EventHandler(this.Button1_Click);

}

private void Button1_Click(object sender, System.EventArgs e)
{
//do sth
}

这就是用委托来实现事件.你可能发现我们并没有给它声明委托对象并通过event关键字来引

用该委托对象，那是因为asp.net早就帮我们做好了该项工作，其委托对象是

System.EventHandler. Button1相当于上面的LetsGame的实例,是呼叫者,Button1_Click是

被呼叫方法.当你click Button1后,Button1就会调用Button1_Click.

-杂项
我觉得这种机制和design pattern里的observer很类似,我们完全可以用observer来达到同样

的效果,但是用委托更灵活,不需要定义一个interface然后所有的concrete class都实现某个方

法,函数指针(委托)更灵活.

还有,委托不一定非要和事件一起用,单独用的时候就是函数指针.

-------------------------------------------------------------------------------
WndProc(ref Message m)
protected override void WndProc(ref Message m)
{
const int WM_SYSCOMMAND = 0x0112;
const int SC_CLOSE = 0xF060;
if (m.Msg == WM_SYSCOMMAND && (int) m.WParam == SC_CLOSE)
{
// 屏蔽传入的消息事件
this.WindowState = FormWindowState.Minimized;
return;
}
base.WndProc(ref m);
}

protected override void WndProc(ref Message m)
{
const int WM_SYSCOMMAND = 0x0112;
const int SC_CLOSE = 0xF060;
const int SC_MINIMIZE = 0xF020;
if (m.Msg == WM_SYSCOMMAND && ((int)m.WParam == SC_MINIMIZE ||

(int)m.WParam == SC_CLOSE))
{
//最小化到系统栏
this.Hide();
return;
}
base.WndProc(ref m);
}

----------------------------------------------
不规则窗体拖动

using System.Runtime.InteropServices;

[DllImport("user32.dll")]
public static extern bool ReleaseCapture();
[DllImport("user32.dll")]
public static extern bool SendMessage(IntPtr hwnd, int wMsg, int wParam, int

lParam);
public const int WM_SYSCOMMAND = 0x0112;
public const int SC_MOVE = 0xF010;
public const int HTCAPTION = 0x0002;

public void ShapedForm_MouseDown(object sender, MouseEventArgs e)
{
ReleaseCapture();
SendMessage(this.Handle, WM_SYSCOMMAND, SC_MOVE + HTCAPTION, 0);
}

-------------------------------------------------------------------
protected override void WndProc(ref Message m)
{
//拦截窗体最小化按钮消息，调用隐藏动画并隐藏窗体
if (m.Msg == (int)hyFrameWork.win32Api.Enum.WinMsg.WM_SYSCOMMAND)
{
if (m.WParam.ToInt32() == (int)

hyFrameWork.win32Api.Enum.ECNCSysCommandConstants.SC_MINIMIZE)
{
formShowControl(false);
return;
}
}
base.WndProc(ref m);
}
-------------------------------------------
大体的消息说明,你自己看吧
WM_NULL = $0000;
WM_CREATE = $0001;
应用程序创建一个窗口
WM_DESTROY = $0002;
一个窗口被销毁
WM_MOVE = $0003;
移动一个窗口
WM_SIZE = $0005;
改变一个窗口的大小
WM_ACTIVATE = $0006;
一个窗口被激活或失去激活状态；
WM_SETFOCUS = $0007;
获得焦点后
WM_KILLFOCUS = $0008;
失去焦点
WM_ENABLE = $000A;
改变enable状态
WM_SETREDRAW = $000B;
设置窗口是否能重画
WM_SETTEXT = $000C;
应用程序发送此消息来设置一个窗口的文本
WM_GETTEXT = $000D;
应用程序发送此消息来复制对应窗口的文本到缓冲区
WM_GETTEXTLENGTH = $000E;
得到与一个窗口有关的文本的长度（不包含空字符）
WM_PAINT = $000F;
要求一个窗口重画自己
WM_CLOSE = $0010;
当一个窗口或应用程序要关闭时发送一个信号
WM_QUERYENDSESSION = $0011;
当用户选择结束对话框或程序自己调用ExitWindows函数
WM_QUIT = $0012;
用来结束程序运行或当程序调用postquitmessage函数
WM_QUERYOPEN = $0013;
当用户窗口恢复以前的大小位置时，把此消息发送给某个图标
WM_ERASEBKGND = $0014;
当窗口背景必须被擦除时（例在窗口改变大小时）
WM_SYSCOLORCHANGE = $0015;
当系统颜色改变时，发送此消息给所有顶级窗口
WM_ENDSESSION = $0016;
当系统进程发出WM_QUERYENDSESSION消息后，此消息发送给应用程序，
通知它对话是否结束
WM_SYSTEMERROR = $0017;
WM_SHOWWINDOW = $0018;
当隐藏或显示窗口是发送此消息给这个窗口
WM_ACTIVATEAPP = $001C;
发此消息给应用程序哪个窗口是激活的，哪个是非激活的；
WM_FONTCHANGE = $001D;
当系统的字体资源库变化时发送此消息给所有顶级窗口
WM_TIMECHANGE = $001E;
当系统的时间变化时发送此消息给所有顶级窗口
WM_CANCELMODE = $001F;
发送此消息来取消某种正在进行的摸态（操作）
WM_SETCURSOR = $0020;
如果鼠标引起光标在某个窗口中移动且鼠标输入没有被捕获时，就发消息给某个窗口
WM_MOUSEACTIVATE = $0021;
当光标在某个非激活的窗口中而用户正按着鼠标的某个键发送此消息给当前窗口
WM_CHILDACTIVATE = $0022;
发送此消息给MDI子窗口当用户点击此窗口的标题栏，或当窗口被激活，移动，改变大小
WM_QUEUESYNC = $0023;
此消息由基于计算机的训练程序发送，通过WH_JOURNALPALYBACK的hook程序
分离出用户输入消息
WM_GETMINMAXINFO = $0024;
此消息发送给窗口当它将要改变大小或位置；
WM_PAINTICON = $0026;
发送给最小化窗口当它图标将要被重画
WM_ICONERASEBKGND = $0027;
此消息发送给某个最小化窗口，仅当它在画图标前它的背景必须被重画
WM_NEXTDLGCTL = $0028;
发送此消息给一个对话框程序去更改焦点位置
WM_SPOOLERSTATUS = $002A;
每当打印管理列队增加或减少一条作业时发出此消息
WM_DRAWITEM = $002B;
当button，combobox，listbox，menu的可视外观改变时发送
此消息给这些空件的所有者
WM_MEASUREITEM = $002C;
当button, combo box, list box, list view control, or menu item 被创建时
发送此消息给控件的所有者
WM_DELETEITEM = $002D;
当the list box 或 combo box 被销毁或当某些项被删除通过LB_DELETESTRING,

LB_RESETCONTENT, CB_DELETESTRING, or CB_RESETCONTENT 消息
WM_VKEYTOITEM = $002E;
此消息有一个LBS_WANTKEYBOARDINPUT风格的发出给它的所有者来响应

WM_KEYDOWN消息
WM_CHARTOITEM = $002F;
此消息由一个LBS_WANTKEYBOARDINPUT风格的列表框发送给他的所有者来响应

WM_CHAR消息
WM_SETFONT = $0030;
当绘制文本时程序发送此消息得到控件要用的颜色
WM_GETFONT = $0031;
应用程序发送此消息得到当前控件绘制文本的字体
WM_SETHOTKEY = $0032;
应用程序发送此消息让一个窗口与一个热键相关连
WM_GETHOTKEY = $0033;
应用程序发送此消息来判断热键与某个窗口是否有关联
WM_QUERYDRAGICON = $0037;
此消息发送给最小化窗口，当此窗口将要被拖放而它的类中没有定义图标，应用程序能
返回一个图标或光标的句柄，当用户拖放图标时系统显示这个图标或光标
WM_COMPAREITEM = $0039;
发送此消息来判定combobox或listbox新增加的项的相对位置
WM_GETOBJECT = $003D;
WM_COMPACTING = $0041;
显示内存已经很少了
WM_WINDOWPOSCHANGING = $0046;
发送此消息给那个窗口的大小和位置将要被改变时，来调用setwindowpos函数或其它窗口

管理函数
WM_WINDOWPOSCHANGED = $0047;
发送此消息给那个窗口的大小和位置已经被改变时，来调用setwindowpos函数或其它窗口

管理函数
WM_POWER = $0048;（适用于16位的windows）
当系统将要进入暂停状态时发送此消息
WM_COPYDATA = $004A;
当一个应用程序传递数据给另一个应用程序时发送此消息
WM_CANCELJOURNAL = $004B;
当某个用户取消程序日志激活状态，提交此消息给程序
WM_NOTIFY = $004E;
当某个控件的某个事件已经发生或这个控件需要得到一些信息时，发送此消息给它的父窗口
WM_INPUTLANGCHANGEREQUEST = $0050;
当用户选择某种输入语言，或输入语言的热键改变
WM_INPUTLANGCHANGE = $0051;
当平台现场已经被改变后发送此消息给受影响的最顶级窗口
WM_TCARD = $0052;
当程序已经初始化windows帮助例程时发送此消息给应用程序
WM_HELP = $0053;
此消息显示用户按下了F1，如果某个菜单是激活的，就发送此消息个此窗口关联的菜单，否

则就
发送给有焦点的窗口，如果当前都没有焦点，就把此消息发送给当前激活的窗口
WM_USERCHANGED = $0054;
当用户已经登入或退出后发送此消息给所有的窗口，当用户登入或退出时系统更新用户的具

体
设置信息，在用户更新设置时系统马上发送此消息；
WM_NOTIFYFORMAT = $0055;
公用控件，自定义控件和他们的父窗口通过此消息来判断控件是使用ANSI还是UNICODE结

构
在WM_NOTIFY消息，使用此控件能使某个控件与它的父控件之间进行相互通信
WM_CONTEXTMENU = $007B;
当用户某个窗口中点击了一下右键就发送此消息给这个窗口
WM_STYLECHANGING = $007C;
当调用SETWINDOWLONG函数将要改变一个或多个窗口的风格时发送此消息给那个窗口
WM_STYLECHANGED = $007D;
当调用SETWINDOWLONG函数一个或多个窗口的风格后发送此消息给那个窗口
WM_DISPLAYCHANGE = $007E;
当显示器的分辨率改变后发送此消息给所有的窗口
WM_GETICON = $007F;
此消息发送给某个窗口来返回与某个窗口有关连的大图标或小图标的句柄；
WM_SETICON = $0080;
程序发送此消息让一个新的大图标或小图标与某个窗口关联；
WM_NCCREATE = $0081;
当某个窗口第一次被创建时，此消息在WM_CREATE消息发送前发送；
WM_NCDESTROY = $0082;
此消息通知某个窗口，非客户区正在销毁
WM_NCCALCSIZE = $0083;
当某个窗口的客户区域必须被核算时发送此消息
WM_NCHITTEST = $0084;//移动鼠标，按住或释放鼠标时发生
WM_NCPAINT = $0085;
程序发送此消息给某个窗口当它（窗口）的框架必须被绘制时；
WM_NCACTIVATE = $0086;
此消息发送给某个窗口仅当它的非客户区需要被改变来显示是激活还是非激活状态；
WM_GETDLGCODE = $0087;
发送此消息给某个与对话框程序关联的控件，widdows控制方位键和TAB键使输入进入此控

件
通过响应WM_GETDLGCODE消息，应用程序可以把他当成一个特殊的输入控件并能处理它
WM_NCMOUSEMOVE = $00A0;
当光标在一个窗口的非客户区内移动时发送此消息给这个窗口 //非客户区为：窗体的标题栏

及窗
的边框体
WM_NCLBUTTONDOWN = $00A1;
当光标在一个窗口的非客户区同时按下鼠标左键时提交此消息
WM_NCLBUTTONUP = $00A2;
当用户释放鼠标左键同时光标某个窗口在非客户区十发送此消息；
WM_NCLBUTTONDBLCLK = $00A3;
当用户双击鼠标左键同时光标某个窗口在非客户区十发送此消息
WM_NCRBUTTONDOWN = $00A4;
当用户按下鼠标右键同时光标又在窗口的非客户区时发送此消息
WM_NCRBUTTONUP = $00A5;
当用户释放鼠标右键同时光标又在窗口的非客户区时发送此消息
WM_NCRBUTTONDBLCLK = $00A6;
当用户双击鼠标右键同时光标某个窗口在非客户区十发送此消息
WM_NCMBUTTONDOWN = $00A7;
当用户按下鼠标中键同时光标又在窗口的非客户区时发送此消息
WM_NCMBUTTONUP = $00A8;
当用户释放鼠标中键同时光标又在窗口的非客户区时发送此消息
WM_NCMBUTTONDBLCLK = $00A9;
当用户双击鼠标中键同时光标又在窗口的非客户区时发送此消息
WM_KEYFIRST = $0100;
WM_KEYDOWN = $0100;
//按下一个键
WM_KEYUP = $0101;
//释放一个键
WM_CHAR = $0102;
//按下某键，并已发出WM_KEYDOWN， WM_KEYUP消息
WM_DEADCHAR = $0103;
当用translatemessage函数翻译WM_KEYUP消息时发送此消息给拥有焦点的窗口
WM_SYSKEYDOWN = $0104;
当用户按住ALT键同时按下其它键时提交此消息给拥有焦点的窗口；
WM_SYSKEYUP = $0105;
当用户释放一个键同时ALT 键还按着时提交此消息给拥有焦点的窗口
WM_SYSCHAR = $0106;
当WM_SYSKEYDOWN消息被TRANSLATEMESSAGE函数翻译后提交此消息给拥有焦点的

窗口
WM_SYSDEADCHAR = $0107;
当WM_SYSKEYDOWN消息被TRANSLATEMESSAGE函数翻译后发送此消息给拥有焦点的

窗口
WM_KEYLAST = $0108;
WM_INITDIALOG = $0110;
在一个对话框程序被显示前发送此消息给它，通常用此消息初始化控件和执行其它任务
WM_COMMAND = $0111;
当用户选择一条菜单命令项或当某个控件发送一条消息给它的父窗口，一个快捷键被翻译
WM_SYSCOMMAND = $0112;
当用户选择窗口菜单的一条命令或当用户选择最大化或最小化时那个窗口会收到此消息
WM_TIMER = $0113; //发生了定时器事件
WM_HSCROLL = $0114;
当一个窗口标准水平滚动条产生一个滚动事件时发送此消息给那个窗口，也发送给拥有它的

控件
WM_VSCROLL = $0115;
当一个窗口标准垂直滚动条产生一个滚动事件时发送此消息给那个窗口也，发送给拥有它的

控件 WM_INITMENU = $0116;
当一个菜单将要被激活时发送此消息，它发生在用户菜单条中的某项或按下某个菜单键，它

允许
程序在显示前更改菜单
WM_INITMENUPOPUP = $0117;
当一个下拉菜单或子菜单将要被激活时发送此消息，它允许程序在它显示前更改菜单，而不

要
改变全部
WM_MENUSELECT = $011F;
当用户选择一条菜单项时发送此消息给菜单的所有者（一般是窗口）
WM_MENUCHAR = $0120;
当菜单已被激活用户按下了某个键（不同于加速键），发送此消息给菜单的所有者；
WM_ENTERIDLE = $0121;
当一个模态对话框或菜单进入空载状态时发送此消息给它的所有者，一个模态对话框或菜单

进入空载状态就是在处理完一条或几条先前的消息后没有消息它的列队中等待
WM_MENURBUTTONUP = $0122;
WM_MENUDRAG = $0123;
WM_MENUGETOBJECT = $0124;
WM_UNINITMENUPOPUP = $0125;
WM_MENUCOMMAND = $0126;
WM_CHANGEUISTATE = $0127;
WM_UPDATEUISTATE = $0128;
WM_QUERYUISTATE = $0129;
WM_CTLCOLORMSGBOX = $0132;
在windows绘制消息框前发送此消息给消息框的所有者窗口，通过响应这条消息，所有者窗

口可以
通过使用给定的相关显示设备的句柄来设置消息框的文本和背景颜色
WM_CTLCOLOREDIT = $0133;
当一个编辑型控件将要被绘制时发送此消息给它的父窗口；通过响应这条消息，所有者窗口

可以
通过使用给定的相关显示设备的句柄来设置编辑框的文本和背景颜色
WM_CTLCOLORLISTBOX = $0134;
当一个列表框控件将要被绘制前发送此消息给它的父窗口；通过响应这条消息，所有者窗口

可以
通过使用给定的相关显示设备的句柄来设置列表框的文本和背景颜色
WM_CTLCOLORBTN = $0135;
当一个按钮控件将要被绘制时发送此消息给它的父窗口；通过响应这条消息，所有者窗口可

以
通过使用给定的相关显示设备的句柄来设置按纽的文本和背景颜色
WM_CTLCOLORDLG = $0136;
当一个对话框控件将要被绘制前发送此消息给它的父窗口；通过响应这条消息，所有者窗口

可以
通过使用给定的相关显示设备的句柄来设置对话框的文本背景颜色
WM_CTLCOLORSCROLLBAR= $0137;
当一个滚动条控件将要被绘制时发送此消息给它的父窗口；通过响应这条消息，所有者窗口

可以
通过使用给定的相关显示设备的句柄来设置滚动条的背景颜色
WM_CTLCOLORSTATIC = $0138;
当一个静态控件将要被绘制时发送此消息给它的父窗口；通过响应这条消息，所有者窗口可

以
通过使用给定的相关显示设备的句柄来设置静态控件的文本和背景颜色
WM_MOUSEFIRST = $0200;
WM_MOUSEMOVE = $0200;
// 移动鼠标
WM_LBUTTONDOWN = $0201;
//按下鼠标左键
WM_LBUTTONUP = $0202;
//释放鼠标左键
WM_LBUTTONDBLCLK = $0203;
//双击鼠标左键
WM_RBUTTONDOWN = $0204;
//按下鼠标右键
WM_RBUTTONUP = $0205;
//释放鼠标右键
WM_RBUTTONDBLCLK = $0206;
//双击鼠标右键
WM_MBUTTONDOWN = $0207;
//按下鼠标中键
WM_MBUTTONUP = $0208;
//释放鼠标中键
WM_MBUTTONDBLCLK = $0209;
//双击鼠标中键
WM_MOUSEWHEEL = $020A;
当鼠标轮子转动时发送此消息个当前有焦点的控件
WM_MOUSELAST = $020A;
WM_PARENTNOTIFY = $0210;
当MDI子窗口被创建或被销毁，或用户按了一下鼠标键而光标在子窗口上时发送此消息给它

的父窗口
WM_ENTERMENULOOP = $0211;
发送此消息通知应用程序的主窗口that已经进入了菜单循环模式
WM_EXITMENULOOP = $0212;
发送此消息通知应用程序的主窗口that已退出了菜单循环模式
WM_NEXTMENU = $0213;
WM_SIZING = 532;
当用户正在调整窗口大小时发送此消息给窗口；通过此消息应用程序可以监视窗口大小和位

置
也可以修改他们
WM_CAPTURECHANGED = 533;
发送此消息给窗口当它失去捕获的鼠标时；
WM_MOVING = 534;
当用户在移动窗口时发送此消息，通过此消息应用程序可以监视窗口大小和位置
也可以修改他们；
WM_POWERBROADCAST = 536;
此消息发送给应用程序来通知它有关电源管理事件；
WM_DEVICECHANGE = 537;
当设备的硬件配置改变时发送此消息给应用程序或设备驱动程序
WM_IME_STARTCOMPOSITION = $010D;
WM_IME_ENDCOMPOSITION = $010E;
WM_IME_COMPOSITION = $010F;
WM_IME_KEYLAST = $010F;
WM_IME_SETCONTEXT = $0281;
WM_IME_NOTIFY = $0282;
WM_IME_CONTROL = $0283;
WM_IME_COMPOSITIONFULL = $0284;
WM_IME_SELECT = $0285;
WM_IME_CHAR = $0286;
WM_IME_REQUEST = $0288;
WM_IME_KEYDOWN = $0290;
WM_IME_KEYUP = $0291;
WM_MDICREATE = $0220;
应用程序发送此消息给多文档的客户窗口来创建一个MDI 子窗口
WM_MDIDESTROY = $0221;
应用程序发送此消息给多文档的客户窗口来关闭一个MDI 子窗口
WM_MDIACTIVATE = $0222;
应用程序发送此消息给多文档的客户窗口通知客户窗口激活另一个MDI子窗口，当客户窗口

收到
此消息后，它发出WM_MDIACTIVE消息给MDI子窗口（未激活）激活它；
WM_MDIRESTORE = $0223;
程序发送此消息给MDI客户窗口让子窗口从最大最小化恢复到原来大小
WM_MDINEXT = $0224;
程序发送此消息给MDI客户窗口激活下一个或前一个窗口
WM_MDIMAXIMIZE = $0225;
程序发送此消息给MDI客户窗口来最大化一个MDI子窗口；
WM_MDITILE = $0226;
程序发送此消息给MDI客户窗口以平铺方式重新排列所有MDI子窗口
WM_MDICASCADE = $0227;
程序发送此消息给MDI客户窗口以层叠方式重新排列所有MDI子窗口
WM_MDIICONARRANGE = $0228;
程序发送此消息给MDI客户窗口重新排列所有最小化的MDI子窗口
WM_MDIGETACTIVE = $0229;
程序发送此消息给MDI客户窗口来找到激活的子窗口的句柄
WM_MDISETMENU = $0230;
程序发送此消息给MDI客户窗口用MDI菜单代替子窗口的菜单
WM_ENTERSIZEMOVE = $0231;
WM_EXITSIZEMOVE = $0232;
WM_DROPFILES = $0233;
WM_MDIREFRESHMENU = $0234;
WM_MOUSEHOVER = $02A1;
WM_MOUSELEAVE = $02A3;
WM_CUT = $0300;
程序发送此消息给一个编辑框或combobox来删除当前选择的文本
WM_COPY = $0301;
程序发送此消息给一个编辑框或combobox来复制当前选择的文本到剪贴板
WM_PASTE = $0302;
程序发送此消息给editcontrol或combobox从剪贴板中得到数据
WM_CLEAR = $0303;
程序发送此消息给editcontrol或combobox清除当前选择的内容；
WM_UNDO = $0304;
程序发送此消息给editcontrol或combobox撤消最后一次操作
WM_RENDERFORMAT = $0305；

WM_RENDERALLFORMATS = $0306;
WM_DESTROYCLIPBOARD = $0307;
当调用ENPTYCLIPBOARD函数时发送此消息给剪贴板的所有者
WM_DRAWCLIPBOARD = $0308;
当剪贴板的内容变化时发送此消息给剪贴板观察链的第一个窗口；它允许用剪贴板观察窗口

来
显示剪贴板的新内容；
WM_PAINTCLIPBOARD = $0309;
当剪贴板包含CF_OWNERDIPLAY格式的数据并且剪贴板观察窗口的客户区需要重画；
WM_VSCROLLCLIPBOARD = $030A;
WM_SIZECLIPBOARD = $030B;
当剪贴板包含CF_OWNERDIPLAY格式的数据并且剪贴板观察窗口的客户区域的大小已经改

变是此消息通过剪贴板观察窗口发送给剪贴板的所有者；
WM_ASKCBFORMATNAME = $030C;
通过剪贴板观察窗口发送此消息给剪贴板的所有者来请求一个CF_OWNERDISPLAY格式的剪

贴板的名字
WM_CHANGECBCHAIN = $030D;
当一个窗口从剪贴板观察链中移去时发送此消息给剪贴板观察链的第一个窗口；
WM_HSCROLLCLIPBOARD = $030E;
此消息通过一个剪贴板观察窗口发送给剪贴板的所有者；它发生在当剪贴板包含

CFOWNERDISPALY格式的数据并且有个事件在剪贴板观察窗的水平滚动条上；所有者应滚

动剪贴板图象并更新滚动条的值；
WM_QUERYNEWPALETTE = $030F;
此消息发送给将要收到焦点的窗口，此消息能使窗口在收到焦点时同时有机会实现他的逻辑

调色板
WM_PALETTEISCHANGING= $0310;
当一个应用程序正要实现它的逻辑调色板时发此消息通知所有的应用程序
WM_PALETTECHANGED = $0311;
此消息在一个拥有焦点的窗口实现它的逻辑调色板后发送此消息给所有顶级并重叠的窗口，

以此
来改变系统调色板
WM_HOTKEY = $0312;
当用户按下由REGISTERHOTKEY函数注册的热键时提交此消息
WM_PRINT = 791;
应用程序发送此消息仅当WINDOWS或其它应用程序发出一个请求要求绘制一个应用程序的

一部分；
WM_PRINTCLIENT = 792;
WM_HANDHELDFIRST = 856;
WM_HANDHELDLAST = 863;
WM_PENWINFIRST = $0380;
WM_PENWINLAST = $038F;
WM_COALESCE_FIRST = $0390;
WM_COALESCE_LAST = $039F;
WM_DDE_FIRST = $03E0;
WM_DDE_INITIATE = WM_DDE_FIRST + 0;
一个DDE客户程序提交此消息开始一个与服务器程序的会话来响应那个指定的程序和主题名

；
WM_DDE_TERMINATE = WM_DDE_FIRST + 1;
一个DDE应用程序（无论是客户还是服务器）提交此消息来终止一个会话；
WM_DDE_ADVISE = WM_DDE_FIRST + 2;
一个DDE客户程序提交此消息给一个DDE服务程序来请求服务器每当数据项改变时更新它
WM_DDE_UNADVISE = WM_DDE_FIRST + 3;
一个DDE客户程序通过此消息通知一个DDE服务程序不更新指定的项或一个特殊的剪贴板格

式的项
WM_DDE_ACK = WM_DDE_FIRST + 4;
此消息通知一个DDE（动态数据交换）程序已收到并正在处理WM_DDE_POKE,

WM_DDE_EXECUTE, WM_DDE_DATA, WM_DDE_ADVISE, WM_DDE_UNADVISE, or

WM_DDE_INITIAT消息
WM_DDE_DATA = WM_DDE_FIRST + 5;
一个DDE服务程序提交此消息给DDE客户程序来传递个一数据项给客户或通知客户的一条可

用数据项
WM_DDE_REQUEST = WM_DDE_FIRST + 6;
一个DDE客户程序提交此消息给一个DDE服务程序来请求一个数据项的值；
WM_DDE_POKE = WM_DDE_FIRST + 7;
一个DDE客户程序提交此消息给一个DDE服务程序，客户使用此消息来请求服务器接收一个

未经同意的数据项；服务器通过答复WM_DDE_ACK消息提示是否它接收这个数据项；
WM_DDE_EXECUTE = WM_DDE_FIRST + 8;
一个DDE客户程序提交此消息给一个DDE服务程序来发送一个字符串给服务器让它象串行命

令一样被处理，服务器通过提交WM_DDE_ACK消息来作回应；
WM_DDE_LAST = WM_DDE_FIRST + 8;
WM_APP = $8000;
WM_USER = $0400;
此消息能帮助应用程序自定义私有消息；
/
通知消息(Notification message)是指这样一种消息，一个窗口内的子控件发生了一些事情

，需要通
知父窗口。通知消息只适用于标准的窗口控件如按钮、列表框、组合框、编辑框，以及

Windows 95公
共控件如树状视图、列表视图等。例如，单击或双击一个控件、在控件中选择部分文本、操

作控件的
滚动条都会产生通知消息。
按扭
B N _ C L I C K E D //用户单击了按钮
B N _ D I S A B L E //按钮被禁止
B N _ D O U B L E C L I C K E D //用户双击了按钮
B N _ H I L I T E //用户加亮了按钮
B N _ PA I N T按钮应当重画
B N _ U N H I L I T E加亮应当去掉
组合框
C B N _ C L O S E U P组合框的列表框被关闭
C B N _ D B L C L K用户双击了一个字符串
C B N _ D R O P D O W N组合框的列表框被拉出
C B N _ E D I T C H A N G E用户修改了编辑框中的文本
C B N _ E D I T U P D AT E编辑框内的文本即将更新
C B N _ E R R S PA C E组合框内存不足
C B N _ K I L L F O C U S组合框失去输入焦点
C B N _ S E L C H A N G E在组合框中选择了一项
C B N _ S E L E N D C A N C E L用户的选择应当被取消
C B N _ S E L E N D O K用户的选择是合法的
C B N _ S E T F O C U S组合框获得输入焦点
编辑框
E N _ C H A N G E编辑框中的文本己更新
E N _ E R R S PA C E编辑框内存不足
E N _ H S C R O L L用户点击了水平滚动条
E N _ K I L L F O C U S编辑框正在失去输入焦点
E N _ M A X T E X T插入的内容被截断
E N _ S E T F O C U S编辑框获得输入焦点
E N _ U P D AT E编辑框中的文本将要更新
E N _ V S C R O L L用户点击了垂直滚动条消息含义
列表框
L B N _ D B L C L K用户双击了一项
L B N _ E R R S PA C E列表框内存不够
L B N _ K I L L F O C U S列表框正在失去输入焦点
L B N _ S E L C A N C E L选择被取消
L B N _ S E L C H A N G E选择了另一项
L B N _ S E T F O C U S列表框获得输入焦点
------------------------------------------------------------------
static bool flag = false;
protected override void WndProc(ref Message m)//C# 重写 WndProc 移动窗口
{
switch (m.Msg) {
case 0x0200: //WM_MOUSEMOVE
if (flag)
{
PostMessage(this.Handle, 0x00A1,new IntPtr(2),m.LParam);//这里

需要导入 user32.dll
}
break;
case 0x201://WM_LBUTTONDOWN
flag = true;
break;
case 0x202://WM_LBUTTONUP
flag = false;

break;

default:
base.WndProc(ref m);
break;
}

[DllImport("user32.dll", CharSet = CharSet.Unicode)]
public static extern IntPtr PostMessage(IntPtr hwnd, int wMsg, IntPtr wParam,

IntPtr lParam);
------------------------------------------------------------
[DllImport("user32.dll")]
public static extern IntPtr SendMessage(IntPtr hWnd, int msg, int wparam, int

lparam);
protected override void OnMouseDown(MouseEventArgs e)
{
base.OnMouseDown(e); if (e.Button == MouseButtons.Left)//按下的是鼠标左

键
{
Capture = false;//释放鼠标，使能够手动操作
SendMessage(Handle, 0x00A1, 2, 0);//拖动窗体
}
}
--------------------------------------------------------
protected override void WndProc(ref Message m)
{
switch (m.Msg)
{
case 0x0201://鼠标左键按下的消息
m.Msg = 0x00A1;//更改消息为非客户区按下鼠标
m.LParam = IntPtr.Zero;//默认值
m.WParam = new IntPtr(2);//鼠标放在标题栏内
break;
}
base.WndProc(ref m);
}
----------------------------------------------------

重写 WndProc函数来同时实现无标题栏的窗体移动和禁止双击窗体最大化

protected override void WndProc(ref Message m)
{
const int WM_NCHITTEST = 0x84;
const int HTCLIENT = 0x01;
const int HTCAPTION = 0x02;
const int WM_SYSCOMMAND = 0x112;
const int SC_MAXMIZE = 0xF030;
const int WM_NCLBUTTONDBLCLK = 0xA3;
switch (m.Msg)
{
case 0x4e:
case 0xd:
case 0xe:
case 0x14:
base.WndProc(ref m);
break;
case WM_NCHITTEST://鼠标点任意位置后可以拖动窗体

this.DefWndProc(ref m);
if (m.Result.ToInt32() == HTCLIENT)
{
m.Result = new IntPtr(HTCAPTION);
return;
}
break;
case WM_NCLBUTTONDBLCLK://禁止双击最大化
Console.WriteLine(this.WindowState);

return;

break;

default:

base.WndProc(ref m);
break;
}
}
----------------------------------------------------------
第一步，先在类的级别中申明两个API函数，

　　///注册热键
　　[DllImport("user32.dll")]
　　private static extern bool RegisterHotKey(IntPtr hWnd, int id, uint fsModifiers,

Keys vk);
　　///卸载热键
　　[DllImport("user32.dll")]
　　private static extern bool UnregisterHotKey(IntPtr hWnd, int id);

　　注意引入名字空间 System.Runtime.InteropServices;

　　上面两个函数参数的解释：

　　RegisterHotKey 函数中，

　　hWnd为本程序窗口的句柄，在C#的窗口中直接用Handle属性就可以引用窗口句柄

　　id为热键的标示符，是我们自己定义的，因为一个程序中可以定义多个热键，所以要用

这个字段来区别，具体用法见下

　　fsModifiers为激活热键时，是否和系统键组合使用，none:0 Alt:1 Ctrl:2 Shift:4,并且还

可以用或运算来组合使用

　　vk就是要定义的热键，C#中按键都被包含在Keys枚举中

　　UnregisterHotKey 函数中，

　　hWnd和RegisterHotKey 函数中是一样的，id为要卸载的热键标示

　　第二步，在窗口的初始化中注册热键，例如 RegisterHotKey(Handle, 100, 0, Keys.F9);

　　将些热键识别为100，0表示不使用系统键，Keys.F9表示此热键为F9，若要同时按

Shift+Ctrl+F9,则第三个参数应该为 2|4 其实对二进制运算熟悉的朋友，　　　　　　　　

　　　　　　可以立刻算出 2|4=6

　　第三步，可以响应热键了：

　　重写窗体的WndProc函数，具体代码为

　　protected override void WndProc(ref Message m) {
　　//这个if的条件中固定的
　　if (m.Msg == 0x312) {
　　//这个if就在于判断是哪个热键，100对应上面RegisterHotKey函数中的第二个参数
　　if (m.WParam.ToInt32() == 100) {
　　//这里就是响应的函数
　　DoSomething();
　　}
　　}
　　base.WndProc(ref m);
　　}

　　WndProc()函数的功能就是处理Windows消息，在其它地方还将看到这个函数的妙用!

　　第四步，在程序结束的时候调用UnregisterHotKey(Handle,100)卸载此热键!

　　WIN32

　　第一步，在int WINAPI WinMain()函数中,

　　while(GetMessage(&msg,NULL,0,0)){……}

　　之前，注册热键

　　RegisterHotKey(hWnd,100,0,VK_F9)

　　VK_F9为WinUser.h中定义的宏，其他键也是用类似的形式进行定义，不过数字键和字

母键，直接用'0','A'这样的形式

　　第二步，在while(GetMessage(&msg,NULL,0,0)) {……}

　　循环体内，添加代码

　　//这是响应热键条件，从WM_HOTKEY宏的定义中，可以看出来它代表的值为 0x312

，和C#中的if条件是一致的
　　if(msg.message ==WM_HOTKEY)
　　{
　　//这里的条件用来判断热键的标示符
　　if(msg.wParam==100)
　　{
　　//这里调用想要执行的函数
　　DoSomething();
　　}
　　}

　　第三步，在while()循环结束后，调用 UnregisterHotKey(hWnd,100) 卸载热键。

　　MFC

　　第一步，在MFC的窗体中添加其WM_HOTKEY消息的响应，

　　void C热键Dlg::OnHotKey(UINT nHotKeyId, UINT nKey1, UINT nKey2)
　　{
　　//这里用来判断热键的标识符
　　if(nHotKeyId == 100)
　　{
　　//响应函数
　　DoSomething();
　　}
　　CDialog::OnHotKey(nHotKeyId, nKey1, nKey2);
　　}

　　第二步，在MFC窗体的初始化地方，添加注册热键的代码：

　　RegisterHotKey(m_hWnd,100,0,VK_F9);

　　注意上面的字段m_hWnd,是CWnd类中字段，完成由MFC控制，我们只需要在适合地

方引用就可以了。

　　第三步，在窗体销毁的地方调用 UnregisterHotKey(hWnd,100) 卸载热键就可以了。

　　到这里，大家可以已经掌握了在三种环境中设置系统级热键的方法。笔者的体会是，在

WIN32和C#中方法大概相同，笔者就是在C#的基础上，尝试着在WIN32中实现该功能，结

果一次成功，但是在MFC中就走了一些弯路。
------------------------------------------------------------------------

protected override void WndProc(ref Message m)
{
switch (m.Msg)
{
case 0x0005://change size: WM_SIZE
{
FormWindowState newState = FormWindowState.Normal;
switch (m.WParam.ToInt32())
{
case 0://SIZE_RESTORED
newState = FormWindowState.Normal;
break;
case 1://SIZE_MINIMIZED
newState = FormWindowState.Minimized;
break;
case 2://SIZE_MAXIMIZED
newState = FormWindowState.Maximized;
break;
default:
break;
}

if (newState != this.preWindowState)
{
this.OnWindowStateChanged(new

WindowStateChangedEventArgs(this.preWindowState, newState));
this.preWindowState = newState;
}
}
break;
default:
break;
}
base.WndProc(ref m);
}
#endregion
}
}
========

C# 消息处理学习总结相关推荐

MFC消息处理学习总结
Windows消息机制概述 http://www.cppblog.com/suiaiguo/archive/2009/07/18/90412.html 消息是指什么? 消息系统对于一个win ...
rtsp连接断开_live555学习之RTSP连接建立以及请求消息处理过程
live555 学习之 RTSP 连接建立以及请求消息处理过程 1 , RTSP 连接的建立过程 RTSPServer 类用于构建一个 RTSP 服务器,该类同时在其内部定义了一个 RTSPClie ...
Python进阶_wxpy学习：消息处理
目录: 目录: 前言消息处理消息对象内容数据用户相关群聊相关回复方法转发消息自动处理消息开始运行示例代码已发送消息历史消息前言学习完了python的基本概念和相应操作后,就 ...
[学习总结]6、Android异步消息处理机制完全解析，带你从源码的角度彻底理解
开始进入正题,我们都知道,Android UI是线程不安全的,如果在子线程中尝试进行UI操作,程序就有可能会崩溃.相信大家在日常的工作当中都会经常遇到这个问题,解决的方案应该也是早已烂熟于心,即创建一 ...
【Visual C++】游戏开发笔记十三游戏输入消息处理（二）鼠标消息处理
本系列文章由zhmxy555编写,转载请注明出处. http://blog.csdn.net/zhmxy555/article/details/7405479 作者:毛星云邮箱: happyl ...
Android应用程序消息处理机制（Looper、Handler）分析（2）
我们再回到NativeMessageQueue的构造函数中,看看JNI层的Looper对象的创建过程,即看看它的构造函数是如何实现的,这个Looper类实现在frameworks/base/libs/ ...
一周焦点 | 李彦宏：如果谷歌回来，有信心再赢一次；GitHub深度学习开源项目Top200...
▌业界焦点瞄准超算皇冠:神威E级超算原型机正式启用运算速度达每秒百亿亿次的 E 级计算机,被称作"超级计算机界的下一顶皇冠".8 月 5 日,国产超算研制向着这一皇冠又迈进了一 ...
Android Handler 深入学习(1)
Android 上的应用类似于 Win32 的消息处理机制,也是由消息驱动来工作的.也是会涉及到消息,消息队列,消息循环,以及处理消息的应用层上的消息处理器. 下图为 Looper, Handler, ...
[转]［android深入学习］android窗口管理机制
在学习 WindowManager 接口的时候,了解到这个接口很重要,因为它可以直接与Window Manager(窗口管理器)进行交互,那这个 Window Manager 究竟是怎么一回事呢? 通 ...

C# 消息处理学习总结

C# 收发和处理自定义的WINDOWS消息

C#中消息处理机制(事件与委托)

c#消息处理

c# Windows消息处理过程探究

C#委托与事件、消息、WndProc用法

C# 消息处理学习总结相关推荐

最新文章

热门文章