C#使用SendMessage实现进程间通信的示例代码

2025-09-21 12:50
文章标签 间通信 示例 c# sendmessage 代码 进程 实现 使用 netcore .net

本文主要是介绍C#使用SendMessage实现进程间通信的示例代码，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

《C#使用SendMessage实现进程间通信的示例代码》在软件开发中,进程间通信（IPC）是关键技术之一,C#通过调用WindowsAPI的SendMessage函数实现这一功能,本文将通过实例介绍...

第一章：SendMessage的底层原理揭秘

核心思想：窗口句柄作为进程通信的"身份证"

// 窗口句柄（HWND）的本质：进程身份的唯一标识符
public class WindowHandleManager
{
    [DllImport("user32.dll", SetLastError = true)]
    private static extern IntPtr Findwindow(string lpClassName, string lpWindowName);

    /// <summary>
    /// 获取目标进程的主窗口句柄
    /// </summary>
    /// <param name="processName">进程名称（不含.exe后缀）</param>
    /// <returns>窗口句柄</returns>
    public static IntPtr GetWindowHandle(string processName)
    {
        // 查找同名进程
        Process[] processes = Process.GetProcessesByName(processName);
        if (processes.Length == 0)
            throw new Exception($"未找到进程 {processName}");

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

        return hWnd;
    }
}

灵魂拷问：

为什么必须通过窗口句柄通信？

Windows系统为每个窗口分配唯一句柄，如同进程的“身份证号”，是跨进程通信的唯一身份验证方式。

第二章：构建跨进程通信桥梁

目标：发送端与接收端的完整握手流程

2.1 定义通信协议

// 自定义消息结构体（必须与C++定义完全一致）
[StructLayout(LayoutKind.Sequential)]
public struct COPYDATASTRUCT
{
    public IntPtr dwData;    // 自定义标识符（如类型ID）
    publicChina编程 int cbData;       // 数据长度（字节数）
    public IntPtr lpData;    // 数据指针
}

// 消息常量定义
public static class WindowMessages
{
    public const uint WM_COPYDATA = 0x004A;  // 标准消息ID
    public const uint CUSTOM_MSG_BASE = 0x8000; // 自定义消息起始点
}

设计哲学：

  • 使用WM_COPYDATA标准消息确保跨语言兼容性
  • dwData字段可扩展为消息类型标识符（如0x0001表示文本，0x0002表示二进制）

2.2 接收端实现

// 接收端窗体类
public class MessageReceiver : Form
{
    protected override void WndProc(ref Message m)
    {
        // 拦截自定义消息
        if (m.Msg == (int)WindowMessages.WM_COPYDATA)
        {
            try
            {
                // 解析消息结构体
                var cds = (COPYDATASTRUCT)Marshal.PtrToStructure(
                    m.LParam,
                    typeof(COPYDATASTRUCT)
                );

                // 将指针转换为字符串
                string receivedData = Marshal.PtrToStringAnsi(cds.lpData);
                
                // 处理数据（示例：显示消息）
                MessageBox.Show($"收到数据: {receivedData}");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"消息处理异常: {ex.Message}");
            }
        }

        base.WndProc(ref m);
    }

    public static void Main()
    {
        Application.Run(new MessageReceiver());
        Console.WriteLine("接收端启动，等待消息...");
    }
}

高级技巧：

  • 使用try-catch包裹消息处理防止程序崩溃
  • 添加日志记录便于调试
  • 使用GCHandle管理内存生命周期（详见下文）

2.3 发送端实现

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

    /// <summary>
    /// 向指定进程发送数据
    /// </summary>
    /// <param name="targetProcessName">目标进程名</param>
    /// <param name="data">要发送的数据</param>
    public static void SendDataToProcess(string targetProcessName, string data)
    {
        // 1. 获取目标进程句柄
        IntPtr hWnd = WindowHandleManager.GetWindowHandle(targetProcessName);

        // 2. 将字符串转换为字节数组
        byte[] bytes = Encoding.UTF8.GetBytes(data);
        
        // 3. 固定内存地址（防止GC回收）
        GCHandle handle = GCHandle.Alloc(bytes, GCHandleType.Pinned);
        try
        {
            // 4. 构造消息结构体
            COPYDATASTRUCT cds = new COPYDATASTRUCT
            {
                dwData = IntPtr.Zero,        // 自定义标识符
                cbData = bytes.Length,       // 数据长度
                lpData = handle.AddrOfPinnedObject() // 数据指针
            };

            // 5. 发送消息
            IntPtr result = SendMessage(
                hWnd, 
                WindowMessages.WM_COPYDATA, 
                IntPtr.Zero, 
                ref cds
编程China编程            );

            // 6. 错误处理
            if (result == IntPtr.Zero)
            {
                int errorCode = Marshal.GetLastWin32Error();
                throw new Exception($"发送失败，错误码：{errorCode}");
            }
        }
        finally
        {
            // 7. 释放内存
            handle.Free();
        }
    }
}

性能优化：

  • 使用GCHandle.Alloc固定内存地址防止GC干扰
  • 批量发送时复用内存缓冲区
  • 添加发送频率限制（如每秒不超过100次）

第三章：突破SendMessage的性能瓶颈

让进程通信速度提升10倍的关键技巧

3.1 异步通信模式

// 异步发送任务（避免阻塞主线程）
public static async Task SendDataAsync(
    string targetProcessName, 
    string data,
    CancellationToken cancellationToken)
{
    await Task.Run(() =>
    {
        try
        {
            SendDataToProcess(targetProcessName, data);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"异步发送异常: {ex.Message}");
        }
    }, cancellationToken);
}

设计原则：

  • 使用Task.Run隔离耗时操作
  • 添加取消令牌支持中断机制
  • 使用ValueTask优化小数据场景

3.2 高吞吐量优化

// 批量发送优化器
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);
        }
    }
}

性能对比：

模式吞吐量（条/秒）适用场景
单条发送50实时性要求高
批量发送500+大批量数据传输

第四章：解决SendMessage的致命缺陷

从理论到实践的全面加固

4.1 窗口句柄失效问题

// 带重试机制的句柄获取
public static IntPtr GetWindowHandleWithRetry(
    string processName, 
    int maxRetries = 5, 
    int retryIntervalMs = 1000)
{
    for (int i = 0; i < maxRetries; i++)
    {
        try
        {
            retpythonurn WindowHandleManager.GetWindowHandle(processName);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"第{i + 1}次尝试失败: {ex.Message}");
            Thread.Sleep(retryIntervalMs);
        }
    }
    throw new Exception("多次尝试获取句柄失败");
}

防御策略：

  • 设置最大重试次数防止单点故障
  • 添加指数退避算法（每次重试间隔翻倍）
  • 集成健康检查接口

4.2 内存泄漏预防

// 使用对象池复用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);
    }
}

内存管理守则：

  • 对象池减少GC压力
  • 显式重置结构体字段
  • 使用弱引用跟踪未释放资源

第五章：扩展应用场景

让SendMessage发挥最大价值

5.1 传输复杂数据结构

// 自定义数据序列化
[StructLayout(LayoutKind.Sequential)]
public struct UserMessage
{
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
    public string Username;
    public int Score;
    public DateTime Timestamp;
}

// 发送复杂结构
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.AddrOfChina编程PinnedObject();
        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();
    }
}

设计考量：

  • 使用StructLayout控制内存布局
  • 添加版本号字段支持协议升级
  • 使用二进制序列化提升效率

5.2 实现双向通信

// 双向通信示例
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)
    {
        // 构造请求
        byte[] requestBytes = Encoding.UTF8.GetBytes(request);
        GCHandle requestHandle = GCHandle.Alloc(requestBytes, GCHandleType.Pinned);
        
        // 注册回调
        IntPtr callbackPtr = Marshal.GetFunctionPointerForDelegate(
            new MessageCallback(OnResponseReceived)
        );
        
        // 发送请求
        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)
    {
        // 处理响应...
    }

    // 服务器端需要实现对应的回调处理
}

双向通信架构：

  • 使用唯一messageId标识会话
  • 回调函数地址作为wParam传递
  • 需要双方约定完整的协议规范

通过本文，你已经掌握了：

  1. SendMessage的底层工作原理
  2. 完整的进程间通信实现方案
  3. 高性能优化策略
  4. 常见异常的防御性编程
  5. 复杂场景的扩展应用

墨工的终极建议：

  • 对于高可靠性场景，建议结合MemoryMappedFile实现共享内存
  • 使用PerformanceCounter监控通信性能
  • 开发可视化调试工具（如Wireshark插件）

以上就是C#使用SendMessage实现进程间通信的示例代码的详细内容，更多关于C# SendMessage进程间通信的资料请关注China编程(www.chinasem.cn)其它相关文章！

这篇关于C#使用SendMessage实现进程间通信的示例代码的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1155956。

相关文章

Kotlin 协程之Channel的概念和基本使用详解

Kotlin 协程之Channel的概念和基本使用详解

《Kotlin协程之Channel的概念和基本使用详解》文章介绍协程在复杂场景中使用Channel进行数据传递与控制,涵盖创建参数、缓冲策略、操作方式及异常处理,适用于持续数据流、多协程协作等,需注... 目录前言launch / async 适合的场景Channel 的概念和基本使用概念Channel 的
阅读更多...
Python Excel 通用筛选函数的实现

Python Excel 通用筛选函数的实现

《PythonExcel通用筛选函数的实现》本文主要介绍了PythonExcel通用筛选函数的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着... 目录案例目的示例数据假定数据来源是字典优化：通用CSV数据处理函数使用说明使用示例注意事项案例目的第一
阅读更多...
JAVA实现亿级千万级数据顺序导出的示例代码

JAVA实现亿级千万级数据顺序导出的示例代码

《JAVA实现亿级千万级数据顺序导出的示例代码》本文主要介绍了JAVA实现亿级千万级数据顺序导出的示例代码,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面... 前提：主要考虑控制内存占用空间，避免出现同时导出，导致主程序OOM问题。实现思路：A.启用线程池
阅读更多...
Python实现中文大写金额转阿拉伯数字

Python实现中文大写金额转阿拉伯数字

《Python实现中文大写金额转阿拉伯数字》在财务票据中,中文大写金额被广泛使用以防止篡改,但在数据处理时,我们需要将其转换为阿拉伯数字形式,下面我们就来看看如何使用Python实现这一转换吧... 目录一、核心思路拆解二、中文数字解析实现三、大单位分割策略四、元角分综合处理五、测试验证六、全部代码在财务票
阅读更多...
使用python制作一款文件粉碎工具

使用python制作一款文件粉碎工具

《使用python制作一款文件粉碎工具》这篇文章主要为大家详细介绍了如何使用python制作一款文件粉碎工具,能够有效粉碎密码文件和机密Excel表格等,感兴趣的小伙伴可以了解一下... 文件粉碎工具：适用于粉碎密码文件和机密的escel表格等等，主要作用就是防止 别人用数据恢复大师把你刚删除的机密的文件恢
阅读更多...
java 恺撒加密/解密实现原理(附带源码)

java 恺撒加密/解密实现原理(附带源码)

《java恺撒加密/解密实现原理(附带源码)》本文介绍Java实现恺撒加密与解密,通过固定位移量对字母进行循环替换,保留大小写及非字母字符,由于其实现简单、易于理解,恺撒加密常被用作学习加密算法的入... 目录Java 恺撒加密/解密实现1. 项目背景与介绍2. 相关知识2.1 恺撒加密算法原理2.2 Ja
阅读更多...
MySQL使用EXISTS检查记录是否存在的详细过程

MySQL使用EXISTS检查记录是否存在的详细过程

《MySQL使用EXISTS检查记录是否存在的详细过程》EXISTS是SQL中用于检查子查询是否返回至少一条记录的运算符,它通常用于测试是否存在满足特定条件的记录,从而在主查询中进行相应操作,本文给大... 目录基本语法示例数据库和表结构1. 使用 EXISTS 在 SELECT 语句中2. 使用 EXIS
阅读更多...
在.NET项目中嵌入Python代码的实践指南

在.NET项目中嵌入Python代码的实践指南

《在.NET项目中嵌入Python代码的实践指南》在现代开发中,.NET与Python的协作需求日益增长,从机器学习模型集成到科学计算,从脚本自动化到数据分析,然而,传统的解决方案（如HTTPAPI或... 目录一、CSnakes vs python.NET：为何选择 CSnakes？二、环境准备：从 Py
阅读更多...
React 记忆缓存的三种方法实现

React 记忆缓存的三种方法实现

《React记忆缓存的三种方法实现》本文主要介绍了React记忆缓存的三种方法实现,包含React.memo、useMemo、useCallback,用于避免不必要的组件重渲染和计算,感兴趣的可以... 目录1. React.memo2. useMemo3. useCallback使用场景与注意事项在 Re
阅读更多...
Nginx实现端口映射的示例代码

Nginx实现端口映射的示例代码

《Nginx实现端口映射的示例代码》本文主要介绍了Nginx实现端口映射的示例代码,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧... 目录1. 找到nginx的部署路径2. 备份原来的配置文件3. 编辑nginx.conf文件4. 在
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2