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客戶端進程。最后，我們等待一段時間以讓客戶端與服務器進行通信，然后關閉這兩個進程。

請注意，這個示例僅用于演示目的。在實際應用中，你可能需要根據你的需求對其進行修改和優化。