窗体程序websocket服务端

要在窗体程序中实现WebSocket服务端，需要使用类似于System.Net.Sockets.TcpListener的类来监听WebSocket连接。可以使用C#中的WebSocketListener库来实现WebSocket服务端。

以下是一个示例代码，展示如何在C#窗体程序中实现WebSocket服务端：

using System;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Text;

namespace WebSocketServerDemo
{
    public class WebSocketServer
    {
        private TcpListener tcpListener;
        private List<WebSocketConnection> connections = new List<WebSocketConnection>();
        private Thread listenThread;

        public WebSocketServer(string ipAddress, int port)
        {
            tcpListener = new TcpListener(IPAddress.Parse(ipAddress), port);
        }

        public void Start()
        {
            listenThread = new Thread(new ThreadStart(ListenForClients));
            listenThread.Start();
        }

        private void ListenForClients()
        {
            tcpListener.Start();

            while (true)
            {
                TcpClient client = tcpListener.AcceptTcpClient();

                // create a new thread to handle this client
                WebSocketConnection connection = new WebSocketConnection(client);
                connections.Add(connection);
                Thread clientThread = new Thread(new ThreadStart(connection.Start));
                clientThread.Start();
            }
        }

        public void Broadcast(string message)
        {
            foreach (WebSocketConnection connection in connections)
            {
                connection.Send(message);
            }
        }
    }

    public class WebSocketConnection
    {
        private TcpClient client;
        private NetworkStream stream;

        public WebSocketConnection(TcpClient client)
        {
            this.client = client;
            stream = client.GetStream();
        }

        public void Start()
        {
            // read the client's handshake request
            byte[] buffer = new byte[1024];
            int bytes = stream.Read(buffer, 0, buffer.Length);
            string request = Encoding.UTF8.GetString(buffer, 0, bytes);

            // send the server's handshake response
            string response = "HTTP/1.1 101 Switching Protocols\r\n" +
                "Connection: Upgrade\r\n" +
                "Upgrade: websocket\r\n" +
                "Sec-WebSocket-Accept: " + Convert.ToBase64String(
                    System.Security.Cryptography.SHA1.Create().ComputeHash(
                        Encoding.UTF8.GetBytes(
                            new System.Text.RegularExpressions.Regex("Sec-WebSocket-Key: (.*)").Match(request).Groups[1].Value.Trim() + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
                        )
                    )
                ) + "\r\n\r\n";
            byte[] responseBytes = Encoding.UTF8.GetBytes(response);
            stream.Write(responseBytes, 0, responseBytes.Length);

            // start listening for messages from the client
            while (client.Connected)
            {
                try
                {
                    // read the message header
                    buffer = new byte[2];
                    stream.Read(buffer, 0, 2);
                    byte opcode = (byte)(buffer[0] & 0x0F);
                    bool fin = (buffer[0] & 0x80) == 0x80;
                    bool mask = (buffer[1] & 0x80) == 0x80;
                    int payloadLength = buffer[1] & 0x7F;

                    // read the message payload
                    if (payloadLength == 126)
                    {
                        buffer = new byte[2];
                        stream.Read(buffer, 0, 2);
                        Array.Reverse(buffer);
                        payloadLength = BitConverter.ToUInt16(buffer, 0);
                    }
                    else if (payloadLength == 127)
                    {
                        buffer = new byte[8];
                        stream.Read(buffer, 0, 8);
                        Array.Reverse(buffer);
                        payloadLength = (int)BitConverter.ToUInt64(buffer, 0);
                    }

                    byte[] maskBytes = mask ? new byte[4] : null;
                    if (mask)
                    {
                        stream.Read(maskBytes, 0, 4);
                    }

                    byte[] payload = new byte[payloadLength];
                    stream.Read(payload, 0, payloadLength);
                    if (mask)
                    {
                        for (int i = 0; i < payloadLength; i++)
                        {
                            payload[i] = (byte)(payload[i] ^ maskBytes[i % 4]);
                        }
                    }

                    // handle the message
                    if (opcode == 8)
                    {
                        // client closed the connection
                        client.Close();
                    }
                    else if (opcode == 1)
                    {
                        string message = Encoding.UTF8.GetString(payload);
                        Console.WriteLine("Received message: " + message);

                        // send a response
                        Send("Echo: " + message);
                    }
                }
                catch (Exception ex)
                {
                    // handle the exception
                    Console.WriteLine("Exception: " + ex.Message);
                    client.Close();
                }
            }
        }

        public void Send(string message)
        {
            byte[] buffer = Encoding.UTF8.GetBytes("\x81" + (char)message.Length + message);
            stream.Write(buffer, 0, buffer.Length);
        }
    }
}

在窗体程序中，可以使用以下代码来启动WebSocket服务端：

WebSocketServer server = new WebSocketServer("127.0.0.1", 8080);
server.Start();

在这个示例中，WebSocket服务端监听IP地址为127.0.0.1，端口号为8080。每当有新的WebSocket连接到达时，将启动一个新的线程来处理该连接，使用WebSocketConnection类来处理连接。可以通过调用WebSocketServer类的Broadcast方法来向所有连接发送消息。

注意：该示例代码仅用于演示WebSocket服务端的基本实现方式，实际应用中还需要考虑更多的安全性和可靠性问题。