网络版sendmessage（跨进程消息处理demo）

最新推荐文章于 2024-06-18 09:46:36 发布
最新推荐文章于 2024-06-18 09:46:36 发布
阅读量457 收藏
点赞数
分类专栏： sendmessage c 文章标签： 网络 队列 socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42501279/article/details/119253795
版权
本文档展示了如何实现一个本地和网络消息处理的C语言库，包括消息注册、注销、发送和删除功能。此外，还包含了网络通信部分的代码，用于处理TCP服务器和客户端的连接、数据发送与接收。测试工程分别提供了服务端和客户端的示例，实现了进程间的消息传递。
摘要由CSDN通过智能技术生成

一工程分布

1、消息处理工程

消息处理动态库工程

1、本地和网络消息处理

动态库接口定义
bylhMessage.h

#include "dllBase.h"

#ifndef BYLH_MESSAGE_H
#define BYLH_MESSAGE_H

#define MSG_LEN (32)

typedef void(*MSG_HANDLER)( const char* strCmd, void* arg1, void* arg2 );
BYLH_MESSAGE_DLL msg_state  BylhMsgModelInit(int i);//!< i 0:服务端  1：客户端
BYLH_MESSAGE_DLL msg_state  BylhRegMsg(const char msg[MSG_LEN], MSG_HANDLER onCommand);
BYLH_MESSAGE_DLL msg_state  BylhUnRegMsg(const char  msg[MSG_LEN], MSG_HANDLER onCommand);
BYLH_MESSAGE_DLL msg_state  BylhSendMsg(const char msg[MSG_LEN], void * arg1, unsigned int arg1Len, void* arg2, unsigned int arg2Len);


#endif // !BYLH_MESSAGE_H
';

dllBase.h

#pragma once

#ifdef __cplusplus
#define BYLH_MESSAGE_DLL extern "C" 
#else
#ifdef DLL_EXPORT
#define BYLH_MESSAGE_DLL __declspec(dllexport)
#else
#define BYLH_MESSAGE_DLL __declspec(dllimport)
#endif
#endif // !__cplusplus

typedef enum
{
	msg_state_ok,
	msg_state_failed,
	msg_state_para_error,
	msg_state_invalid_handle,
	msg_state_unknow_error,
}msg_state;

typedef enum 
{
	TEST_CMD
}CMD_EN;

typedef struct Link{
	void*  elem;
	struct Link *next;
	int cnt;
}link;
link * initLink();
void destroyLink(link * p);
link * appendElem(link * p, void * pData);
int delElem(link * p, void * pData);
void * pop(link * p);
int linkSize(link * p);

bylhMessage.c部分实现


#pragma pack(push)
#pragma pack(1)
typedef struct  
{
	char msg[MSG_LEN];
	link * funcLink;
	char lock;//!< 锁   线程互斥
}BylhMsgMap;
typedef struct __MsgData
{
	char msg[MSG_LEN];
	char arg1[1024];
	unsigned int arg1Len;
	char arg2[1024];
	unsigned int arg2Len;
}MsgData;
#pragma pack(pop)
static link * g_msgMapLink = NULL;
static net_hd g_msgSerHd = NULL;
static net_hd g_msgClientHd = NULL;
static int g_runningMode = 0;
void etnMsgCallBack(void *pData, unsigned int dataLen)
{
	if (dataLen != sizeof( MsgData ))
		return;
	struct __MsgData * pMsgData = ( MsgData * )pData;
	BylhMsgDel(pMsgData->msg, pMsgData->arg1, pMsgData->arg2);
	//BylhSendMsg(pMsgData->msg, pMsgData->arg1, pMsgData->arg1Len, pMsgData->arg2, pMsgData->arg2Len);
}
BYLH_MESSAGE_DLL msg_state BylhMsgModelInit(int i)
{
	if (i == 0)//!< 服务端
	{
		g_runningMode = 0;
		if (NULL == g_msgSerHd)
			g_msgSerHd = creatTcpServer(6514, etnMsgCallBack);
		return msg_state_ok;
	}
	else//!< 客户端
	{
		g_runningMode = 1;
		if (NULL == g_msgSerHd)
			g_msgSerHd = creatTcpClient("127.0.0.1", 6514, etnMsgCallBack);
		return msg_state_ok;
	}
	return msg_state_failed;
}

BYLH_MESSAGE_DLL msg_state  BylhRegMsg(const char msg[MSG_LEN], MSG_HANDLER onCommand)
{
	if (msg == NULL || onCommand == NULL || strlen(msg) == 0)
		return msg_state_para_error;
	if (g_msgMapLink == NULL)
	{
		g_msgMapLink = initLink();
		if (g_msgMapLink == NULL)
			return msg_state_failed;
	}
	link* temp = g_msgMapLink;
	while (temp->next)
	{
		temp = temp->next;
		if (strcmp(( ( BylhMsgMap  * )( temp->elem ) )->msg, msg) == 0)
		{
			//!< 防止重复注册
			//......
			//!< 注册
			while (( ( BylhMsgMap  * )( temp->elem ) )->lock == 1);
			( ( BylhMsgMap  * )( temp->elem ) )->lock = 1;
			appendElem(( ( BylhMsgMap  * )( temp->elem ) )->funcLink, onCommand);
			( ( BylhMsgMap  * )( temp->elem ) )->lock = 0;
			return msg_state_ok;
		}
	}
	BylhMsgMap * pNewMsg = ( BylhMsgMap * )malloc(sizeof( BylhMsgMap ));
	memset(pNewMsg, 0x0, sizeof( BylhMsgMap ));
	strcpy_s(pNewMsg->msg, MSG_LEN, msg);
	pNewMsg->funcLink = initLink();
	pNewMsg->lock = 0;
	appendElem(pNewMsg->funcLink, onCommand);
	appendElem(g_msgMapLink, pNewMsg);
	return msg_state_ok;
}

BYLH_MESSAGE_DLL msg_state   BylhUnRegMsg(const char msg[MSG_LEN], MSG_HANDLER onCommand)
{
	if (msg == NULL || onCommand == NULL || strlen(msg) == 0)
		return msg_state_para_error;
	if (g_msgMapLink == NULL)
	{
		g_msgMapLink = initLink();
		if (g_msgMapLink == NULL)
			return msg_state_failed;
	}
	link* temp = g_msgMapLink;
	while (temp->next)
	{
		temp = temp->next;
		if (strcmp(( ( BylhMsgMap  * )( temp->elem ) )->msg, msg) == 0)
		{
			while (( ( BylhMsgMap  * )( temp->elem ) )->lock == 1);
			( ( BylhMsgMap  * )( temp->elem ) )->lock = 1;
			delElem(( ( BylhMsgMap  * )( temp->elem ) )->funcLink, onCommand);
			( ( BylhMsgMap  * )( temp->elem ) )->lock = 0;
			return msg_state_ok;
		}
	}
	return msg_state_failed;
}

 msg_state  BylhMsgDel(const char msg[MSG_LEN], void * arg1, void* arg2)
{
	if (msg == NULL || strlen(msg) == 0)
		return msg_state_para_error;
	if (g_msgMapLink == NULL)
	{
		g_msgMapLink = initLink();
		if (g_msgMapLink == NULL)
			return msg_state_failed;
	}
	link* temp = g_msgMapLink;
	while (temp->next)
	{
		temp = temp->next;
		if (strcmp(( ( BylhMsgMap  * )( temp->elem ) )->msg, msg) == 0)
		{

			link* temp2 = ( ( BylhMsgMap  * )( temp->elem ) )->funcLink;
			while (( ( BylhMsgMap  * )( temp->elem ) )->lock == 1);
			( ( BylhMsgMap  * )( temp->elem ) )->lock = 1;
			while (temp2->next)
			{
				temp2 = temp2->next;
				MSG_HANDLER func = ( MSG_HANDLER )( temp2->elem );
				func(msg, arg1, arg2);
			}
			( ( BylhMsgMap  * )( temp->elem ) )->lock = 0;
			return msg_state_ok;
		}
	}
	return msg_state_failed;
}

 BYLH_MESSAGE_DLL msg_state  BylhSendMsg(const char msg[MSG_LEN], void * arg1, unsigned int arg1Len, void* arg2, unsigned int arg2Len)
{
	MsgData * pMsgData = ( MsgData * )malloc(sizeof( MsgData ));
	memset(pMsgData, 0x0, sizeof( MsgData ));
	memcpy(pMsgData->msg, msg, strlen(msg));
	memcpy(pMsgData->arg1, arg1, arg1Len);
	memcpy(pMsgData->arg2, arg2, arg2Len);
	pMsgData->arg1Len = arg1Len;
	pMsgData->arg2Len = arg2Len;
	if (g_runningMode == 0)
	{
		serverSocketSendData(g_msgSerHd, TEST_CMD, sizeof( MsgData ), pMsgData);
	}
	else
	{
		clientSocketSendData(g_msgSerHd, TEST_CMD, sizeof( MsgData ), pMsgData);
	}
	return BylhMsgDel(msg, arg1, arg2);
}

下面是网络部分的处理
netCtl.h

#pragma once
#include "dllBase.h"

#ifndef net_hd
#define  net_hd void*
#endif // !net_hd

typedef void(*ethDataCallBack)( void *pData, unsigned int dataLen );

net_hd creatTcpServer(const int port, ethDataCallBack dataCallBack);
net_hd creatTcpClient(const char * serverIp, const int serverPort, ethDataCallBack dataCallBack);
int clientSocketSendData(net_hd netHd, CMD_EN funEn, unsigned int dataLen, void * dataSrc);
int serverSocketSendData(net_hd netHd, CMD_EN funEn, unsigned int dataLen, void * dataSrc);

netCtl.c

#include "netCtl.h"
#include <stdio.h>
#include<Winsock2.h>
#include<time.h>
#include<string.h>
#include <ws2def.h>
#pragma warning(disable:4996)
#pragma comment(lib,"ws2_32.lib")
#pragma pack(push)
#pragma pack(1)
typedef struct __netHandle{
	SOCKET sk;
	struct sockaddr_in  sa;
	BOOL threadDone;
	link * msgLink;
	link * clientSocketLink;
	net_hd serverHd;
	ethDataCallBack dataRcevCallback;
}netHandle;

typedef struct
{
	unsigned int headerHead;//!< 0x55AAAA55
	CMD_EN funEn;
	unsigned int frameTotleLen;
	unsigned int dataLen;
	void * pData;
}socketFrame;
#pragma pack(pop)

BOOL socketSend(SOCKET sk, unsigned int dataLen, void * dataSrc)
{
#if 0
	puts("recv:");
	for (unsigned int i = 0; i < dataLen; i++)
	{
		printf("%02x ", ( ( char* )dataSrc )[i]);
		if (i % 16 == 0)
			puts("");
	}
	puts("");
#endif
	unsigned int curSend = 0;
	while (curSend < dataLen)
	{
		int n = send(sk, ( ( char* )dataSrc ) + curSend, dataLen - curSend,0);
		if (n <= 0)
			return FALSE;
		curSend += n;
	}
	return TRUE;
}

DWORD WINAPI tcpNewConnectProc(LPVOID p)
{
	netHandle * pNewConnectNetHandle = ( netHandle * )p;
	char * recvData = ( char * )malloc(3 * 1024 * 1024);
	int ret;
	while (pNewConnectNetHandle->threadDone == FALSE)
	{
		memset(recvData, 0x0, 3 * 1024 * 1024);
		ret = recv(pNewConnectNetHandle->sk, recvData, 3*1024*1024, 0);
		if (ret <= 0)
		{
			puts("client disconnect!");
			pNewConnectNetHandle->threadDone = TRUE;
			break;
			continue;
		}
#if 0
		puts("recv:");
		for (int i = 0; i < ret; i++)
		{
			printf("%02x ", ( ( char* )recvData )[i]);
			if (i % 16 == 0)
				puts("");
		}
		puts("");
#endif
		socketFrame * pSocketFrame = ( socketFrame * )recvData;
		if (pSocketFrame->headerHead == 0x55AAAA55)
		{
			char * dataSrc = ( char* )malloc(pSocketFrame->dataLen);
			memcpy(dataSrc, (char*)recvData + sizeof( socketFrame ), pSocketFrame->dataLen);
			if (pNewConnectNetHandle->dataRcevCallback)
			{
				pNewConnectNetHandle->dataRcevCallback(dataSrc, pSocketFrame->dataLen);
			}
			free(dataSrc);
		}
// 		recvData[ret] = '\0';
// 		printf("%s\n", recvData);
// 		send(pNewConnectNetHandle->sk, recvData, strlen(recvData), 0);
	}
	netHandle * serverHd = pNewConnectNetHandle->serverHd;
	delElem(serverHd->clientSocketLink, pNewConnectNetHandle);
	free(pNewConnectNetHandle);
	free(recvData);
	return 0;
}
DWORD WINAPI dataSendProc(LPVOID p)//!< 数据发送线程
{
	unsigned char * sendBuf = ( unsigned char * )malloc(2 * 1024 * 1024);
	netHandle * pServerNetHandle = ( netHandle * )p;
	while (pServerNetHandle->threadDone == FALSE)
	{
		if (linkSize(pServerNetHandle->msgLink))
		{
			//!< todo  套接字分发数据
			if (linkSize(pServerNetHandle->clientSocketLink))
			{
				link * msgRes = pop(pServerNetHandle->msgLink);
				link * skRes = pServerNetHandle->clientSocketLink->next;
				while (msgRes&&msgRes->elem)
				{
					socketFrame * pSocketFrame = ( socketFrame * )msgRes->elem;
					memset(sendBuf, 0x0, 2 * 1024 * 1024);
					memcpy(sendBuf, pSocketFrame, sizeof( socketFrame ));
					memcpy(sendBuf + sizeof( socketFrame ), pSocketFrame->pData, pSocketFrame->dataLen);
					while (skRes&&skRes->elem)
					{
						netHandle* clientSk = ( netHandle* )skRes->elem;
						if (FALSE == socketSend(clientSk->sk, pSocketFrame->frameTotleLen, sendBuf))
						{
							perror("socket send err!");
							return GetLastError();
						}
						skRes = skRes->next;
					}
					free(pSocketFrame->pData);//!< 释放消息内容缓存区
					free(pSocketFrame);//!< 释放消息帧结构缓存区
					msgRes = pop(pServerNetHandle->msgLink);
				}
			}
			
		}
	}
	free(sendBuf);
	return 0;
}


DWORD WINAPI tcpListenProc(LPVOID p)
{
	netHandle * pNetHandle = ( netHandle * )p;
	struct sockaddr_in c_sin;
	int c_sin_len = sizeof( c_sin );
	while (FALSE == pNetHandle->threadDone)
	{
		printf("waiting for connect\n");
		netHandle * pClientNetHandle = ( netHandle* )malloc(sizeof( netHandle ) );
		memset(pClientNetHandle, 0x0, sizeof( netHandle ));
		pClientNetHandle->sk = accept(pNetHandle->sk, ( SOCKADDR * )&pClientNetHandle->sa, &c_sin_len);
		if (pClientNetHandle->sk == INVALID_SOCKET)
			printf("accept() Failed:%d\n", WSAGetLastError());
		else
		{
			pClientNetHandle->serverHd = pNetHandle;
			pClientNetHandle->dataRcevCallback = pNetHandle->dataRcevCallback;
			HANDLE hThread;
			DWORD  threadId;
			appendElem(pNetHandle->clientSocketLink, pClientNetHandle);
			hThread = CreateThread(NULL, 0, tcpNewConnectProc, pClientNetHandle, 0, &threadId); // 创建线程
		}
	}
	return 0;
}

net_hd creatTcpServer(const int port, ethDataCallBack dataCallBack)
{
	WSADATA wsaData;
	if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
	{
		return NULL;
	}
	SOCKET socket_of_server;
	socket_of_server = socket(AF_INET, SOCK_STREAM, 0);
	if (socket_of_server == INVALID_SOCKET)
	{
		printf("socket() Failed:%d\n", WSAGetLastError());
		return NULL;
	}
	struct sockaddr_in s_sin;
	s_sin.sin_family = AF_INET;
	s_sin.sin_port = htons(port);
	s_sin.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
	if (bind(socket_of_server, ( LPSOCKADDR )&s_sin, sizeof( s_sin )) == SOCKET_ERROR)
	{
		printf("blind() Failed:%d\n", WSAGetLastError());
		return NULL;
	}
	if (listen(socket_of_server, 5) == SOCKET_ERROR)
	{
		printf("listen() Failed:%d\n", WSAGetLastError());
		return NULL;
	}
	netHandle * pNetHandle = ( netHandle * )malloc(sizeof( netHandle ));
	memset(pNetHandle, 0x0, sizeof( netHandle ));
	pNetHandle->sk = socket_of_server;
	pNetHandle->msgLink = initLink();//!< 创建消息队列
	pNetHandle->clientSocketLink = initLink();//!< 创建套接字队列
	pNetHandle->dataRcevCallback = dataCallBack;
	HANDLE hThread;
	DWORD  threadId;

	hThread = CreateThread(NULL, 0, dataSendProc, pNetHandle, 0, &threadId); // 创建数据发送线程
	hThread = CreateThread(NULL, 0, tcpListenProc, pNetHandle, 0, &threadId); // 创建监听线程

	return pNetHandle;
}
void destroyTcpServer(net_hd netHd)
{
	netHandle * pNetHandle = ( netHandle * )netHd;
	closesocket(pNetHandle->sk);
	WSACleanup();
	pNetHandle->threadDone = TRUE;//!< 控制进程退出
	destroyLink(pNetHandle->clientSocketLink);
	destroyLink(pNetHandle->msgLink);
	free(pNetHandle);
}
net_hd creatTcpClient(const char * serverIp, const int serverPort, ethDataCallBack dataCallBack)
{
	WSADATA wsaData;
	if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
	{
		return NULL;
	}
	SOCKET socket_client = socket(AF_INET, SOCK_STREAM, 0);
	if (socket_client == INVALID_SOCKET)
	{
		perror(" Failed socket() \n");
		return NULL;
	}
	struct sockaddr_in server_in;
	server_in.sin_family = AF_INET;
	server_in.sin_port = htons(serverPort);
	server_in.sin_addr.S_un.S_addr = inet_addr(serverIp);

	if (connect(socket_client, ( struct sockaddr* )&server_in, sizeof( server_in )) == -1)
	{
		perror(" Failed connect() \n");
		return NULL;
	}
	else
	{
		printf("connect %s.%d\n", inet_ntoa(server_in.sin_addr), server_in.sin_port);
	}
	netHandle * pNetHandle = ( netHandle * )malloc(sizeof( netHandle ));
	netHandle * pNetHandleTmp = ( netHandle * )malloc(sizeof( netHandle ));
	memset(pNetHandle, 0x0, sizeof( netHandle ));
	pNetHandle->sk = socket_client;
	memcpy(pNetHandleTmp, pNetHandle, sizeof( netHandle ));
	pNetHandle->sa = server_in;
	pNetHandle->msgLink = initLink();
	pNetHandle->clientSocketLink = initLink();
	pNetHandle->dataRcevCallback = dataCallBack;
	appendElem(pNetHandle->clientSocketLink, pNetHandleTmp);
	HANDLE hThread;
	DWORD  threadId;

	hThread = CreateThread(NULL, 0, tcpNewConnectProc, pNetHandle, 0, &threadId); // 创建数据接收线程
	hThread = CreateThread(NULL, 0, dataSendProc, pNetHandle, 0, &threadId); // 创建数据发送线程

	return NULL;
}


int serverSocketSendData(net_hd netHd, CMD_EN funEn, unsigned int dataLen, void * dataSrc)
{
	if (NULL == netHd)
		return -1;
	struct __netHandle * pNetHandle = ( netHandle * )netHd;
	socketFrame * pSocketFrame = ( socketFrame * )malloc(sizeof( socketFrame ));
	pSocketFrame->headerHead = 0x55AAAA55;
	pSocketFrame->frameTotleLen = dataLen + sizeof( socketFrame );
	pSocketFrame->funEn = funEn;
	pSocketFrame->dataLen = dataLen;
	pSocketFrame->pData = malloc(dataLen);
	memset(pSocketFrame->pData, 0x0, dataLen);
	memcpy(pSocketFrame->pData, dataSrc, dataLen);
	return NULL == appendElem(pNetHandle->msgLink, pSocketFrame) ? -1 : 0;
}
int clientSocketSendData(net_hd netHd, CMD_EN funEn, unsigned int dataLen, void * dataSrc)
{
	return serverSocketSendData(netHd, funEn, dataLen, dataSrc);
}

2、测试工程(服务端)

服务端

3、测试工程（客户端）

客户端
测试效果
测试

模块主要处理同进程模块间和进程间的带参消息处理。无需句柄，模块自主注册监听消息类型。
比如 在本地和远端都注册了消息“ABCD”，那么当某个模块发送此消息，则远端和本地都会收到此消息。

Spring Cloud Stream 之百万级消息推送实践
AI天才研究院
07-29 1279
随着互联网技术的飞速发展，网站应用、移动应用、物联网设备、游戏领域等越来越多地使用云计算资源。在云平台上部署服务时，由于网络带宽、存储容量等方面的限制，需要通过高效的数据流传输方式来提升性能和降低成本。即使在微小数据量下，如IoT设备或者移动应用程序数据上传，也会产生海量数据需要处理。因此，如何有效地处理海量数据的传输成为企业面临的新课题。
Spark基础学习笔记31：Kafka分布式消息系统
howard2005的专栏
05-17 890
本文详细介绍了Kafka，一个基于发布订阅的消息系统。内容涵盖Kafka的基本概念，如消息、服务器节点、主题、分区、生产者和消费者，以及Kafka的架构、数据存储机制、消费者组、集群搭建和Java API操作。文章强调了Kafka的高吞吐量、低延迟特性和数据一致性，展示了如何通过Kafka实现大规模数据处理和实时消息传输。
跨进程通信SendMessage - VB.NET
04-23
跨进程通信SendMessage - VB.NET, WM_SETTEXT, WM_GETTEXT
关于多线程中使用SendMessage
wangandy7811的专栏
08-20 7918
如果，窗口是由非主线程创建的，那么，那个线程将会跑一个自己的窗口消息队列。调用SendMessage会切换到该线程上去执行。 主线程是个窗口线程，在另外一个工作线程中调用了窗口线程的SendMessage，那么执行的过程是： 1.工作线程挂起 2.切换到窗口线程，执行对应的消息处理 3.切换回工作线程 SendMessage : 如果指定窗口由调用线程创建，那么窗口过程会被当成一
跨进程通信SendMessage - C#
04-23
跨进程通信SendMessage - C#, WM_SETTEXT, WM_GETTEXT
进程间通讯SendMessage
GT黑喵的博客
02-03 908
PostMessage貌似只能用于进程内通讯，不同进程间通讯可以用SendMessage和共享内存等方式。这里理出SendMessage的用法，方便日后查阅。 发送消息的进程代码： const UINT messageID = RegisterWindowMessage("SingletonApplication"); char szTemp[1024] = { 0 }; sprintf(...
PostMessage,SendMessage跨不同权限进程通信失效的解决办法
wlslblue的专栏
08-16 1818
vista之后的windows引入了UAC（用户账户控制），意味着在t
springboot——grpc实现demo
JHC23的专栏
10-15 2643
grpc实现demo一、前言1、应用场景：Java做为服务端给go 提供接口2、 grpc: 数据的序列化以及进城数据通信的交互方式二、springboot 构建grpc 的demo1、版本对应：2、项目构建2.1 项目结构2.2 根pom文件2.3 grpc-lib 模块2.3.1 文件结构2.3.2 pom文件2.4 grpc-server 模块2.4.1 对应的pom 文件2.4.2 对应的...
Android 应用进程保活APP常驻内存研究方案
csdn_aiyang的博客
08-28 8879
前言 遥想当年，博主铭记在心的一件事，就是曾做过让我加快秃顶的功能——健步活动。我们知道，在Android4.4之后的版本中，Android在硬件中支持内置计步传感器，例如微信运动等软件都是调用了Android中的Sensor.TYPE_STEP_COUNTER传感器服务，从而获取到每日的步数。 由于当时用户手机版本普遍偏低，因此需要手写记步。当时好在机智如我，参考了微信摇一摇的原理，通过加...
消息服务器61616的测试工具,JMS_ActiveMQ_转载
weixin_34643336的博客
08-05 822
**一、 ****概述与介绍******ActiveMQ 是Apache出品，最流行的、功能强大的即时通讯和集成模式的开源服务器。ActiveMQ 是一个完全支持JMS1.1和J2EE 1.4规范的 JMS Provider实现。提供客户端支持跨语言和协议，带有易于在充分支持JMS 1.1和1.4使用J2EE企业集成模式和许多先进的功能。**二、 ****特性******1、 多种语言和协议编写客...
Window下跨进程发消息（命名消息）
12-08
C++实现跨进程发消息的简单Demo（命名消息），简单便捷的进程间通讯方式，适用于Window环境下。
利用sendMessage实现进程间通信
08-04
来源 visual c++开发范例,IDE:vs2010. 分为 a.server(接收消息,显示接收到的数值). b.client（打开server进程,向server主窗体发送消息). //得到主窗口 HWND CMyJC006ClientDlg::GetServerMainWnd() { HWND hWnd; if(0==EnumWindows((WNDENUMPROC)EnumWndProc,(LPARAM)&hWnd)) //find { return hWnd; } return NULL; } //枚举窗口的回调函数 BOOL CALLBACK EnumWndProc(HWND hWnd,LPARAM lParam) { TCHAR szWndText[MAX_PATH]; unsigned long dwProcessID; GetWindowThreadProcessId(hWnd,&dwProcessID); if(dwProcessID==g_ProcessId) { if(NULL==::GetParent(hWnd)) //is top window { *(HWND*)lParam=hWnd; return FALSE; //means 0 } } return TRUE; } void CMyJC006ClientDlg::OnBnClickedButtonSend() { // TODO: 在此添加控件通知处理程序代码 //handle --wnd UpdateData(TRUE); //to var HWND hWnd=GetServerMainWnd(); if(hWnd==NULL) { AfxMessageBox(_T("获取MyJC006Server窗口句柄失败!")); ((CButton*)GetDlgItem(IDC_BUTTON_OPEN))->EnableWindow(TRUE); ((CButton*)GetDlgItem(IDC_BUTTON_SEND))->EnableWindow(FALSE); ((CEdit*)GetDlgItem(IDC_EDIT_SENDTEXT))->SetReadOnly(TRUE); return; } //进程ID-->主窗口句柄 CWnd *pWnd=CWnd::FromHandle (hWnd); //wonder 22,get句柄server窗体 pWnd->SendMessage (WM_TEXTMESSAGE,this->m_nTextMessage,0); }
C++进程间通信之SendMessage和PostMessage
lizfs_csdn的博客
06-06 4677
C++进程间通信之SendMessage和PostMessage 1，使用介绍 2，需要注意的地方 3，WM_COPYDATA的原理 SendMessage和PostMessage在Win32编程中是很常见的，主要是用来发送消息到指定的窗口，一般用于工作线程传输数据到UI线程。其中SendMessage函数将指定的消息发送到一个或多个窗口。此函数为指定的窗口调用窗口程序，直到窗口程序处理完消息再返回。而函数PostMessage不同，将一个消息寄送到一个线程的消息队列后立即返回。 同样的
跨进程消息以及数据发送
李林生 的专栏
09-10 3177
在WINDOWS系统
利用SendMessage和FindWindow，给其他进程发消息
hanxiucaolss的博客
09-06 5063
当某个程序要给另一个程序发消息时，可以利用下面2个函数。注意，必须知道另一个进程的主窗口名（顶级窗口，也就是程序运行时的title标题。） 问题描述：https://social.msdn.microsoft.com/Forums/windows/en-US/ccee7ae6-75ca-4916-89cf-a099d12074a7/send-message-to-other-process?fo...
sendmsg
wubala的专栏
08-06 778
#include #include "stdio.h" #include "string.h" #include #include void main(int argc,char **argv) { int gflags,sflags,rflags; int i = 0
MFC的SendMessage用法
sinat_31608641的博客
12-31 6898
Cwnd::SendMessage函数将直接调用窗口过程，并且在该窗口处理该消息之前，不会返回。 这与PostMessage成员函数不同，后者将消息放入窗口的消息队列，并立即返回。 函数声明： LRESULT SendMessage(UINT message, WPARAM wParam = 0,LPARAM lParam = 0); 具体的用法： void CAboutDlg::On...
发现SendMessage：Windows消息发送利器
最新发布
gitblog_00065的博客
06-18 597
发现SendMessage：Windows消息发送利器 去发现同类优质开源项目:https://gitcode.com/ 在Windows开发的浩瀚世界中，精确地测试应用程序对系统事件的响应是一大挑战，特别是面对那些难以人工触发的消息时。今天，我们要向大家隆重推荐一款开源小工具——SendMessage。它不仅简化了开发者对于系统消息测试的复杂度，还为调试过程中理解应用程序的行为打开了一扇新窗口。...
VB SendMessage使用例程
Nie2014的博客
08-17 1578
有关这一部分内容，网上资源都是说很简单、很常用，但是没有完整的示例。我找到一份VB写的完整示例，后续再整理C++的。 SendMessage基础知识 网上相关的文字介绍有很多： C++进程间通信之SendMessage和PostMessage 进程通信-SendMessage使用方法 示例程序 1、功能说明 程序总共分三大步骤： 1、发送端获取当前工程目录中图片名称，生成COPYDATA数据“C0_00"。用SendMessage发送给接收端。 2、接收端收到"C0_00"数据，显示在接收端窗体的Pictu
VC++枚举并控制应用窗口：跨进程消息发送技术
资源摘要信息:"VC++实现枚举所有可见应用窗口，支持发送消息进行关闭、最大化或最小化操作，涉及跨进程通信的技术实现。" 在Windows操作系统中，VC++（Visual C++）是微软提供的一个集成开发环境，它包含对Windows ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值