.Net中封装Windows 消息实现进程间通讯

      .NET Framework 中对进程间的通讯支持不多，不过Windows API 已经为我们提供了丰富的进程间通讯的特性。我们可以使用Windows API SendMessage、PostMessage来实现windows 窗体之间的通讯。本文就是将SendMessage封装在一个窗体基类WinMsgData中，把它变成类中的一个方法以方便调用，而接收其他窗体的消息则封装成事件通知的形式提供。其中还对接收到的消息做队列处理，避免对消息发送方造成阻塞。所以只要程序中的WinForm从这个基类继承，就可以很方便的与其他的窗体进行通讯了。

下面看看具体的实现吧。
首先在窗体的构造函数中，我使用RegisterWindowMessage为希望通讯的窗体在系统中注册一个消息值。然后执行一个“Connect”的动作，就是使用PostMessage做广播，看看是否有“志同道合”者。代码如下：

1.         public event WindowsMessageHandler OnMessage;
2.         public delegate void WindowsMessageHandler(object sender, 
3.                                                          WindowsMessageEventArgs e);
5.         private const string DefaultAttachWindowMessage 
6.                                                             = "Peanut.DefaultAttachWinMsgString";
7.         private bool connected = false;
8.         private int attachMessage;
9.         private int thisHandle;
10.         private string attachMessageString;
11.         private List<IntPtr> AttachWindows;
12.         private Queue<WindowsMessageEventArgs> incomingMessageQueue 
13.                                        = new Queue<WindowsMessageEventArgs>();
14. public WinMsgData() : this (DefaultAttachWindowMessage){}
16.         public WinMsgData(string attachMessageString)
17.         {
18.              this.thisHandle = this.Handle.ToInt32();
19.             AttachWindows = new List<IntPtr>();
20.             this.attachMessageString = attachMessageString;
21.             this.attachMessage = User32.RegisterWindowMessage(attachMessageString);
22.             Connect();//“连接”
23.         }
25.         private void Connect()
26.         {
27.             if (User32.PostMessage(User32.HWND_BROADCAST, 
28.                                  attachMessage, thisHandle ,1) == 0)//连接
29.                 throw new Exception("PostMessage failed.");
30.             else
31.                 connected = true;
32.         }

调用到Windows API代码如下：
具体如何调用Windows 的API请看Calling Win32 DLLs in C# with P/Invoke。

1. public struct COPYDATASTRUCT
2.     {
3.         public IntPtr dwData;
4.         public int cbData;
5.         [MarshalAs(UnmanagedType.LPStr)]
6.         public string lpData;
7.     }
9.     public class User32
10.     {
11.         public const int WM_COPYDATA = 0x4A;
12.         public const int WM_DESTROY = 0x0002;
13.         public const int WM_QUERYENDSESSION = 0x0011;
14.         public const int WM_QUEUE_NOTIFY = 0x401;
16.         [DllImport("user32")]
17.         public static extern int PostMessage(IntPtr hwnd, int wMsg, int wParam, int lParam);
18.         [DllImport("user32")]
19.         public static extern int RegisterWindowMessage(string lpString);
20.         [DllImport("user32")]
21.         public static extern int SendMessage(IntPtr hWnd, int Msg, 
22.                        int wParam, ref COPYDATASTRUCT lParam);
24.         public static IntPtr HWND_BROADCAST
25.         {
26.             get { return (IntPtr)0xFFFF; }
27.         }
28.     }

 

然后就要重写WndProc来接收处理窗体消息了：

1.  protected override void WndProc(ref Message m)
2.         {
3.             if (m.Msg == attachMessage &
4.                 m.WParam.ToInt32() != 0 &
5.                 m.WParam.ToInt32() != thisHandle )
6.             {
7.                 if (m.LParam.ToInt32() == 1)
8.                     User32.PostMessage(m.WParam, attachMessage, thisHandle, 0);//回复
10.                 if (m.LParam.ToInt32() == -1)
11.                     AttachWindows.Remove(m.WParam);//删除窗体句柄
12.                 else //0，1
13.                     AttachWindows.Add(m.WParam);//保存窗体句柄
14.             }
15.             switch (m.Msg)
16.             {
17.                 case User32.WM_COPYDATA:
18.                     COPYDATASTRUCT copyData = new COPYDATASTRUCT();
19.                     copyData = (COPYDATASTRUCT)m.GetLParam(copyData.GetType());
20.                     MessageNotify(m.WParam.ToInt32(), copyData.lpData);
21.                     break;
22.                 case User32.WM_QUEUE_NOTIFY:
23.                     if (incomingMessageQueue.Count == 0)
24.                         break;
26.                     WindowsMessageEventArgs tempArgs = incomingMessageQueue.Dequeue();
27.                     if (OnMessage != null)
28.                         OnMessage(thisHandle, tempArgs);
30.                     if (incomingMessageQueue.Count > 0)
31.                         User32.PostMessage(this.Handle, User32.WM_QUEUE_NOTIFY, 0, 0); //下一个
32.                     break;
33.                 case User32.WM_QUERYENDSESSION:
34.                 case User32.WM_DESTROY:
35.                     User32.PostMessage(User32.HWND_BROADCAST, 
36.                                   attachMessage, thisHandle, -1);//让其他人删除别再给我发消息
37.                     break;
38.             }
39.             base.WndProc(ref m);
40.         }

 

假如已经有窗体进程已经在运行，那么它就会收到新窗体起来时是所发送的“Connect”消息。上面的代码中第一个if就时处理这个消息的。首先会给消息发送者一个响应。然后会将发送者(窗体的句柄)保存到的列表AttachWindows中。
窗体后面部分就是真正处理通讯消息的部分了。MessageNotify方法首先将消息入队，接着给自己发送一个PostMessage通知自己处理，然后就马上返回。大家可能已经注意到WM_QUEUE_NOTIFY了，不错，这个就是通知自己处理消息的。“处理消息”的就是从消息队列中取出一个消息，将消息作为事件参数触发事件。子窗体只要订阅这个事件，并做处理即可。

上面已经把处理消息的过程讲完了，但还没看到发送消息的部分。下面马上给出。
还是先看代码吧，下面的代码是上面提到的MessageNotify方法及发送消息的方法SendMessage();

 

 

1. private void MessageNotify(int target, string message)
2.         {
3.             incomingMessageQueue.Enqueue(new WindowsMessageEventArgs(target, message));
4.             User32.PostMessage(this.Handle, User32.WM_QUEUE_NOTIFY, 0, 0);
5.         } 
7. public void SendMessage(int tarWin, string message)
8.         {
9.             if (!connected)
10.                 throw new Exception("not connected!");
12.             byte[] bytes = System.Text.Encoding.UTF8.GetBytes(message);
13.             int length = bytes.Length;
15.             COPYDATASTRUCT copyData = new COPYDATASTRUCT();
16.             copyData.dwData = (IntPtr)1;
17.             copyData.lpData = message;
18.             copyData.cbData = length + 1;
20.             System.Threading.Thread.Sleep(100);
21.             try
22.             {
23.                 User32.SendMessage((IntPtr)tarWin, User32.WM_COPYDATA, thisHandle, ref copyData);
24.             }
25.             catch (Exception e)
26.             {
27.                 throw new Exception("windows send message error", e);
28.             }
29.         }

还有消息的参数类：

1. public class WindowsMessageEventArgs : EventArgs
2.     {
3.         [ ==== Fields ==== ]#region [ ==== Fields ==== ]
4.         private int targetWinHandle;
5.         private string data; 
7.         #endregion
9.         public WindowsMessageEventArgs(int targetWinHandle, string data)
10.         {
11.             this.targetWinHandle = targetWinHandle;
12.             this.data = data;
13.         }
15.         [ ==== Properties ==== ]#region [ ==== Properties ==== ]
16.         /**//// <summary>
17.         /// 消息发送者窗体句柄值
18.         /// </summary>
19.         public int TargetWinHandle
20.         {
21.             get { return targetWinHandle; }
22.         }
24.         public string Data
25.         {
26.             get { return data; }
27.         } 
29.         #endregion

子窗体只要从WinMsgData继承，并订阅消息事件：
base.OnMessage += new WinMsgData.WindowsMessageHandler(HandleMyMessage);
要发送消息的时候调用base.SendMessage(yourMessageToSend)就可以了。使用方便。
效果图：