C#中进程间的通信：管道
程序中有两个进程，并且一个进程需要和另一个进程进行通信，那么可以使用管道，所谓的C/S模式也和这个差不多。
分为两端服务和客户端，下面简单说一下管道通信。两个类Server和Client，都包含如下方法：监听，接收，发送。
如下类：
Server类
public class Server
{
[DllImport("kernel32.dll", SetLastError = true)]
public static extern SafeFileHandle CreateNamedPipe(
String pipeName,
uint dwOpenMode,
uint dwPipeMode,
uint nMaxInstances,
uint nOutBufferSize,
uint nInBufferSize,
uint nDefaultTimeOut,
IntPtr lpSecurityAttributes);
[DllImport("kernel32.dll", SetLastError = true)]
public static extern int ConnectNamedPipe(
SafeFileHandle hNamedPipe,
IntPtr lpOverlapped);
public const uint DUPLEX = (0x00000003);
public const uint FILE_FLAG_OVERLAPPED = (0x40000000);
public class Client
{
public SafeFileHandle handle;
public FileStream stream;
}
public delegate void MessageReceivedHandler(Client client, string message);
public event MessageReceivedHandler MessageReceived;
public const int BUFFER_SIZE = 4096;
string pipeName;
Thread listenThread;
bool running;
List<Client> clients;
public string PipeName
{
get { return this.pipeName; }
set { this.pipeName = value; }
}
public bool Running
{
get { return this.running; }
}
public Server()
{
this.clients = new List<Client>();
}
public void Start()
{
this.listenThread = new Thread(new ThreadStart(ListenForClients));
this.listenThread.Start();
this.running = true;
}
private void ListenForClients()
{
while (true)
{
SafeFileHandle clientHandle =
CreateNamedPipe(
this.pipeName,
DUPLEX | FILE_FLAG_OVERLAPPED,
0,
255,
BUFFER_SIZE,
BUFFER_SIZE,
0,
IntPtr.Zero);
if (clientHandle.IsInvalid)
return;
int success = ConnectNamedPipe(clientHandle, IntPtr.Zero);
if (success == 0)
return;
Client client = new Client();
client.handle = clientHandle;
lock (clients)
this.clients.Add(client);
Thread readThread = new Thread(new ParameterizedThreadStart(Read));
readThread.Start(client);
}
}
private void Read(object clientObj)
{
Client client = (Client)clientObj;
client.stream = new FileStream(client.handle, FileAccess.ReadWrite, BUFFER_SIZE, true);
byte[] buffer = new byte[BUFFER_SIZE];
//ASCIIEncoding encoder = new ASCIIEncoding();
UTF8Encoding encoder = new UTF8Encoding();//可以传汉字
while (true)
{
int bytesRead = 0;
try
{
bytesRead = client.stream.Read(buffer, 0, BUFFER_SIZE);
}
catch
{
break;
}
if (bytesRead == 0)
break;
if (this.MessageReceived != null)
this.MessageReceived(client, encoder.GetString(buffer, 0, bytesRead));
}
client.stream.Close();
client.handle.Close();
lock (this.clients)
this.clients.Remove(client);
}
public void SendMessage(string message)
{
lock (this.clients)
{
ASCIIEncoding encoder = new ASCIIEncoding();
byte[] messageBuffer = encoder.GetBytes(message);
foreach (Client client in this.clients)
{
client.stream.Write(messageBuffer, 0, messageBuffer.Length);
client.stream.Flush();
}
}
}
}
Client类
public class Client
{
[DllImport("kernel32.dll", SetLastError = true)]
public static extern SafeFileHandle CreateFile(
String pipeName,
uint dwDesiredAccess,
uint dwShareMode,
IntPtr lpSecurityAttributes,
uint dwCreationDisposition,
uint dwFlagsAndAttributes,
IntPtr hTemplate);
public const uint GENERIC_READ = (0x80000000);
public const uint GENERIC_WRITE = (0x40000000);
public const uint OPEN_EXISTING = 3;
public const uint FILE_FLAG_OVERLAPPED = (0x40000000);
public delegate void MessageReceivedHandler(string message);
public event MessageReceivedHandler MessageReceived;
public const int BUFFER_SIZE = 4096;
string pipeName;
private FileStream stream;
private SafeFileHandle handle;
Thread readThread;
bool connected;
public bool Connected
{
get { return this.connected; }
}
public string PipeName
{
get { return this.pipeName; }
set { this.pipeName = value; }
}
public void Connect()
{
this.handle =
CreateFile(
this.pipeName,
GENERIC_READ | GENERIC_WRITE,
0,
IntPtr.Zero,
OPEN_EXISTING,
FILE_FLAG_OVERLAPPED,
IntPtr.Zero);
if (this.handle.IsInvalid)
return;
this.connected = true;
this.stream = new FileStream(this.handle, FileAccess.ReadWrite, BUFFER_SIZE, true);
this.readThread = new Thread(new ThreadStart(Read));
this.readThread.Start();
}
public void Read()
{
byte[] readBuffer = new byte[BUFFER_SIZE];
ASCIIEncoding encoder = new ASCIIEncoding();
while (true)
{
int bytesRead = 0;
try
{
bytesRead = this.stream.Read(readBuffer, 0, BUFFER_SIZE);
}
catch
{
break;
}
if (bytesRead == 0)
break;
if (this.MessageReceived != null)
this.MessageReceived(encoder.GetString(readBuffer, 0, bytesRead));
}
this.stream.Close();
this.handle.Close();
}
public void SendMessage(string message)
{
//ASCIIEncoding encoder = new ASCIIEncoding();
UTF8Encoding encoder = new UTF8Encoding();//可以传汉字
byte[] messageBuffer = encoder.GetBytes(message);
this.stream.Write(messageBuffer, 0, messageBuffer.Length);
this.stream.Flush();
}
}
Server端
public class ServerPort
{
private Delegate sendMessage = null;
private ContainerControl mainForm;
public Server pipeServer = null;
public ServerPort(ContainerControl form,Delegate sendmessage)
{
mainForm = form;
sendMessage = sendmessage;
}
void SendMsg(string msg)
{
this.mainForm.Invoke(sendMessage, new Object[] { msg });
}
void PipeServer_MessageReceived(Server.Client client, string message)
{
if (!message.Equals(""))
{
SendMsg("接收到的信息是：" + message);
}
else
{
SendMsg("消息未收到？？？");
}
}
private void MessageSend()
{
}
public void PipServerStart()
{
try
{
if (!this.pipeServer.Running)
{
this.pipeServer.PipeName = "\\\\.\\pipe\\testprocesspipe";
this.pipeServer.Start();
this.pipeServer.MessageReceived += new Server.MessageReceivedHandler(PipeServer_MessageReceived);
}
}
catch
{
}
}
}
Client端，发送信息
public class ClientPort
{
private static Client pipeClient;
public static void MessagePipeStart()
{
if (pipeClient == null)
{
pipeClient = new Client();
pipeClient.MessageReceived += new Client.MessageReceivedHandler(pipeClient_MessageReceived);
}
if (!pipeClient.Connected)
{
pipeClient.PipeName = "\\\\.\\pipe\\testprocesspipe";
pipeClient.Connect();
}
if (pipeClient != null && pipeClient.Connected)
{
MessageSend("测试传输的字符:金胖子死了！！！");
}
}
static void MessageSend(string str)
{
pipeClient.SendMessage(str);
}
static void pipeClient_MessageReceived(string message)
{
}
}
启动服务端
ServerPort serverPort;
recivedMessage += new ServerRecivedMessageDelegate(DisplayMessage);
try
{
serverPort = new ServerPort(this, recivedMessage);
serverPort.pipeServer = new Server();
serverPort.PipServerStart();
}
catch
{ }
客户端发送信息
ClientPort.MessagePipeStart();
接收如图，
客户端发送后，服务端监听到，并接收
简单的例子下载地址：http://download.csdn.net/detail/yysyangyangyangshan/3946892
上述 只是在一个工程中简单的模拟。正的进程的通信，Server端和Client端分别在两个进程中，启动的方式都一样，当两端都启动的话，就可以互发信息了。当然，PipeName必须一致，双方才能接收到对方的信息。
这样，可以建造一个服务端，启动好几个Server设置PipeName 各不同，然后客户端分别对应不同的PipeName，就可实现服务器一对多的通信。