c# 进程间的通信实现之一简单字符串收发

2022-10-31 14:10:29

使用Windows API实现两个进程间（含窗体）的通信在Windows下的两个进程之间通信通常有多种实现方式，在.NET中，有如命名管道、消息队列、共享内存等实现方式，这篇文章要讲的是使用Windows的API来实现简单的进程间通信，这两个进程既可以都是基于C#开发，也可以都是基于C++开发，也可以是一个C#开发而另一个为C++开发，在C++开发方面，不需要额外调用Windows的API，而是可以直接使用相关方法即可。所以，这里重点要讲的就是在C#中是如何做的，而至于在C++中是如何做的将给出例子，并不做详述。

对于接收消息，只需要重写DefWndProc函数即可，对于发送消息，笔者编写了一个类MsgHandler来实现。要顺利实现消息的接收与发送，使用了Windows的API：FindWindow、SendMessage等。在C#环境中，通过DllImport来引入相应的API，代码示例如下：

// FindWindow method, using Windows API
[DllImport("User32.dll", EntryPoint = "FindWindow")]
private static extern int FindWindow(string lpClassName, string lpWindowName);

// IsWindow method, using Windows API
[DllImport("User32.dll", EntryPoint = "IsWindow")]
private static extern bool IsWindow(int hWnd);

// SendMessage method, using Windows API
[DllImport("User32.dll", EntryPoint = "SendMessage")]
private static extern int SendMessage(
int hWnd, // handle to destination window
int Msg, // message
int wParam, // first message parameter
ref COPYDATASTRUCT lParam // second message parameter
);

笔者查阅了相关网络资源，发现很少有提及使用自定义消息来发送和接收消息的，几乎都是使用了系统消息WM_COPYDATA来实现。在本例中，笔者除了使用系统消息WM_COPYDATA来收发消息外，还将使用自定义消息来实现收发消息。不过，值得注意的是，笔者在测试过程中发现，使用自定义的消息来收发结构体时发生了一些异常，该异常提示说内存不能读，对于该问题，还有待进一步解决，当然，若是哪位前辈或朋友有遇到过该问题并已顺利解决的话，不妨告知，笔者将洗耳恭听。

消息发送类MsgHandler的代码示例如下：

using System;
using System.Text;
using System.Windows.Forms;
using System.Diagnostics;
using System.Runtime.InteropServices;

namespace CommunicationTest
{
/// <summary>
/// Send message handler class.
/// Call the method "SendMessageToTargetWindow" to send
/// the message what we want.
/// </summary>
class MsgHandler
{
/// <summary>
/// System defined message
/// </summary>
private const int WM_COPYDATA = 0x004A;

/// <summary>
/// User defined message
/// </summary>
private const int WM_DATA_TRANSFER = 0x0437;

// FindWindow method, using Windows API
[DllImport("User32.dll", EntryPoint = "FindWindow")]
private static extern int FindWindow(string lpClassName, string lpWindowName);

// IsWindow method, using Windows API
[DllImport("User32.dll", EntryPoint = "IsWindow")]
private static extern bool IsWindow(int hWnd);

/// <summary>
/// CopyDataStruct
/// </summary>
private struct COPYDATASTRUCT
{
public IntPtr dwData;
public int cbData;
public IntPtr lpData;
}

/// <summary>
/// Send message to target window
/// </summary>
/// <param name="wndName">The window name which we want to found</param>
/// <param name="msg">The message to be sent, string</param>
/// <returns>success or not</returns>
public static bool SendMessageToTargetWindow(string wndName, string msg)
{
Debug.WriteLine(string.Format("SendMessageToTargetWindow: Send message to target window {0}: {1}", wndName, msg));

COPYDATASTRUCT cdsBuffer;
cdsBuffer.dwData = (IntPtr)100;
cdsBuffer.cbData = bytData.Length;
cdsBuffer.lpData = Marshal.AllocHGlobal(bytData.Length);
Marshal.Copy(bytData, 0, cdsBuffer.lpData, bytData.Length);

// Use system defined message WM_COPYDATA to send message.
int iReturn = SendMessage(iHWnd, WM_COPYDATA, 0, ref cdsBuffer);
if (iReturn < 0)
{
string strError = string.Format("SendMessageToTargetWindow: Send message to the target window [{0}] failed!", wndName);
MessageBox.Show(strError, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
Debug.WriteLine(strError);
return false;
}

return true;
}
}

/// <summary>
/// Send message to target window
/// </summary>
/// <param name="wndName">The window name which we want to found</param>
/// <param name="wParam">first parameter, integer</param>
/// <param name="lParam">second parameter, string</param>
/// <returns>success or not</returns>
public static bool SendMessageToTargetWindow(string wndName, int wParam, string lParam)
{
Debug.WriteLine(string.Format("SendMessageToTargetWindow: Send message to target window {0}: wParam:{1}, lParam:{2}", wndName, wParam, lParam));

int iHWnd = FindWindow(null, wndName);
if (iHWnd == 0)
{
string strError = string.Format("SendMessageToTargetWindow: The target window [{0}] was not found!", wndName);
MessageBox.Show(strError, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
Debug.WriteLine(strError);
return false;
}
else
{
// Use our defined message WM_DATA_TRANSFER to send message.
int iReturn = SendMessage(iHWnd, WM_DATA_TRANSFER, wParam, lParam);
if (iReturn < 0)
{
string strError = string.Format("SendMessageToTargetWindow: Send message to the target window [{0}] failed!", wndName);
MessageBox.Show(strError, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
Debug.WriteLine(strError);
return false;
}

return true;
}
}
}
}

消息接收重写了DefWndProc方法，其代码示例如下：

/// <summary>
/// Override the DefWndProc function, in order to receive the message through it.
/// </summary>
/// <param name="m">message</param>
protected override void DefWndProc(ref System.Windows.Forms.Message m)
{
switch (m.Msg)
{
// Here, we use WM_COPYDATA message to receive the COPYDATASTRUCT
case WM_COPYDATA:
COPYDATASTRUCT cds = new COPYDATASTRUCT();
cds = (COPYDATASTRUCT)m.GetLParam(typeof(COPYDATASTRUCT));
byte[] bytData = new byte[cds.cbData];
Marshal.Copy(cds.lpData, bytData, 0, bytData.Length);
this.ProcessIncomingData(bytData);
break;

// Here, we use our defined message WM_DATA_TRANSFER to receive the
// normal data, such as integer, string.
// We had try to use our defined message to receive the COPYDATASTRUCT,
// but it didn't work!! It told us that we try to access the protected
// memory, it usually means that other memory has been broken.
case WM_DATA_TRANSFER:
int iWParam = (int)m.WParam;
string sLParam = m.LParam.ToString();
this.ProcessIncomingData(iWParam, sLParam);
break;

default:
base.DefWndProc(ref m);
break;
}
}

消息的接收与发送最终通过一个WinForm展现出来，其代码实现如下：

using System;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;

namespace CommunicationTest
{
public partial class FrmTest : Form
{
/// <summary>
/// System defined message
/// </summary>
private const int WM_COPYDATA = 0x004A;

/// <summary>
/// User defined message
/// </summary>
private const int WM_DATA_TRANSFER = 0x0437;

/// <summary>
/// CopyDataStruct
/// </summary>
public struct COPYDATASTRUCT
{
public IntPtr dwData;
public int cbData;
public IntPtr lpData;
}

public FrmTest()
{
InitializeComponent();
}

default:
base.DefWndProc(ref m);
break;
}
}

/// <summary>
/// Process the incoming data
/// </summary>
/// <param name="data">incoming data</param>
private void ProcessIncomingData(byte[] bytesData)
{
string strRevMsg = "Receive message: " + Encoding.Default.GetString(bytesData);

lstReceivedMsg.Items.Add(strRevMsg);
}

/// <summary>
/// Process the incoming data
/// </summary>
/// <param name="iWParam">a integer parameter</param>
/// <param name="sLParam">a string parameter</param>
private void ProcessIncomingData(int iWParam, string sLParam)
{
StringBuilder strBuilder = new StringBuilder();
strBuilder.Append("wParam: ");
strBuilder.Append(iWParam.ToString());
strBuilder.Append(", lParam: ");
strBuilder.Append(sLParam);

lstReceivedMsg.Items.Add(strBuilder.ToString());
}

private void FrmTest_Load(object sender, EventArgs e)
{
this.Text = "First Test Form";
this.txtCurrentWndName.Text = "First Test Form";
this.txtTargetWndName.Text = "Second Test Form";
}

private void txtCurrentWndName_TextChanged(object sender, EventArgs e)
{
this.Text = txtCurrentWndName.Text;
}

/// <summary>
/// Send message to the target window with system defined message WM_COPYDATA
/// </summary>
private void btnSend1_Click(object sender, EventArgs e)
{
string strWndName = this.txtTargetWndName.Text;
// Check the target window name is null/empty or not
if (string.IsNullOrEmpty(strWndName))
{
MessageBox.Show("The target window name must not be null or empty!", "Information", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}

string strMsg = this.txtSendingMsg.Text;
// Check the sending message is null/empty or not
if (string.IsNullOrEmpty(strMsg))
{
MessageBox.Show("The sending message must not be null or empty!", "Information", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}

// Send message to the target window
bool bReturn = MsgHandler.SendMessageToTargetWindow(strWndName, strMsg);
}

/// <summary>
/// Send message to the target window with user defined message WM_DATA_TRANSFER
/// </summary>
private void btnSend2_Click(object sender, EventArgs e)
{
string strWndName = this.txtTargetWndName.Text;
// Check the target window name is null/empty or not
if (string.IsNullOrEmpty(strWndName))
{
MessageBox.Show("The target window name must not be null or empty!", "Information", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}

string strWParam = this.txtWParam.Text;
string strLParam = this.txtLParam.Text;
// Check the sending message is null/empty or not
if (string.IsNullOrEmpty(strWParam) || string.IsNullOrEmpty(strLParam))
{
MessageBox.Show("The sending message must not be null or empty!", "Information", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}

int iWParam = 0;
// Convert string to integer
try
{
iWParam = Int32.Parse(strWParam);
}
catch (Exception ex)
{
MessageBox.Show("Convert string to integer exception: " + ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}

// Send message to the target window
bool bReturn = MsgHandler.SendMessageToTargetWindow(strWndName, iWParam, strLParam);
}
}
}

通过上述的C#部分的代码，已经可以实现两个C#窗体间的通信，其界面截图如下图所示：

那么，在C++中又是如何实现的呢？这个其实也是很简单的。要实现消息的收发，同理也要重写WindowProc以便于接收消息，而通过调用方法亦可实现消息的发送。
对于消息接收，如果是系统消息，可以通过OnCopyData(CWnd* pWnd, COPYDATASTRUCT* pCopyDataStruct)事件完成；如果是自定义消息，可以通过重写WindowProc完成。代码示例如下：

BOOL CTestDlg::OnCopyData(CWnd* pWnd, COPYDATASTRUCT* pCopyDataStruct)
{
// TODO: 在此添加消息处理程序代码和/或调用默认值

DWORD dwSize = pCopyDataStruct->cbData;

CString szData;// = (LPCTSTR)(pCopyDataStruct->lpData);
TCHAR* ptchar = new TCHAR[dwSize+1];

memcpy( ptchar, pCopyDataStruct->lpData, dwSize );
ptchar[dwSize] = TEXT('/0');
szData = ptchar;
// TODO: Add some code here to handler the message

delete[] ptchar;

return CDialog::OnCopyData(pWnd, pCopyDataStruct);
}

LRESULT CTestDlg::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
{
// TODO: 在此添加专用代码和/或调用基类
COPYDATASTRUCT szCpyData;

switch ( message )
{
case WM_DATA_TRANSFER:
szCpyData = *((PCOPYDATASTRUCT)lParam);
// TODO: Add some code here to handler the message
break;

default:
break;
}

return CDialog::WindowProc(message, wParam, lParam);
}

对于消息发送，只需要调用形如SendMessage(m_hwndMsg, WM_DATA_TRANSFER, wParam, lParam)方法即可实现，lParam参数可以是PCOPYDATASTRUCT等。

通过上面的介绍，相信已经可以轻松实现两个进程间（含窗体）的通信的，使用这样的方法，既简单又能够满足大部分的应用需求，不失为一种简便的方法。

码农公寓

相关文章