// 窗口句柄（HWND）的本質(zhì)：進(jìn)程身份的唯一標(biāo)識(shí)符
public class WindowHandleManager
{
    [DllImport("user32.dll", SetLastError = true)]
    private static extern IntPtr FindWindow(string lpClassName, string lpWindowName);

    /// <summary>
    /// 獲取目標(biāo)進(jìn)程的主窗口句柄
    /// </summary>
    /// <param name="processName">進(jìn)程名稱（不含.exe后綴）</param>
    /// <returns>窗口句柄</returns>
    public static IntPtr GetWindowHandle(string processName)
    {
        // 查找同名進(jìn)程
        Process[] processes = Process.GetProcessesByName(processName);
        if (processes.Length == 0)
            throw new Exception($"未找到進(jìn)程 {processName}");

        // 獲取主窗口句柄
        IntPtr hWnd = processes[0].MainWindowHandle;
        if (hWnd == IntPtr.Zero)
            throw new Exception("未找到窗口句柄");

        return hWnd;
    }
}

// 自定義消息結(jié)構(gòu)體（必須與C++定義完全一致）
[StructLayout(LayoutKind.Sequential)]
public struct COPYDATASTRUCT
{
    public IntPtr dwData;    // 自定義標(biāo)識(shí)符（如類型ID）
    public int cbData;       // 數(shù)據(jù)長(zhǎng)度（字節(jié)數(shù)）
    public IntPtr lpData;    // 數(shù)據(jù)指針
}

// 消息常量定義
public static class WindowMessages
{
    public const uint WM_COPYDATA = 0x004A;  // 標(biāo)準(zhǔn)消息ID
    public const uint CUSTOM_MSG_BASE = 0x8000; // 自定義消息起始點(diǎn)
}

// 接收端窗體類
public class MessageReceiver : Form
{
    protected override void WndProc(ref Message m)
    {
        // 攔截自定義消息
        if (m.Msg == (int)WindowMessages.WM_COPYDATA)
        {
            try
            {
                // 解析消息結(jié)構(gòu)體
                var cds = (COPYDATASTRUCT)Marshal.PtrToStructure(
                    m.LParam,
                    typeof(COPYDATASTRUCT)
                );

                // 將指針轉(zhuǎn)換為字符串
                string receivedData = Marshal.PtrToStringAnsi(cds.lpData);
                
                // 處理數(shù)據(jù)（示例：顯示消息）
                MessageBox.Show($"收到數(shù)據(jù): {receivedData}");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"消息處理異常: {ex.Message}");
            }
        }

        base.WndProc(ref m);
    }

    public static void Main()
    {
        Application.Run(new MessageReceiver());
        Console.WriteLine("接收端啟動(dòng)，等待消息...");
    }
}

public class ProcessCommunicator
{
    [DllImport("user32.dll", SetLastError = true)]
    private static extern IntPtr SendMessage(
        IntPtr hWnd, 
        uint Msg, 
        IntPtr wParam, 
        ref COPYDATASTRUCT lParam
    );

    /// <summary>
    /// 向指定進(jìn)程發(fā)送數(shù)據(jù)
    /// </summary>
    /// <param name="targetProcessName">目標(biāo)進(jìn)程名</param>
    /// <param name="data">要發(fā)送的數(shù)據(jù)</param>
    public static void SendDataToProcess(string targetProcessName, string data)
    {
        // 1. 獲取目標(biāo)進(jìn)程句柄
        IntPtr hWnd = WindowHandleManager.GetWindowHandle(targetProcessName);

        // 2. 將字符串轉(zhuǎn)換為字節(jié)數(shù)組
        byte[] bytes = Encoding.UTF8.GetBytes(data);
        
        // 3. 固定內(nèi)存地址（防止GC回收）
        GCHandle handle = GCHandle.Alloc(bytes, GCHandleType.Pinned);
        try
        {
            // 4. 構(gòu)造消息結(jié)構(gòu)體
            COPYDATASTRUCT cds = new COPYDATASTRUCT
            {
                dwData = IntPtr.Zero,        // 自定義標(biāo)識(shí)符
                cbData = bytes.Length,       // 數(shù)據(jù)長(zhǎng)度
                lpData = handle.AddrOfPinnedObject() // 數(shù)據(jù)指針
            };

            // 5. 發(fā)送消息
            IntPtr result = SendMessage(
                hWnd, 
                WindowMessages.WM_COPYDATA, 
                IntPtr.Zero, 
                ref cds
            );

            // 6. 錯(cuò)誤處理
            if (result == IntPtr.Zero)
            {
                int errorCode = Marshal.GetLastWin32Error();
                throw new Exception($"發(fā)送失敗，錯(cuò)誤碼：{errorCode}");
            }
        }
        finally
        {
            // 7. 釋放內(nèi)存
            handle.Free();
        }
    }
}

// 異步發(fā)送任務(wù)（避免阻塞主線程）
public static async Task SendDataAsync(
    string targetProcessName, 
    string data,
    CancellationToken cancellationToken)
{
    await Task.Run(() =>
    {
        try
        {
            SendDataToProcess(targetProcessName, data);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"異步發(fā)送異常: {ex.Message}");
        }
    }, cancellationToken);
}

// 批量發(fā)送優(yōu)化器
public class BatchMessageOptimizer
{
    private readonly Queue<string> _messageQueue = new Queue<string>();
    private readonly object _lock = new object();
    private Timer _timer;

    public BatchMessageOptimizer(int intervalMs)
    {
        _timer = new Timer(SendBatch, null, Timeout.Infinite, Timeout.Infinite);
        _timer.Change(intervalMs, intervalMs);
    }

    public void Enqueue(string message)
    {
        lock (_lock)
        {
            _messageQueue.Enqueue(message);
        }
    }

    private void SendBatch(object state)
    {
        List<string> batch;
        lock (_lock)
        {
            batch = _messageQueue.ToList();
            _messageQueue.Clear();
        }

        foreach (var msg in batch)
        {
            ProcessCommunicator.SendDataToProcess("Receiver", msg);
        }
    }
}

// 帶重試機(jī)制的句柄獲取
public static IntPtr GetWindowHandleWithRetry(
    string processName, 
    int maxRetries = 5, 
    int retryIntervalMs = 1000)
{
    for (int i = 0; i < maxRetries; i++)
    {
        try
        {
            return WindowHandleManager.GetWindowHandle(processName);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"第{i + 1}次嘗試失敗: {ex.Message}");
            Thread.Sleep(retryIntervalMs);
        }
    }
    throw new Exception("多次嘗試獲取句柄失敗");
}

// 使用對(duì)象池復(fù)用COPYDATASTRUCT
public class CopyDataPool
{
    private readonly ObjectPool<COPYDATASTRUCT> _pool;

    public CopyDataPool(int initialSize)
    {
        _pool = new ObjectPool<COPYDATASTRUCT>(() => new COPYDATASTRUCT(), initialSize);
    }

    public COPYDATASTRUCT Get()
    {
        return _pool.Get();
    }

    public void Return(COPYDATASTRUCT item)
    {
        // 重置字段
        item.dwData = IntPtr.Zero;
        item.cbData = 0;
        item.lpData = IntPtr.Zero;
        _pool.Return(item);
    }
}

// 自定義數(shù)據(jù)序列化
[StructLayout(LayoutKind.Sequential)]
public struct UserMessage
{
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
    public string Username;
    public int Score;
    public DateTime Timestamp;
}

// 發(fā)送復(fù)雜結(jié)構(gòu)
public static void SendUserMessage(IntPtr hWnd, UserMessage message)
{
    int size = Marshal.SizeOf(message);
    byte[] buffer = new byte[size];
    
    GCHandle handle = GCHandle.Alloc(buffer, GCHandleType.Pinned);
    try
    {
        IntPtr pBuffer = handle.AddrOfPinnedObject();
        Marshal.StructureToPtr(message, pBuffer, false);

        COPYDATASTRUCT cds = new COPYDATASTRUCT
        {
            dwData = (IntPtr)1, // 自定義消息類型
            cbData = size,
            lpData = pBuffer
        };

        SendMessage(hWnd, WindowMessages.WM_COPYDATA, IntPtr.Zero, ref cds);
    }
    finally
    {
        handle.Free();
    }
}

// 雙向通信示例
public class BidirectionalCommunicator
{
    private IntPtr _serverHandle;
    private int _messageId = WindowMessages.CUSTOM_MSG_BASE + 1;

    public void Connect(string serverProcessName)
    {
        _serverHandle = WindowHandleManager.GetWindowHandle(serverProcessName);
    }

    public void SendRequest(string request)
    {
        // 構(gòu)造請(qǐng)求
        byte[] requestBytes = Encoding.UTF8.GetBytes(request);
        GCHandle requestHandle = GCHandle.Alloc(requestBytes, GCHandleType.Pinned);
        
        // 注冊(cè)回調(diào)
        IntPtr callbackPtr = Marshal.GetFunctionPointerForDelegate(
            new MessageCallback(OnResponseReceived)
        );
        
        // 發(fā)送請(qǐng)求
        COPYDATASTRUCT cds = new COPYDATASTRUCT
        {
            dwData = (IntPtr)_messageId,
            cbData = requestBytes.Length,
            lpData = requestHandle.AddrOfPinnedObject()
        };

        IntPtr result = SendMessage(
            _serverHandle, 
            WindowMessages.WM_COPYDATA, 
            callbackPtr, 
            ref cds
        );
        
        requestHandle.Free();
    }

    private void OnResponseReceived(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam)
    {
        // 處理響應(yīng)...
    }

    // 服務(wù)器端需要實(shí)現(xiàn)對(duì)應(yīng)的回調(diào)處理
}