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

最新推荐文章于 2023-07-19 16:37:59 发布
最新推荐文章于 2023-07-19 16:37:59 发布
阅读量393 收藏
点赞数
分类专栏： sendmessage c 文章标签： 网络 队列 socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42501279/article/details/119253795
版权

一工程分布

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”，那么当某个模块发送此消息，则远端和本地都会收到此消息。

赖文强
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#使用SendMessage实现进程间通信的方法
12-25
本文实例讲述了C#使用SendMessage实现进程间通信的方法。分享给大家供大家参考。具体分析如下： 为了深入理解消息机制，先来做一个测试项目 在新建项目的Form1的代码中，加入方法： protected override void ...
在C# API 消息处理 SendMessage PostMessage 进程通信 发消息 实例 文档资料
02-13
主要示例在C#中的SendMessage,PostMessage,包含两个示例，一个资料文档，希望受用。 在C#中 API 消息处理 SendMessage PostMessage 进程通信 发消息 实例 文档资料
使用Window的SendMessage进行进程间通信
qq_38284923的博客
07-19 466
使用WIndow的SendMessage实现进程间通信
关于多线程中使用SendMessage
wangandy7811的专栏
08-20 7739
如果，窗口是由非主线程创建的，那么，那个线程将会跑一个自己的窗口消息队列。调用SendMessage会切换到该线程上去执行。 主线程是个窗口线程，在另外一个工作线程中调用了窗口线程的SendMessage，那么执行的过程是： 1.工作线程挂起 2.切换到窗口线程，执行对应的消息处理 3.切换回工作线程 SendMessage : 如果指定窗口由调用线程创建，那么窗口过程会被当成一
Unity C# 自定义TCP传输协议以及封包拆包、解决粘包问题（网络应用层协议）
ba_wang_mao的专栏
08-03 1986
本文只是初步实现了一个简单的基于TCP的自定协议，更为复杂的协议可以根据这种方式去扩展。 网络应用层协议，通俗一点的讲，它是一种基于socket传输的由发送方和接收方事先协商好的一种消息包组成结构，主要由消息头和消息体组成。 众所周知，基于socket的信息交互有两个问题： 第一、接收方不能主动识别发送方发送的信息类型，例如A方（客户端）向B方（服务器）发送了一条信息：123，没有事先经过协议规定的话，B方不可能知道这条信息123到...
轻量级C#网络通信组件StriveEngine —— C/S通信开源demo（附源码）
weixin_34358365的博客
06-17 445
前段时间，有几个研究ESFramework网络通讯框架的朋友对我说，ESFramework有点庞大，对于他们目前的项目来说有点“杀鸡用牛刀”的意思，因为他们的项目不需要文件传送、不需要P2P、不存在好友关系、也不存在组广播、不需要服务器均衡、不需要跨服务器网络通讯、甚至都不需要使用UserID，只要一个客户端能与服务端进行简单的稳定高效的C#网络通信组件就可以了。于是，他们建议我，整一个轻量级的C...
C#利用套接字实现数据发送
qq_55691662的博客
11-24 1371
文章目录一、TCP/UDP1.1 TCP1.2 UDP二、控制台程序使用 UDP 通信2.1 示例一 一、TCP/UDP Socket 套接字是支持TCP/IP协议的网络通信的基本操作单元。可以将套接字看作不同主机间的进程进行双向通信的端点，它构成了单个主机内及整个网络间的编程界面。 套接字的工作原理： 通过互联网进行通信，至少需要一对套接字，其中一个运行于客户机端，称之为ClientSocket，另一个运行于服务器端，称之为ServerSocket。 套接字之间的连接过程可以分为三个步骤：服务器监听，客
vc++跨进程处理消息
12-17
vc++跨进程处理消息（本例通过SendMessage向windows计算器发送消息）
SendMessage PostMessage 消息处理详解
04-09
1.保证无毒 2.简单,方便,实用 3.实例可以自行改用 4.如有非法,本人无法律责任,由改动代码人负责！ 5.需要更多本人作品,查找标签“朱建强” 6.请下载,杀毒后再使用！
C# 进程间通信 Windows消息通讯,SendMessage
03-25
Windows进程之间是相互独立的，通过Windows消息机制，我们可以在进程之间进行通信，适合一台电脑的windows平台下进行消息交换，该例是两个winform之间通过windows消息发送和接收数据。 1、进程间通信 2、SendMessage...
[转载]Win32应用程序中进程间通信方法分析与比较
weixin_34198762的博客
04-16 274
[---  资料是从免费网站上获取的，上载在这里，只为交流学习目的，文章原作者保留所有权力， 如本博客的内容侵犯了你的权益，请与以下地址联系，本人获知后，马上删除。同时本人深表歉意，并致以崇高的谢意！ [email protected]  ---] Win32应用程序中进程间通信方法分析与比较 来源:Intetnet   1 进程与进程通信   　　进程是装入内存并准备执行的程序...
用WM_COPYDATA在C#内实现进程间通信(IPC)
weixin_30627381的博客
08-11 136
用WM_COPYDATA在C#内实现进程间通信(IPC) /* Style Definitions */ table.MsoNormalTable {mso-style-name:普通表格; mso-tstyle-rowba...
C++进程间通信之SendMessage和PostMessage
lizfs_csdn的博客
06-06 4393
C++进程间通信之SendMessage和PostMessage 1，使用介绍 2，需要注意的地方 3，WM_COPYDATA的原理 SendMessage和PostMessage在Win32编程中是很常见的，主要是用来发送消息到指定的窗口，一般用于工作线程传输数据到UI线程。其中SendMessage函数将指定的消息发送到一个或多个窗口。此函数为指定的窗口调用窗口程序，直到窗口程序处理完消息再返回。而函数PostMessage不同，将一个消息寄送到一个线程的消息队列后立即返回。 同样的
webrtc在服务器端通信协议,WebRtc与信令服务器通信的流程分析
weixin_35601611的博客
08-06 612
webrtcWebRTC，即Web Real-Time Communication，web实时通信技术。简单地说就是在web浏览器里面引入实时通信，包括音视频通话等。WebRTC实现了基于网页的语音对话或视频通话，目的是无插件实现web端的实时通信的能力。WebRTC提供了视频会议的核心技术，包括音视频的采集、编解码、网络传输、展示等功能，并且还支持跨平台，包括linux、windows、mac、...
SendMessage()窗体之间发消息
Struggling_Jeff的博客
08-19 3891
SendMessage调用一个窗口的窗口函数，将一条消息发给那个窗口。 一、父窗口向子窗口发消息。 1.1在接收方，也就是子窗口类头文件里面声明消息。 #define MSG_UPDATE_LEFT_CHILD WM_USER+600 1.2消息映射，在头文件里面添加响应函数。 afx_msg LRESULT OnUpdate(WPARAM w, LPARAM l); 1.3响应响应函...
sendmsg
wubala的专栏
08-06 739
#include #include "stdio.h" #include "string.h" #include #include void main(int argc,char **argv) { int gflags,sflags,rflags; int i = 0
qt sendmessage 发送消息
最新发布
08-25
使用sendMessage发送消息的一个常见的用途是在多线程中进行跨线程通信。Qt的信号槽机制是一个常见的实现方式。 需要注意的是，消息的接收方要正确地重载事件处理函数，以处理接收到的消息。 总之，Qt的sendMessage...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值