C# winform程序进程之间互相通信

怼烎@ 2023-09-27 17:35 7阅读 0赞

在C\# WinForm程序中，可以使用多种方式实现程序之间的通信。以下列举了几种常见的方式：

1.  网络通信  
    使用网络通信方式，将需要传递的数据打包成网络包，在不同的程序之间传输数据。在C\#中，可以使用Socket、HttpWebRequest、TcpClient等类库实现网络通信。
2.  共享内存  
    通过共享内存的方式，将需要共享的数据存储在内存中，在不同的程序之间进行读写操作。在C\#中，可以使用MemoryMappedFile类库实现共享内存。
3.  窗口消息  
    在WinForm程序中，可以使用窗口消息机制实现程序之间的通信。当一个程序需要向另一个程序发送消息时，可以通过调用另一个程序的窗口句柄，向其发送消息。在C\#中，可以使用Win32 API函数SendMessage、PostMessage等实现窗口消息通信。
4.  文件共享  
    使用文件共享的方式，将需要传递的数据存储在文件中，在不同的程序之间读写文件来实现数据传递。在C\#中，可以使用FileStream、StreamWriter、StreamReader等类库实现文件读写操作。
5.  进程间通信  
    可以通过进程间通信方式，将需要共享的数据传输到其他进程。在C\#中，可以使用WCF、Remoting等技术实现进程间通信。

5种方式对比：

1.网络通信

*  优点：适用于远程通信，可以在不同计算机之间传递数据，支持异步通信，可以实现高效的通信。
 *  缺点：网络通信会受到网络带宽、延迟等因素的影响，需要对数据进行序列化和反序列化，增加了额外的开销，不适合频繁的小数据交换。

2.共享内存

*  优点：无需序列化和反序列化，传输速度快，适合大量数据的交换，多个进程之间可以共享同一块内存，避免了数据复制，减少了内存开销。
 *  缺点：需要进行同步和互斥控制，否则可能出现数据冲突问题，且共享内存无法跨越不同的计算机进行数据交换。

3.进程间通信

*  优点：可以在同一台计算机上的不同进程之间进行通信，支持不同的通信模式，例如管道、消息队列、共享内存等，灵活性较高。
 *  缺点：进程间通信需要对数据进行序列化和反序列化，增加了额外的开销，可能需要进行同步和互斥控制，否则可能出现数据冲突问题。

4.文件映射

*  优点：可以在同一台计算机上的不同进程之间进行通信，支持多种数据类型，包括文本、图像、音频等，数据交换灵活性较高，无需进行序列化和反序列化。
 *  缺点：需要将数据写入到文件中，增加了额外的开销，可能需要进行同步和互斥控制，否则可能出现数据冲突问题。

5.信号量

*  优点：可以用于进程之间的同步和互斥控制，支持多种同步和互斥模式，例如互斥、共享、递增等，具有高度灵活性。
 *  缺点：不能用于数据交换，需要借助其他机制才能进行数据交换，例如共享内存等。

实例：

1.  网络通信例子

在网络通信中，我们可以使用Socket实现两个应用程序之间的通信。下面是一个简单的例子，展示了如何在C\#中使用Socket进行网络通信。

服务端代码：

using System;
    using System.Net;
    using System.Net.Sockets;
    using System.Text;
    
    namespace Server
    {
        class Program
        {
            static void Main(string[] args)
            {
                IPAddress ipAddress = IPAddress.Parse("127.0.0.1");
                int port = 8080;
    
                TcpListener server = new TcpListener(ipAddress, port);
                server.Start();
    
                Console.WriteLine("Server started on port " + port);
    
                TcpClient client = server.AcceptTcpClient();
                Console.WriteLine("Client connected");
    
                NetworkStream stream = client.GetStream();
    
                byte[] buffer = new byte[1024];
                int bytes = stream.Read(buffer, 0, buffer.Length);
                string message = Encoding.ASCII.GetString(buffer, 0, bytes);
                Console.WriteLine("Received: " + message);
    
                byte[] response = Encoding.ASCII.GetBytes("Hello, client");
                stream.Write(response, 0, response.Length);
                Console.WriteLine("Sent: " + Encoding.ASCII.GetString(response));
    
                client.Close();
                server.Stop();
    
                Console.WriteLine("Server stopped");
            }
        }
    }

客户端代码：

using System;
    using System.Net;
    using System.Net.Sockets;
    using System.Text;
    
    namespace Client
    {
        class Program
        {
            static void Main(string[] args)
            {
                IPAddress ipAddress = IPAddress.Parse("127.0.0.1");
                int port = 8080;
    
                TcpClient client = new TcpClient();
                client.Connect(ipAddress, port);
                Console.WriteLine("Connected to server");
    
                NetworkStream stream = client.GetStream();
    
                string message = "Hello, server";
                byte[] buffer = Encoding.ASCII.GetBytes(message);
                stream.Write(buffer, 0, buffer.Length);
                Console.WriteLine("Sent: " + message);
    
                buffer = new byte[1024];
                int bytes = stream.Read(buffer, 0, buffer.Length);
                message = Encoding.ASCII.GetString(buffer, 0, bytes);
                Console.WriteLine("Received: " + message);
    
                client.Close();
    
                Console.WriteLine("Client closed");
            }
        }
    }

1.  共享内存例子

下面是一个简单的例子，使用了C\#的System.IO.MemoryMappedFiles类，创建了一个具有写权限的共享内存区域，并在该区域中写入了一个字符串。另一个进程可以读取该共享内存区域，并读取写入的字符串。

// 创建一个具有写权限的共享内存区域，大小为1024字节
    using (var mmf = MemoryMappedFile.CreateNew("MySharedMemory", 1024, MemoryMappedFileAccess.ReadWrite))
    {
        // 在共享内存区域中创建一个内存映射视图，偏移量为0，大小为1024字节
        using (var view = mmf.CreateViewAccessor(0, 1024))
        {
            // 写入一个字符串到共享内存区域中
            byte[] data = Encoding.UTF8.GetBytes("Hello, Shared Memory!");
            view.WriteArray(0, data, 0, data.Length);
        }
    }
    
    // 打开共享内存区域，大小为1024字节
    using (var mmf = MemoryMappedFile.OpenExisting("MySharedMemory"))
    {
        // 在共享内存区域中创建一个内存映射视图，偏移量为0，大小为1024字节
        using (var view = mmf.CreateViewAccessor(0, 1024))
        {
            // 读取共享内存区域中的数据
            byte[] data = new byte[1024];
            view.ReadArray(0, data, 0, data.Length);
            string message = Encoding.UTF8.GetString(data);
            Console.WriteLine(message);
        }
    }

该代码创建了一个具有写权限的共享内存区域，大小为1024字节。然后，它在该共享内存区域中写入了一个字符串“Hello, Shared Memory!”。另一个进程可以读取该共享内存区域，并读取写入的字符串。注意，在打开共享内存区域时，需要使用相同的名称“MySharedMemory”。

这些都是实现程序之间通信的常见方式，具体选择哪种方式，需要根据实际情况进行选择。