PostMessage 的字节数组封送处理

Question

我正在尝试将一些 C++ 代码移植到 C#，我需要做的事情之一是使用 PostMessage 将字节数组传递到另一个进程的窗口。我正在尝试将源代码获取到另一个程序，以便我可以准确地看到它所期望的内容，但与此同时，原始 C++ 代码如下所示：

unsigned long result[5] = {0};
//Put some data in the array
unsigned int res = result[0];
Text winName = "window name";
HWND hWnd = FindWindow(winName.getConstPtr(), NULL);
BOOL result = PostMessage(hWnd, WM_COMMAND, 10, res);

这是我现在拥有的：

[DllImport("User32.dll", SetLastError = true, EntryPoint = "FindWindow")]
public static extern IntPtr FindWindow(String lpClassName, String lpWindowName);

[DllImport("User32.dll", SetLastError = true, EntryPoint = "SendMessage")]
public static extern int SendMessage(IntPtr hWnd, int Msg, int wParam, ref COPYDATASTRUCT lParam);

[StructLayout(LayoutKind.Sequential)]
public struct COPYDATASTRUCT
{
    public int dwData;
    public int cbData;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst=32)]
    public byte[] lpData;
}

public const int WM_COPYDATA = 0x4A;

public static int sendWindowsByteMessage(IntPtr hWnd, int wParam, byte[] data)
{
    int result = 0;

    if (hWnd != IntPtr.Zero)
    {
        int len = data.Length;
        COPYDATASTRUCT cds;
        cds.dwData = wParam;
        cds.lpData = data;
        cds.cbData = len;
        result = SendMessage(hWnd, WM_COPYDATA, wParam, ref cds);
    }

    return result;
}

//*****//

IntPtr hWnd = MessageHelper.FindWindow(null, windowName);
if (hWnd != IntPtr.Zero)
{
    int result = MessageHelper.sendWindowsByteMessage(hWnd, wParam, lParam);
    if (result == 0)
    {
        int errCode = Marshal.GetLastWin32Error();
    }
}

请注意，我必须从在 C++ 中使用 PostMessage 在 C# 中使用 SendMessage。

所以现在发生的情况是，我得到的结果和 errCode 都为 0，我相信这意味着消息未得到处理 - 事实上，查看其他应用程序，我没有看到预期的响应。我已经验证了 hWnd != IntPtr.Zero，所以我认为消息被发布到正确的窗口，但消息数据是错误的。有什么想法我做错了吗？

更新

在尝试了评论中的建议后，我仍然没有任何运气。这是我目前得到的：

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

[StructLayout(LayoutKind.Sequential)]
public struct COPYDATASTRUCT
{
    public IntPtr dwData;
    public int cbData;
    public IntPtr lpData;
}

public struct BYTEARRDATA
{
    public byte[] data;
}

public static IntPtr IntPtrAlloc<T>(T param)
{
    IntPtr retval = Marshal.AllocHGlobal(Marshal.SizeOf(param));
    Marshal.StructureToPtr(param, retval, false);
    return (retval);
}

public static void IntPtrFree(IntPtr preAllocated)
{
    //Ignores errors if preAllocated is IntPtr.Zero!
    if (IntPtr.Zero != preAllocated)
    {
        Marshal.FreeHGlobal(preAllocated); 
        preAllocated = IntPtr.Zero;
    }
}

BYTEARRDATA d;
d.data = data;
IntPtr buffer = IntPtrAlloc(d);

COPYDATASTRUCT cds;
cds.dwData = new IntPtr(wParam);
cds.lpData = buffer;
cds.cbData = Marshal.SizeOf(d);

IntPtr copyDataBuff = IntPtrAlloc(cds);
IntPtr r = SendMessage(hWnd, WM_COPYDATA, IntPtr.Zero, copyDataBuff);
if (r != IntPtr.Zero)
{
    result = r.ToInt32();
}

IntPtrFree(copyDataBuff);
copyDataBuff = IntPtr.Zero;
IntPtrFree(buffer);
buffer = IntPtr.Zero;

这是一个 64 位进程试图联系 32 位进程，所以那里可能有一些东西，但我不确定是什么。

Answer 1

问题是 COPYDATASTRUCT 应该包含一个指针作为最后一个成员，并且您将传递整个数组。

看一下 pinvoke.net 上的示例：http://www.pinvoke。 net/default.aspx/Structures/COPYDATASTRUCT.html

注释后的更多信息：

给出这些定义：

const int WM_COPYDATA = 0x004A;

[StructLayout(LayoutKind.Sequential)]
struct COPYDATASTRUCT
{
    public IntPtr dwData;
    public int cbData;
    public IntPtr lpData;
}
[DllImport("User32.dll", SetLastError = true, EntryPoint = "FindWindow")]
public static extern IntPtr FindWindow(String lpClassName, String lpWindowName);

[DllImport("User32.dll", SetLastError = true, EntryPoint = "SendMessage")]
public static extern IntPtr SendMessage(IntPtr hWnd, int Msg, int wParam, ref COPYDATASTRUCT lParam);

我可以创建两个 .NET 程序来测试 WM_COPYDATA。下面是接收方的窗口过程：

protected override void WndProc(ref Message m)
{
    switch (m.Msg)
    {
        case WM_COPYDATA:
            label3.Text = "WM_COPYDATA received!";
            COPYDATASTRUCT cds = (COPYDATASTRUCT)Marshal.PtrToStructure(m.LParam, typeof(COPYDATASTRUCT)); 
            byte[] buff = new byte[cds.cbData];
            Marshal.Copy(cds.lpData, buff, 0, cds.cbData);
            string msg = Encoding.ASCII.GetString(buff, 0, cds.cbData);
            label4.Text = msg;
            m.Result = (IntPtr)1234;
            return;
    }
    base.WndProc(ref m);
}

以及使用 SendMessage 调用它的代码：

Console.WriteLine("{0} bit process.", (IntPtr.Size == 4) ? "32" : "64");
Console.Write("Press ENTER to run test.");
Console.ReadLine();
IntPtr hwnd = FindWindow(null, "JimsForm");
Console.WriteLine("hwnd = {0:X}", hwnd.ToInt64());
var cds = new COPYDATASTRUCT();
byte[] buff = Encoding.ASCII.GetBytes(TestMessage);
cds.dwData = (IntPtr)42;
cds.lpData = Marshal.AllocHGlobal(buff.Length);
Marshal.Copy(buff, 0, cds.lpData, buff.Length);
cds.cbData = buff.Length;
var ret = SendMessage(hwnd, WM_COPYDATA, 0, ref cds);
Console.WriteLine("Return value is {0}", ret);
Marshal.FreeHGlobal(cds.lpData);

当发送方和接收方都是 32 位进程以及 64 位进程时，这将按预期工作。如果两个进程的“位数”不匹配，它将不起作用。

有多种原因导致此功能不适用于 32/64 或 64/32。想象一下您的 64 位程序想要将此消息发送到 32 位程序。 64 位程序传递的 lParam 值的长度为 8 个字节。但32位程序只能看到其中的4个字节。所以该程序将不知道从哪里获取数据！

即使这有效，COPYDATASTRUCT 结构的大小也是不同的。在 32 位程序中，它包含两个指针和一个 DWORD，总大小为 12 个字节。在 64 位程序中，COPYDATASTRUCT 的长度为 20 字节：两个指针各占 8 字节，以及一个 4 字节长度值。

换个方向你也会遇到类似的问题。

我严重怀疑您是否能让 WM_COPYDATA 适用于 32/64 或 64/32。

Answer 2

这适用于 32 位发送器到 64 位接收器、64 位发送器到 32 位接收器。也可以从 32 到 32、64 到 64 工作。您甚至不需要声明 COPYDATASTRUCT。很简单：

    const int WM_COPYDATA = 0x004A;

    [DllImport("user32.dll", SetLastError = true)]
    static extern IntPtr FindWindow(String lpClassName, String lpWindowName);

    [DllImport("user32.dll", SetLastError = true)]
    static extern IntPtr SendMessage(IntPtr hWnd, int Msg, IntPtr wParam, IntPtr lParam);

    static IntPtr SendMessage(IntPtr hWnd, byte[] array, int startIndex, int length)
    {
        IntPtr ptr = Marshal.AllocHGlobal(IntPtr.Size * 3 + length);
        Marshal.WriteIntPtr(ptr, 0, IntPtr.Zero);
        Marshal.WriteIntPtr(ptr, IntPtr.Size, (IntPtr)length);
        IntPtr dataPtr = new IntPtr(ptr.ToInt64() + IntPtr.Size * 3);
        Marshal.WriteIntPtr(ptr, IntPtr.Size * 2, dataPtr);
        Marshal.Copy(array, startIndex, dataPtr, length);
        IntPtr result = SendMessage(hWnd, WM_COPYDATA, IntPtr.Zero, ptr);
        Marshal.FreeHGlobal(ptr);
        return result;
    }

    private void button1_Click(object sender, EventArgs e)
    {
        IntPtr hWnd = FindWindow(null, "Target Window Tittle");
        byte[] data = System.Text.Encoding.ASCII.GetBytes("this is the sample text");
        SendMessage(hWnd, data, 0, data.Length);
    }

    protected override void WndProc(ref Message m)
    {
        switch (m.Msg)
        {
            case WM_COPYDATA:
                byte[] b = new Byte[Marshal.ReadInt32(m.LParam, IntPtr.Size)];
                IntPtr dataPtr = Marshal.ReadIntPtr(m.LParam, IntPtr.Size * 2);
                Marshal.Copy(dataPtr, b, 0, b.Length);
                string str = System.Text.Encoding.ASCII.GetString(b);
                MessageBox.Show(str);
                // m.Result = put result here;
                return;
        }
        base.WndProc(ref m);
    }

Answer 3

这可能是 32 位与 64 位的问题吗？

尝试将 COPYDATASTRUCT 的 dwData 成员设置为 IntPtr 而不是 int。

有关相关问题，请参阅此线程：

http://www.vistax64.com/net-general/156538-apparent-marshalling-lated-problem-x64-but-works-x86.html

查看 COPYDATASTRUCT 的原始定义：

http://msdn.microsoft.com/en-us/library/ms649010(VS.85).aspx

以下是 ULONG_PTR 在 x64 上的含义：

http://msdn.microsoft.com/en-us/library/aa384255(VS.85).aspx

要存储 64 位指针值，请使用 ULONG_PTR。使用 32 位编译器编译时，ULONG_PTR 值为 32 位；使用 64 位编译器编译时，ULONG_PTR 值为 64 位。

Answer 4

在您的 IntPtrAlloc 函数中，SizeOf(param) 为您提供了什么？我认为这将是对数组的引用的大小，而不是数组内容的大小。因此Windows会将.NET数组引用复制到其他进程中，这是完全没有意义的。

固定数组，并使用 Marshal.UnsafeAddrOfPinnedArrayElement 获取 lpData 的正确值。