C#多进程与WebSocket的实时通信

在C#中，可以使用多进程和WebSocket技术来实现实时通信。这里是一个简单的示例，展示了如何在C#中使用多进程和WebSocket实现实时通信。

首先，我们需要创建一个WebSocket服务器。我们可以使用System.Net.WebSockets命名空间中的HttpListener类来实现一个简单的WebSocket服务器。以下是一个简单的WebSocket服务器示例：

using System;
using System.Net;
using System.Net.WebSockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace WebSocketServer
{
    class Program
    {
        static async Task Main(string[] args)
        {
            var server = new HttpListener();
            server.Prefixes.Add("http://localhost:8080/");
            server.Start();

            while (true)
            {
                var context = await server.GetContextAsync();
                if (context.Request.IsWebSocketRequest)
                {
                    ProcessWebSocketRequest(context);
                }
            }
        }

        private static async void ProcessWebSocketRequest(HttpListenerContext context)
        {
            var webSocketContext = await context.AcceptWebSocketAsync(null);
            var webSocket = webSocketContext.WebSocket;

            var buffer = new byte[1024 * 4];
            var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);

            while (!result.CloseStatus.HasValue)
            {
                var message = Encoding.UTF8.GetString(buffer, 0, result.Count);
                Console.WriteLine($"Received message: {message}");

                // Echo the message back to the client
                var echoMessage = Encoding.UTF8.GetBytes("Server received: " + message);
                await webSocket.SendAsync(new ArraySegment<byte>(echoMessage), WebSocketMessageType.Text, true, CancellationToken.None);

                result = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
            }

            await webSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None);
        }
    }
}

接下来，我们需要创建一个客户端应用程序，该应用程序将连接到WebSocket服务器并发送和接收消息。以下是一个简单的客户端示例：

using System;
using System.Net.WebSockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace WebSocketClient
{
    class Program
    {
        static async Task Main(string[] args)
        {
            var client = new ClientWebSocket();
            await client.ConnectAsync(new Uri("ws://localhost:8080"), CancellationToken.None);

            Console.WriteLine("Connected to server. Type 'exit' to quit.");

            var sendTask = Task.Run(async () =>
            {
                while (true)
                {
                    var message = Console.ReadLine();
                    if (message == "exit")
                    {
                        break;
                    }

                    var bytes = Encoding.UTF8.GetBytes(message);
                    await client.SendAsync(new ArraySegment<byte>(bytes), WebSocketMessageType.Text, true, CancellationToken.None);
                }
            });

            var receiveTask = Task.Run(async () =>
            {
                var buffer = new byte[1024 * 4];
                var result = await client.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);

                while (!result.CloseStatus.HasValue)
                {
                    var receivedMessage = Encoding.UTF8.GetString(buffer, 0, result.Count);
                    Console.WriteLine($"Server: {receivedMessage}");

                    result = await client.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
                }
            });

            await Task.WhenAll(sendTask, receiveTask);

            await client.CloseAsync(WebSocketCloseStatus.NormalClosure, "Client closed", CancellationToken.None);
        }
    }
}

现在，你可以运行WebSocket服务器和客户端应用程序。当客户端连接到服务器时，它们可以实时发送和接收消息。

为了实现多进程通信，你可以使用System.Diagnostics.Process类来创建和管理子进程。以下是一个简单的示例，展示了如何在C#中使用多进程和WebSocket实现实时通信：

using System;
using System.Diagnostics;
using System.Net.WebSockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace MultiProcessWebSocketCommunication
{
    class Program
    {
        static async Task Main(string[] args)
        {
            // Start the WebSocket server process
            var serverProcess = new Process
            {
                StartInfo = new ProcessStartInfo
                {
                    FileName = "dotnet",
                    Arguments = "WebSocketServer.dll",
                    UseShellExecute = false,
                    RedirectStandardOutput = true,
                    CreateNoWindow = true
                }
            };
            serverProcess.Start();

            // Wait for the server to start
            await Task.Delay(1000);

            // Start the WebSocket client process
            var clientProcess = new Process
            {
                StartInfo = new ProcessStartInfo
                {
                    FileName = "dotnet",
                    Arguments = "WebSocketClient.dll",
                    UseShellExecute = false,
                    RedirectStandardOutput = true,
                    CreateNoWindow = true
                }
            };
            clientProcess.Start();

            // Wait for the client to connect and communicate with the server
            await Task.Delay(5000);

            // Shut down the server and client processes
            serverProcess.Kill();
            clientProcess.Kill();
        }
    }
}

这个示例中，我们首先启动WebSocket服务器进程，然后等待一段时间以确保服务器已经启动。接下来，我们启动WebSocket客户端进程。最后，我们等待一段时间以让客户端与服务器进行通信，然后关闭这两个进程。

请注意，这个示例仅用于演示目的。在实际应用中，你可能需要根据你的需求对其进行修改和优化。