dotnet: add websocket example program

Author: jwatson0

runtime/dotnet/HelloWorld/Program.cs

@@ -52,7 +52,8 @@ public static async Task Main(string[] args)
 
         // Exercise websockets
         var client = new ClientWebSocket();
-        var uri = new Uri("ws://corefx-net-http11.azurewebsites.net/WebSocket/EchoWebSocket.ashx");
+        // var uri = new Uri("ws://corefx-net-http11.azurewebsites.net/WebSocket/EchoWebSocket.ashx");
+        var uri = new Uri("ws://localhost:8001/");
 
         await client.ConnectAsync(uri, CancellationToken.None);
 

runtime/dotnet/wserver/Program.cs

@@ -0,0 +1,185 @@
+namespace wserver;
+
+using System;
+using System.Collections.Concurrent;
+using System.Net;
+using System.Net.WebSockets;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+#nullable enable
+
+public class WebSocketServer
+{
+    private readonly HttpListener _listener;
+    private readonly ConcurrentDictionary<Guid, WebSocket> _sockets;
+    private readonly CancellationTokenSource _cancellationTokenSource;
+
+    public WebSocketServer(string prefix)
+    {
+        _listener = new HttpListener();
+        _listener.Prefixes.Add(prefix);
+        _sockets = new ConcurrentDictionary<Guid, WebSocket>();
+        _cancellationTokenSource = new CancellationTokenSource();
+    }
+
+    public async Task StartAsync()
+    {
+        _listener.Start();
+        Console.WriteLine("WebSocket server started...");
+
+        while (!_cancellationTokenSource.Token.IsCancellationRequested)
+        {
+            try
+            {
+                HttpListenerContext context = await _listener.GetContextAsync();
+
+                if (context.Request.IsWebSocketRequest)
+                {
+                    ProcessWebSocketRequest(context);
+                }
+                else
+                {
+                    context.Response.StatusCode = 400;
+                    context.Response.Close();
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Error: {ex.Message}");
+            }
+        }
+    }
+
+    private async void ProcessWebSocketRequest(HttpListenerContext context)
+    {
+        HttpListenerWebSocketContext? webSocketContext = null;
+        Guid socketId = Guid.Empty;
+
+        try
+        {
+            webSocketContext = await context.AcceptWebSocketAsync(subProtocol: null);
+
+            // Handle potential null return
+            if (webSocketContext?.WebSocket == null)
+            {
+                context.Response.StatusCode = 500;
+                context.Response.Close();
+                return;
+            }
+
+            WebSocket socket = webSocketContext.WebSocket;
+            socketId = Guid.NewGuid();
+            _sockets.TryAdd(socketId, socket);
+
+            Console.WriteLine($"Client {socketId} connected");
+
+            await HandleMessages(socket, socketId);
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"WebSocket error: {ex.Message}");
+            if (webSocketContext?.WebSocket != null && webSocketContext.WebSocket.State == WebSocketState.Open)
+            {
+                await webSocketContext.WebSocket.CloseAsync(WebSocketCloseStatus.InternalServerError, "Error", CancellationToken.None);
+            }
+        }
+        finally
+        {
+            if (webSocketContext?.WebSocket != null)
+            {
+                WebSocket socket = webSocketContext.WebSocket;
+                if (socket.State == WebSocketState.Open || socket.State == WebSocketState.CloseReceived)
+                {
+                    await socket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Closing", CancellationToken.None);
+                }
+            }
+
+            WebSocket? removedSocket;
+            _sockets.TryRemove(socketId, out removedSocket);
+            Console.WriteLine($"Client {socketId} disconnected");
+        }
+    }
+
+    private async Task HandleMessages(WebSocket socket, Guid socketId)
+    {
+        byte[] buffer = new byte[1024];
+
+        while (socket.State == WebSocketState.Open)
+        {
+            WebSocketReceiveResult result = await socket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
+
+            if (result.MessageType == WebSocketMessageType.Text)
+            {
+                string message = Encoding.UTF8.GetString(buffer, 0, result.Count);
+                Console.WriteLine($"Received from {socketId}: {message}");
+
+                await socket.SendAsync(new ArraySegment<byte>(buffer, 0, result.Count), 
+                    WebSocketMessageType.Text, result.EndOfMessage, CancellationToken.None);
+
+                BroadcastMessage(message, socketId);
+            }
+            else if (result.MessageType == WebSocketMessageType.Close)
+            {
+                await socket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Closing", CancellationToken.None);
+            }
+        }
+    }
+
+    private void BroadcastMessage(string message, Guid senderId)
+    {
+        byte[] messageBytes = Encoding.UTF8.GetBytes(message);
+
+        foreach (var socket in _sockets.Values)
+        {
+            if (socket.State == WebSocketState.Open)
+            {
+                try
+                {
+                    socket.SendAsync(new ArraySegment<byte>(messageBytes), 
+                        WebSocketMessageType.Text, true, CancellationToken.None);
+                }
+                catch (Exception ex)
+                {
+                    Console.WriteLine($"Broadcast error: {ex.Message}");
+                }
+            }
+        }
+    }
+
+    public async Task StopAsync()
+    {
+        _cancellationTokenSource.Cancel();
+
+        foreach (var socket in _sockets.Values)
+        {
+            if (socket.State == WebSocketState.Open)
+            {
+                await socket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Server stopping", CancellationToken.None);
+            }
+        }
+
+        _listener.Stop();
+        _listener.Close();
+
+        Console.WriteLine("WebSocket server stopped");
+    }
+}
+
+public class Program
+{
+    public static async Task Main(string[] args)
+    {
+        var server = new WebSocketServer("http://localhost:8001/");
+
+        try
+        {
+            await server.StartAsync();
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"Server error: {ex.Message}");
+        }
+    }
+}

runtime/dotnet/wserver/wserver.csproj

@@ -0,0 +1,10 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+</Project>