C# websocket服务端 如何主动给客户端发消息

在C#中，您可以使用WebSocket类的SendAsync方法来向客户端发送消息。以下是一个简单的示例：

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

class WebSocketServer
{
    private HttpListener httpListener;
    private WebSocket webSocket;

    public async Task Start()
    {
        httpListener = new HttpListener();
        httpListener.Prefixes.Add("http://localhost:8080/");
        httpListener.Start();

        Console.WriteLine("Server started");

        while (true)
        {
            var context = await httpListener.GetContextAsync();
            if (context.Request.IsWebSocketRequest)
            {
                ProcessWebSocketRequest(context);
            }
            else
            {
                context.Response.StatusCode = 400;
                context.Response.Close();
            }
        }
    }

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

        Console.WriteLine("Client connected");

        await Send("Hello from server!");

        var buffer = new byte[1024];
        while (webSocket.State == WebSocketState.Open)
        {
            var receiveResult = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);

            if (receiveResult.MessageType == WebSocketMessageType.Close)
            {
                await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None);
                Console.WriteLine("Client disconnected");
            }
        }
    }

    private async Task Send(string message)
    {
        var buffer = new ArraySegment<byte>(Encoding.UTF8.GetBytes(message));
        await webSocket.SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None);
    }
}

class Program
{
    static async Task Main(string[] args)
    {
        var server = new WebSocketServer();
        await server.Start();
    }
}

在上面的示例中，我们使用HttpListener类创建了一个简单的HTTP服务器，并使用WebSocket类处理WebSocket请求。通过调用AcceptWebSocketAsync方法接受WebSocket连接后，我们可以使用webSocket对象来发送消息。在示例中，我们在ProcessWebSocketRequest方法中调用Send方法来向客户端发送一条消息。

在WebSocket中，客户端通常是主动发起连接请求，而服务端则接受并处理连接请求。服务端不能主动连接客户端，因为WebSocket是基于客户端/服务器模型的。

如果您希望实现服务端主动与客户端建立连接的功能，您可以考虑使用其他通信协议，如TCP或UDP。以下是一个使用TCP协议的简单示例：

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

class TcpServer
{
    private TcpListener tcpListener;

    public async Task Start()
    {
        tcpListener = new TcpListener(System.Net.IPAddress.Parse("127.0.0.1"), 8080);
        tcpListener.Start();

        Console.WriteLine("Server started");

        while (true)
        {
            var tcpClient = await tcpListener.AcceptTcpClientAsync();
            ProcessTcpClient(tcpClient);
        }
    }

    private async void ProcessTcpClient(TcpClient tcpClient)
    {
        var stream = tcpClient.GetStream();
        var buffer = new byte[1024];

        Console.WriteLine("Client connected");

        await Send(stream, "Hello from server!");

        while (true)
        {
            var bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length);
            if (bytesRead == 0)
            {
                Console.WriteLine("Client disconnected");
                break;
            }

            var message = Encoding.UTF8.GetString(buffer, 0, bytesRead);
            Console.WriteLine("Received message from client: " + message);
        }
    }

    private async Task Send(NetworkStream stream, string message)
    {
        var buffer = Encoding.UTF8.GetBytes(message);
        await stream.WriteAsync(buffer, 0, buffer.Length);
    }
}

class Program
{
    static async Task Main(string[] args)
    {
        var server = new TcpServer();
        await server.Start();
    }
}

在上面的示例中，我们使用TcpListener类创建了一个简单的TCP服务器，并在接受到客户端连接后调用ProcessTcpClient方法处理客户端。通过调用ProcessTcpClient方法，服务器可以向客户端发送消息。在示例中，我们在ProcessTcpClient方法中调用Send方法来向客户端发送一条消息。请注意，此示例仅适用于TCP协议，不能与WebSocket客户端进行通信。

WebSocket是一种基于TCP的协议，它提供了在Web应用程序中进行双向通信的能力。与传统的HTTP请求-响应模型不同，WebSocket允许服务器和客户端之间实时地交换数据，而无需客户端发起多个HTTP请求。

WebSocket协议具有以下特点：

1. 双向通信：WebSocket允许服务器和客户端之间实时地进行双向通信。服务器可以主动向客户端发送消息，而不需要客户端发起请求。
2. 持久连接：WebSocket连接会保持打开状态，而不会像HTTP请求那样在每个请求之后关闭连接。这意味着客户端和服务器之间的连接可以保持活动状态，以便随时进行通信。
3. 低延迟：由于WebSocket连接是持久的，因此数据可以实时传输，从而实现低延迟的通信。
4. 协议标准化：WebSocket协议已被标准化，并且在多个浏览器和服务器端框架中得到支持。

在C#中，可以使用System.Net.WebSockets命名空间提供的类来创建WebSocket服务器和客户端。服务器可以使用HttpListener类来接受WebSocket连接，而客户端可以使用ClientWebSocket类来连接到WebSocket服务器并进行通信。

以下是一个简单的示例，演示了如何使用C#创建WebSocket服务器和客户端：

// WebSocket服务器示例
using System;
using System.Net;
using System.Net.WebSockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

public class WebSocketServer
{
    private HttpListener httpListener;

    public async Task Start()
    {
        httpListener = new HttpListener();
        httpListener.Prefixes.Add("http://localhost:8080/");
        httpListener.Start();

        Console.WriteLine("WebSocket server started");

        while (true)
        {
            var context = await httpListener.GetContextAsync();
            if (context.Request.IsWebSocketRequest)
            {
                ProcessWebSocketRequest(context);
            }
            else
            {
                context.Response.StatusCode = 400;
                context.Response.Close();
            }
        }
    }

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

        Console.WriteLine("Client connected");

        var buffer = new byte[1024];
        while (webSocket.State == WebSocketState.Open)
        {
            var receiveResult = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);

            if (receiveResult.MessageType == WebSocketMessageType.Text)
            {
                var message = Encoding.UTF8.GetString(buffer, 0, receiveResult.Count);
                Console.WriteLine("Received message from client: " + message);

                // Echo back the received message
                await webSocket.SendAsync(new ArraySegment<byte>(buffer, 0, receiveResult.Count), WebSocketMessageType.Text, true, CancellationToken.None);
            }
            else if (receiveResult.MessageType == WebSocketMessageType.Close)
            {
                await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None);
                Console.WriteLine("Client disconnected");
            }
        }
    }
}

// WebSocket客户端示例
using System;
using System.Net.WebSockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

public class WebSocketClient
{
    private ClientWebSocket webSocket;

    public async Task Connect(string url)
    {
        webSocket = new ClientWebSocket();
        await webSocket.ConnectAsync(new Uri(url), CancellationToken.None);

        Console.WriteLine("Connected to WebSocket server");

        var receiveBuffer = new byte[1024];
        while (webSocket.State == WebSocketState.Open)
        {
            var receiveResult = await webSocket.ReceiveAsync(new ArraySegment<byte>(receiveBuffer), CancellationToken.None);

            if (receiveResult.MessageType == WebSocketMessageType.Text)
            {
                var message = Encoding.UTF8.GetString(receiveBuffer, 0, receiveResult.Count);
                Console.WriteLine("Received message from server: " + message);
            }
        }
    }

    public async Task Send(string message)
    {
        var sendBuffer = new ArraySegment<byte>(Encoding.UTF8.GetBytes(message));
        await webSocket.SendAsync(sendBuffer, WebSocketMessageType.Text, true, CancellationToken.None);
    }

    public async Task Disconnect()
    {
        await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None);
    }
}

// 使用示例
class Program
{
    static async Task Main(string[] args)
    {
        // 启动WebSocket服务器
        var server = new WebSocketServer();
        await server.Start();

        // 连接WebSocket客户端到服务器
        var client = new WebSocketClient();
        await client.Connect("ws://localhost:8080/");

        // 发送消息给服务器
        await client.Send("Hello from client!");

        // 关闭连接
        await client.Disconnect();
    }
}

在上面的示例中，我们定义了一个WebSocket服务器和一个WebSocket客户端。服务器使用HttpListener类接受WebSocket连接，并在接收到消息时将其回显给客户端。客户端使用ClientWebSocket类连接到WebSocket服务器，并发送一条消息给服务器。

请注意，上述示例仅用于演示WebSocket的基本用法，实际使用中可能需要添加错误处理和更复杂的逻辑。

在WebSocket中，客户端通过连接到服务器来激活WebSocket并进��WebSocketState.Open状态。一旦WebSocket连接建立，它将保持打开状态，除非客户端或服务器关闭连接。

在C#中，使用ClientWebSocket类作为WebSocket客户端可以实现与服务器的连接。以下是一个示例，演示了如何使用C#创建一个WebSocket客户端，并与服务器建立连接并保持WebSocketState.Open状态：

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

class WebSocketClient
{
    private ClientWebSocket webSocket;

    public async Task Connect(string url)
    {
        webSocket = new ClientWebSocket();
        await webSocket.ConnectAsync(new Uri(url), CancellationToken.None);

        Console.WriteLine("Connected to WebSocket server");

        // 开启接收消息的循环
        var receiveBuffer = new byte[1024];
        while (webSocket.State == WebSocketState.Open)
        {
            var receiveResult = await webSocket.ReceiveAsync(new ArraySegment<byte>(receiveBuffer), CancellationToken.None);

            if (receiveResult.MessageType == WebSocketMessageType.Text)
            {
                var message = Encoding.UTF8.GetString(receiveBuffer, 0, receiveResult.Count);
                Console.WriteLine("Received message from server: " + message);
            }
        }

        Console.WriteLine("WebSocket connection closed");
    }

    public async Task Send(string message)
    {
        var sendBuffer = new ArraySegment<byte>(Encoding.UTF8.GetBytes(message));
        await webSocket.SendAsync(sendBuffer, WebSocketMessageType.Text, true, CancellationToken.None);
    }

    public async Task Disconnect()
    {
        await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None);
    }
}

class Program
{
    static async Task Main(string[] args)
    {
        var client = new WebSocketClient();
        await client.Connect("ws://localhost:8080/");

        // 发送消息给服务器
        await client.Send("Hello from client!");

        // 关闭连接
        await client.Disconnect();
    }
}

在上面的示例中，我们创建了一个WebSocket客户端，并使用ClientWebSocket类连接到WebSocket服务器。在连接后，我们使用ReceiveAsync方法持续接收服务器发送的消息，直到WebSocket的状态不再是WebSocketState.Open。

请注意，WebSocket连接可能因为各种原因而关闭（例如网络中断、服务器关闭等）。因此，您需要适当地处理WebSocket连接关闭的情况。上述示例中，我们在WebSocket连接关闭时打印了一条消息。

另外，请确保将示例代码中的url参数替换为实际的WebSocket服务器地址。