C# COPYDATASTRUCT类代码示例

        public static void SendMessage(IntPtr hWnd, string message)
        {
            BinaryFormatter b = new BinaryFormatter();
            MemoryStream stream = new MemoryStream();
            b.Serialize(stream, message);
            stream.Flush();

            // Now move the data into a pointer so we can send
            // it using WM_COPYDATA:
            // Get the length of the data:
            int dataSize = (int)stream.Length;
            if (dataSize > 0)
            {
                byte[] data = new byte[dataSize];
                stream.Seek(0, SeekOrigin.Begin);
                stream.Read(data, 0, dataSize);
                IntPtr ptrData = Marshal.AllocCoTaskMem(dataSize);
                Marshal.Copy(data, 0, ptrData, dataSize);

                COPYDATASTRUCT cds = new COPYDATASTRUCT();
                cds.cbData = dataSize;
                cds.dwData = IntPtr.Zero;
                cds.lpData = ptrData;
                int res = SendMessage(hWnd, WM_COPYDATA, 0, ref cds);

                // Clear up the data:
                Marshal.FreeCoTaskMem(ptrData);
            }

            stream.Close();
        }

        public static int Send(string data, IntPtr windowHandle)
        {
            var cds = new COPYDATASTRUCT();
            cds.dwData = (IntPtr)Marshal.SizeOf(cds);
            cds.cbData = (IntPtr)data.Length;
            cds.lpData = Marshal.StringToHGlobalAnsi(data);

            var ptr = Marshal.AllocCoTaskMem(Marshal.SizeOf(cds));
            Marshal.StructureToPtr(cds, ptr, true);

            try
            {
                const int WM_COPY_DATA = 0x004A;
                var result = SendMessage(windowHandle, WM_COPY_DATA, IntPtr.Zero, ptr);
                return result;
            }
            catch (Exception)
            {
                return 1;
            }
            finally
            {
                Marshal.FreeHGlobal(cds.lpData);
                Marshal.FreeCoTaskMem(ptr);
            }
        }

		/// <summary>
		/// Override for a form's Window Procedure to handle WM_COPYDATA
		/// messages sent by other instances of this class.
		/// </summary>
		/// <param name="m">The Windows Message information.</param>
		protected override void WndProc (ref System.Windows.Forms.Message m )
		{
			if (m.Msg == WM_COPYDATA)
			{
				COPYDATASTRUCT cds = new COPYDATASTRUCT();
				cds = (COPYDATASTRUCT) Marshal.PtrToStructure(m.LParam, typeof(COPYDATASTRUCT));
				if (cds.cbData > 0)
				{
					byte[] data = new byte[cds.cbData];				
					Marshal.Copy(cds.lpData, data, 0, cds.cbData);
					MemoryStream stream = new MemoryStream(data);
					BinaryFormatter b = new BinaryFormatter();
					CopyDataObjectData cdo = (CopyDataObjectData) b.Deserialize(stream);
					
					if (channels.Contains(cdo.Channel))
					{
						DataReceivedEventArgs d = new DataReceivedEventArgs(cdo.Channel, cdo.Data, cdo.Sent);
						OnDataReceived(d);
						m.Result = (IntPtr) 1;
					}				
				}
			}
			else if (m.Msg == WM_DESTROY)
			{
				// WM_DESTROY fires before OnHandleChanged and is
				// a better place to ensure that we've cleared 
				// everything up.
				channels.OnHandleChange();
				base.OnHandleChange();
			}
			base.WndProc(ref m);
		}

 public static extern int SendMessageTimeout(
     IntPtr hwnd,
     uint wMsg,
     IntPtr wParam,
     ref COPYDATASTRUCT lParam,
     SendMessageTimeoutFlags flags,
     uint timeout,
     out IntPtr result);

 public static string ReciveMessage(ref Message m)
 {
     COPYDATASTRUCT mystr = new COPYDATASTRUCT();
     Type mytype = mystr.GetType();
     mystr = (COPYDATASTRUCT)m.GetLParam(mytype);
     string data = mystr.lpData;
     Debug.WriteLine("WM_COPYDATA message:" + data);
     return data;
 }

        private void OnCopyData(ref Message m)
        {
            // Get the COPYDATASTRUCT
            COPYDATASTRUCT cds = new COPYDATASTRUCT();
            cds = (COPYDATASTRUCT)Marshal.PtrToStructure(m.LParam, typeof(COPYDATASTRUCT));

            // The lpData member of COPYDATASTRUCT points to an (unmanaged) FILECONTEXT struct
            FILECONTEXT ht = (FILECONTEXT)Marshal.PtrToStructure(cds.lpData, typeof(FILECONTEXT));

            string strTemp;

            // If the target application opened, created, wrote to, or read from a file...
            if (cds.dwData >= (int)FileAction.File_CreateAlways && cds.dwData <= (int) FileAction.File_Read)
            {
                int unManagedSize = Marshal.SizeOf(typeof(FILECONTEXT));
                unsafe
                {
                    byte* pString = (byte*)cds.lpData.ToPointer();
                    pString += unManagedSize;
                    IntPtr pManString = new IntPtr((void*)pString);
                    strTemp = Marshal.PtrToStringUni(pManString);
                }

                if (cds.dwData <= 5)
                {
                    ListViewItem[] lvs = listOpenFiles.Items.Find(strTemp, true);
                    if (lvs == null || lvs.Length == 0)
                    {
                        ListViewItem lv = listOpenFiles.Items.Insert(listOpenFiles.Items.Count, strTemp);
                        lv.Tag = ht.Handle;
                        lv.Name = strTemp;
                    }
                }
                else
                {
                    int nIndex = strTemp.IndexOf('\n');
                    if (nIndex > -1)
                    {
                        string Intro = strTemp.Substring(0, nIndex);
                        string Other = strTemp.Substring(nIndex);
                        Font oldFont = richFileOps.SelectionFont;
                        richFileOps.SelectionFont = _boldFont;
                        richFileOps.SelectedText = Intro;
                        richFileOps.SelectionFont = oldFont;
                        richFileOps.Select(richFileOps.TextLength, 0);
                        richFileOps.SelectedText = Other;
                    }
                }
                m.Result = (IntPtr)1;
            }
            // If the target application CLOSED a file
            else if (cds.dwData == (int)FileAction.File_Close)
            {
                // TODO: remove the file from the GUI
            }
        }

 public static void _SendMessage(string msg, IntPtr target)
 {
     byte[] b = Encoding.UTF8.GetBytes(msg);
     IntPtr hLog = Marshal.AllocHGlobal(b.Length);
     Marshal.Copy(b, 0, hLog, b.Length);
     COPYDATASTRUCT data = new COPYDATASTRUCT();
     data.cbData = b.Length;
     data.lpData = hLog;
     SendMessage(target, WM_COPYDATA, 0, ref data);
 }

        ///<summary>Send the message to another process (receiver) using WM_COPYDATA.</summary>
        ///<param name="hHost">Handle of the receiver</param>
        ///<param name="msg">Message to be sent</param>
        ///<param name="port">Port on which to send the message</param>
        public bool Send(IntPtr hHost, string msg, int port)
        {
            COPYDATASTRUCT cd = new COPYDATASTRUCT();
            cd.dwData = port;
            cd.cbData = msg.Length+1;
            cd.lpData = Marshal.StringToHGlobalAnsi(msg).ToInt32();

            //IntPtr pcd = Marshal.AllocCoTaskMem(Marshal.SizeOf(cd));	// Alocate memory
            //Marshal.StructureToPtr(cd, pcd, true);					// Converting structure to IntPtr
            int i = SendMessage(hHost, WM_COPYDATA, id, ref cd);
            return i==1 ? true : false;
        }

    ///<summary>Send the textual message to another process (receiver).</summary> 
    ///<param name="Hwnd">Handle of the receiver</param> 
    ///<param name="Text">Message to be sent</param> 
    ///<param name="Port">Port on which to send the message, positive integer</param> 
    public bool Send(IntPtr Hwnd, string Text, int Port)
    {
        COPYDATASTRUCT cd = new COPYDATASTRUCT();
        cd.dwData = (IntPtr)(-Port);                                          //use negative port for textual messages
        cd.cbData = Text.Length + 1;
        cd.lpData = Marshal.StringToHGlobalAnsi(Text);

          //IntPtr pcd = Marshal.AllocCoTaskMem(Marshal.SizeOf(cd));   // Alocate memory
          //Marshal.StructureToPtr(cd, pcd, true);               // Converting structure to IntPtr
        int i = SendMessage(Hwnd, WM_COPYDATA, this.Handle, ref cd);
          return i==1 ? true : false;
    }

        static void Send(Params @params)
        {
            var copyDataMem = IntPtr.Zero;
              var dataPointer = IntPtr.Zero;
              try
              {
            var dataSize = 0;
            dataPointer = IntPtr.Zero;
            if (@params.Send.Data != null)
            {
              // Same algorithm to determine size as in Marshal.StringToHGlobalUni.
              dataSize = (@params.Send.Data.Length + 1) * 2;
              dataPointer = Marshal.StringToHGlobalUni(@params.Send.Data);
            }

            var copyData = new COPYDATASTRUCT
            {
              dwData = new UIntPtr(@params.Send.Message),
              cbData = dataSize,
              lpData = dataPointer
            };

            copyDataMem = Marshal.AllocHGlobal(Marshal.SizeOf(copyData));
            Marshal.StructureToPtr(copyData, copyDataMem, true);
            var result = NativeMethods.SendMessage(@params.Connection.Handle,
                                               NativeConstants.WM_COPYDATA,
                                               @params.Receiver.Handle,
                                               copyDataMem);
            if (result == IntPtr.Zero)
            {
              throw new Win32Exception(Marshal.GetLastWin32Error());
            }

            RxMessageBrokerMinimod.Default.Send(new Log("Sent message {0} to MPC", @params.Send.Info()));
              }
              catch (Exception ex)
              {
            RxMessageBrokerMinimod.Default.Send(new Log("Failed to send message {0} to MPC: {1}",
                                                    @params.Send.Info(),
                                                    ex.Message));
              }
              finally
              {
            if (copyDataMem != IntPtr.Zero)
            {
              Marshal.FreeHGlobal(copyDataMem);
            }
            if (dataPointer != IntPtr.Zero)
            {
              Marshal.FreeHGlobal(dataPointer);
            }
              }
        }

        protected override void WndProc(ref Message m)
        {
            if((m.Msg==WM_COPYDATA) && (m.WParam == id))
            {
                CD = (COPYDATASTRUCT)m.GetLParam(typeof(COPYDATASTRUCT));
                strData = Marshal.PtrToStringAnsi(new IntPtr(CD.lpData), CD.cbData);

                if (OnMessage != null)
                    OnMessage( strData, CD.dwData );

                return;
            }

            base.WndProc(ref m);
        }

        private void SendString(IntPtr wnd)
        {
            string s = "hi2server" +  char.MinValue;
            IntPtr lpData = Marshal.StringToHGlobalAnsi(s);

            COPYDATASTRUCT data = new COPYDATASTRUCT();
            data.dwData = 0;
            data.cbData = s.Length + 1;
            data.lpData = lpData;

            IntPtr lpStruct = Marshal.AllocHGlobal(Marshal.SizeOf(data));

            Marshal.StructureToPtr(data, lpStruct, false);
            SendMessage(wnd, WM_COPYDATA,this.Handle, lpStruct);
        }

        protected override void DefWndProc(ref System.Windows.Forms.Message m)
        {
            string token = "";
            COPYDATASTRUCT mystr;
            Type mytype = null;
            //MessageBox.Show(m.Msg.ToString());
            switch (m.Msg)
            {
                case WM_MESSAGE:
                    mystr = new COPYDATASTRUCT();
                    mytype = mystr.GetType();
                    mystr = (COPYDATASTRUCT)m.GetLParam(mytype);
                    token = mystr.bstrData;

                    eterm_bga.is_eterm_status = mystr.bstrData;
                    eterm_bga.ib_connect_status = false;
                    eterm_bga.ib_dataflag = false;
                    //    MessageBox.Show(this, mystr.bstrData, mystr.bstrCategory);
                    break;

                case WM_DATA:
                    mystr = new COPYDATASTRUCT();
                    mytype = mystr.GetType();
                    mystr = (COPYDATASTRUCT)m.GetLParam(mytype);
                    token = mystr.bstrData;

                    ShowData(token);
                    break;
                case WM_CTX:
                    mystr = new COPYDATASTRUCT();
                    mytype = mystr.GetType();
                    mystr = (COPYDATASTRUCT)m.GetLParam(mytype);
                    token = mystr.bstrToken;
                    CreatingCtx((int)m.WParam, token);
                    break;
                default:
                    base.DefWndProc(ref m);
                    if (eterm_bga.ib_connect_status)
                    {
                        eterm_bga.is_eterm_status = "Host system down";
                        eterm_bga.ib_connect_status = false;
                        eterm_bga.ib_dataflag = false;
                    }

                    break;
            }
        }

        //接收传递的消息
        protected override void DefWndProc(ref Message m)
        {
            switch (m.Msg)
            {
                case WM_COPYDATA:
                    COPYDATASTRUCT mystr = new COPYDATASTRUCT();
                    Type mytype = mystr.GetType();
                    mystr = (COPYDATASTRUCT)m.GetLParam(mytype);
                    receiveMsg = mystr.lpData;

                    displayMessage(receiveMsg);
                    break;
                default:
                    base.DefWndProc(ref m);
                    break;
            }
        }

        public static string DecodeMessage(ref Message message)
        {
            string messageText = string.Empty;

            COPYDATASTRUCT cds = new COPYDATASTRUCT();
            cds = (COPYDATASTRUCT)Marshal.PtrToStructure(message.LParam, typeof(COPYDATASTRUCT));
            if (cds.cbData > 0)
            {
                byte[] data = new byte[cds.cbData];
                Marshal.Copy(cds.lpData, data, 0, cds.cbData);
                MemoryStream stream = new MemoryStream(data);
                BinaryFormatter b = new BinaryFormatter();
                messageText = (string)b.Deserialize(stream);
            }

            return messageText;
        }