C#

[DllImport("User32", SetLastError = true)]
public static extern IntPtr SendMessage(IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam);
...

string ManagedString = "A string!";
IntPtr PtrToUnmanagedString = Marshal.StringToHGlobalAnsi(ManagedString);
SendMessage(hwnd, WM_SOMEMESSAGE, IntPtr.Zero, PtrToUnmanagedString);
Marshal.FreeHGlobal(PtrToUnmanagedString);

Mark Salsbery
Microsoft MVP - Visual C++

const char *pANSIstring = (const char *)lParam;

const wchar_t *pUnicodestring = (const wchar_t *)lParam;

Mark Salsbery
Microsoft MVP - Visual C++

eyalbi007 wrote:

Maybe the reason is that each one of the applications (C# and C++) uses different memory space

Mark Salsbery
Microsoft MVP - Visual C++

[StructLayout(LayoutKind.Sequential)]
    struct CopyDataStruct
    {
        public IntPtr dwData;
        public int dataSize;
        public IntPtr data;
    }

    enum WinMessage
    {
        WM_COPYDATA = 0x4A
    }

    class NativeAPI
    {
        [DllImport("User32.dll")]
        public static extern int SendMessage(IntPtr hWnd, WinMessage msg, IntPtr wParam, IntPtr lParam);
        [DllImport("User32.dll", CharSet = CharSet.Auto)]
        public static extern IntPtr FindWindow(string className, string windowName);
    }

private void button1_Click(object sender, EventArgs e)
        {        
            string s = "This is a message from sharp"; // string to send to the native application
            // native window handle
            IntPtr hCWindow = NativeAPI.FindWindow("RECIEVE_DATA", "Recieve_Data");
            // check and handle the not found (null) case here...

            // GetBytes returns the bytes of the string but not the terminating null char
            byte[] tmpStringData = System.Text.Encoding.Unicode.GetBytes(s);
            // so we copy to a new byte array and adding 2 zeros (for unicode)
            byte[] stringData = new byte[tmpStringData.Length + 2];
            Array.Copy(tmpStringData, stringData, tmpStringData.Length);
            stringData[stringData.Length - 2] = stringData[stringData.Length - 1] = 0;
            
            CopyDataStruct cds = new CopyDataStruct();
            cds.dwData = IntPtr.Zero;  // no need for this example
            cds.dataSize = stringData.Length; 
            // pinning the managed array and getting the address
            GCHandle gch_data = GCHandle.Alloc(stringData, GCHandleType.Pinned);
            cds.data = gch_data.AddrOfPinnedObject();
            // pinning the struct also
            GCHandle gch_cds = GCHandle.Alloc(cds, GCHandleType.Pinned); 
            // when sending a WM_COPYDATA msg wParam is the hWnd of the 
            // sender and lParam a pointer to a COPYDATASTRUCT                   
            NativeAPI.SendMessage(hCWindow, WinMessage.WM_COPYDATA, this.Handle, gch_cds.AddrOfPinnedObject());
            // free the handles
            gch_data.Free();
            gch_cds.Free();
        }

case WM_COPYDATA:
    {
    PCOPYDATASTRUCT pcds = (PCOPYDATASTRUCT)lParam;
    MessageBox(0, (LPCTSTR)pcds->lpData, _T("CopyData message"), 0);
    }
    break;

Blue_Boy wrote:

It worth to use it (www.cuil.com) time by time,why not.