WM_COPYDATA实现的不同进程间通信

进程间通信，通过SendMessage向另一进程发送WM_COPYDATA消息，实现不同进程间的消息通信。

需求：已写好一个工具软件，想在不更改当前的软件开发的前提下，实现为后面新开发的软件提供数据推送任务。原先想到使用，WCF以实现通信级别的调用，但对于后续新开发的软件来说，所需实现的东西太多（相当于需要实现一个既定接口的服务端）。所以选择使用SendMessage，发送一个WM_COPYDATA以实现对新软件的通知任务。其中主要是需要对传输一个对象级的处理，需要进行序列化及反序列货处理，这是比较重要的一点。其他方面都比较简单，只是单独发一条WM_COPYDATA消息。

一、找到新软件需被通知的窗口（一般是以配置的形式实现）

　　而在原有软件（即主消息推送方）通过既定的扩展软件名称通过：FindWindow函数进行查找对象句柄，以待后续发送消息。

二、发送消息

　　需要创建WM_COPYDATA消息所需的传参结构，默认情况下可以传递字符串，所以如只单独传输字符串，那就没什么问题的，直接简单调用即可。但在此，需要传输的为对象，所以，需要将对象先进行一系列处理，以便格式化为字符串进行传输。在接收方再以逆运算得出传输过来的对象。

三、将对象序列化为字符串及反序列化的操作，通过一个帮助类实现

Demo代码：

传输类：

 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Runtime.InteropServices;
 using System.Runtime.Serialization.Formatters.Binary;
 using System.Text;
 using System.Threading.Tasks;
 namespace Dralee.AppTransferMsg.Common
 {
     [Serializable]
     public class Msg
     {
         public string SentBy { get; set; }
         public string RcvBy { get; set; }
         public string Message { get; set; }
         public DateTime SentOn { get; set; }
         public Msg()
         {
         }
         public Msg(string sentBy, string rcvBy, string msg, DateTime sentOn)
         {
             SentBy = sentBy;
             RcvBy = rcvBy;
             Message = msg;
             SentOn = sentOn;
         }
         public static byte[] Serialize(Msg msg)
         {
             MemoryStream ms = new MemoryStream();
             BinaryFormatter bf = new BinaryFormatter();
             bf.Serialize(ms, msg);
             byte[] buffer = ms.GetBuffer();
             ms.Close();
             return buffer;
             //return Encoding.Unicode.GetString(buffer);
         }
         public static Msg Deserialize(byte[] buffer)
         {
             MemoryStream ms = new MemoryStream(buffer);
             BinaryFormatter bf = new BinaryFormatter();
             Msg msg = (Msg)bf.Deserialize(ms);
             return msg;
         }
     }
     /// <summary>
     /// 传输结构
     /// </summary>
     public struct CopyDataStruct
     {
         public IntPtr dwData;
         public int cbData;
         [MarshalAs(UnmanagedType.LPStr)]
         public string lpData;
     }
 }

转换帮助类：

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 namespace Dralee.AppTransferMsg.Common
 {
     // CreatedBy: Jackie Lee
     // CreatedOn: 2016-08-17
     /// <summary>
     /// 字节数组与字符串互转
     /// </summary>
     public class HexConverter
     {
         /// <summary>
         /// 字节数组转
         /// </summary>
         /// <param name="buffer"></param>
         /// <returns></returns>
         public string ByteToString(byte[] buffer)
         {
             StringBuilder sb = new StringBuilder();
             for(int i = ; i < buffer.Length; ++i)
             {
                 sb.AppendFormat("{0:X2}", buffer[i]);
             }
             return sb.ToString();
         }
         /// <summary>
         /// 字符串转字节数组
         /// </summary>
         /// <param name="str"></param>
         /// <returns></returns>
         public byte[] StringToByte(string str)
         {
             if(string.IsNullOrEmpty(str) || str.Length %  != )
             {
                 return null;
             }
             byte[] buffer = new byte[str.Length / ];
             string hex;
             int j = ;
             for(int i = ; i < buffer.Length;++i)
             {
                 hex = new string(new char[] { str[j], str[j + ]});
                 buffer[i] = HexToByte(hex);
                 j += ;
             }
             return buffer;
         }
         /// <summary>
         /// 双字节字符转byte
         /// </summary>
         /// <param name="hex"></param>
         /// <returns></returns>
         public byte HexToByte(string hex)
         {
             if (hex.Length > )
                 return ;
             char[] hexs = hex.ToArray();
             if(hexs.Length == )
             {
                 return (byte)NumByChar(hexs[]);
             }
             else
             {
                 return (byte)(NumByChar(hexs[]) *  + NumByChar(hexs[]));
             }
         }
         private byte NumByChar(char ch)
         {
             switch(ch)
             {
                 case '': return ;
                 case '': return ;
                 case '': return ;
                 case '': return ;
                 case '': return ;
                 case '': return ;
                 case '': return ;
                 case '': return ;
                 case '': return ;
                 case '': return ;
                 case 'A': return ;
                 case 'B': return ;
                 case 'C': return ;
                 case 'D': return ;
                 case 'E': return ;
                 case 'F': return ;
                 default:
                     return ;
             }
         }
     }
 }

API类：

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.InteropServices;
 using System.Text;
 using System.Threading.Tasks;
 namespace Dralee.AppTransferMsg.Common
 {
     public static class API
     {
         public const int WM_COPYDATA = 0x004A;
         [DllImport("User32.dll", EntryPoint = "FindWindow")]
         public static extern int FindWindow(string lpClassName, string lpWindowName);
         /// <summary>
         /// 发送消息
         /// </summary>
         /// <param name="hwnd">目标句柄</param>
         /// <param name="msg"></param>
         /// <param name="wParam">参数1</param>
         /// <param name="lParam">参数2</param>
         /// <returns></returns>
         [DllImport("User32.dll", EntryPoint = "SendMessage")]
         public static extern int SendMessage(int hwnd, int msg, int wParam, ref CopyDataStruct lParam);
     }
 }

发送端：

 private void btnSend_Click(object sender, EventArgs e)
 {
     Msg msg = new Msg { SentBy = txtSentBy.Text.Trim(), RcvBy = txtRcvBy.Text.Trim(), Message = txtMsg.Text.Trim(), SentOn = DateTime.Parse(txtSentOn.Text) };
     //long size = GC.GetTotalMemory(true);
     int hwnd = API.FindWindow(null, "(测试)->接收者");
     if (hwnd == )
         return;
     string msgStr = new HexConverter().ByteToString(Msg.Serialize(msg));
     CopyDataStruct cds;
     cds.dwData = (IntPtr);
     cds.cbData = (int)msgStr.Length + ;
     cds.lpData = msgStr;

     API.SendMessage(hwnd, API.WM_COPYDATA, ,ref cds);
 }

接收端，通过重写以实现对消息监控：

 protected override void DefWndProc(ref Message m)
 {
     switch(m.Msg)
     {
         case API.WM_COPYDATA:
             CopyDataStruct cds = (CopyDataStruct)m.GetLParam(typeof(CopyDataStruct));
             //Msg msg = (Msg)m.GetLParam(typeof(Msg));
             byte[] buffer = new HexConverter().StringToByte(cds.lpData);
             Msg msg = Msg.Deserialize(buffer);
             txtMsg.Text = msg.Message;
             txtRcvBy.Text = msg.RcvBy;
             txtSentBy.Text = msg.SentBy;
             txtSentOn.Text = msg.SentOn.ToLongDateString();
             break;
         default:
             base.DefWndProc(ref m);
             break;
     }
 }

效果：