networking-demo

Network.cs (5070B)

---

 using System;
 using System.Collections.Generic;
 using System.Net;
 using System.Net.Sockets;
 
 // for MemoryMarshall, to efficiently read and write buffers
 using System.Runtime.InteropServices;
 
 using NetworkingDemo.Packets;
 
 namespace NetworkingDemo {
 	internal enum ConnectionResult {
 		ReceivePackets,
 		CloseConnection,
 	}
 
 	internal delegate ConnectionResult PacketHandler(Memory<byte> buffer, Connection conn);
 
 	internal class Connection {
 		private readonly NetworkStream network;
 
 		private const int PacketHeaderLength = sizeof(PacketType) + sizeof(int);
 		private byte[] recvBuffer;
 		private int recvBufferOffset;
 
 		private readonly Dictionary<PacketType, PacketHandler> handlers;
 
 		internal Connection(NetworkStream network) {
 			this.network = network;
 
 			handlers = new Dictionary<PacketType, PacketHandler>();
 		}
 
 		internal Connection(NetworkStream network, Dictionary<PacketType, PacketHandler> handlers) {
 			this.network = network;
 
 			this.handlers = handlers;
 		}
 
 		internal void On(PacketType type, PacketHandler handler) {
 			handlers[type] = handler;
 		}
 
 		internal void Send<T>(T packet) where T : IPacket {
 			byte[] buffer = new byte[packet.MaxSerializedLength()];
 			int length = packet.SerializeInto(buffer);
 
 			int raw_type = IPAddress.HostToNetworkOrder((int) packet.Type());
 			int raw_length = IPAddress.HostToNetworkOrder(length);
 
 			Span<byte> header = stackalloc byte[PacketHeaderLength];
 			MemoryMarshal.Write(header.Slice(0, sizeof(int)), ref raw_type);
 			MemoryMarshal.Write(header.Slice(sizeof(int), sizeof(int)), ref raw_length);
 
 			network.Write(header);
 
 			network.Write(buffer, 0, length);
 		}
 
 		internal void BeginRecv() {
 			recvBuffer = new byte[PacketHeaderLength];
 			recvBufferOffset = 0;
 
 			network.BeginRead(recvBuffer, 0, PacketHeaderLength, OnRecvHeader, null);
 		}
 
 		private void OnRecvHeader(IAsyncResult result) {
 			int bytes_read = network.EndRead(result);
 			if (bytes_read <= 0) {
 				Console.WriteLine("Error! Zero bytes read when receiving header!");
 				return;
 			}
 
 			recvBufferOffset += bytes_read;
 			if (recvBufferOffset < recvBuffer.Length) {
 				network.BeginRead(recvBuffer, recvBufferOffset,
 						  recvBuffer.Length - recvBufferOffset,
 						  OnRecvHeader, null);
 				return;
 			}
 
 			Span<byte> header = recvBuffer;
 
 			int raw_type = MemoryMarshal.Read<int>(header.Slice(0, sizeof(int)));
 			int raw_length = MemoryMarshal.Read<int>(header.Slice(sizeof(int), sizeof(int)));
 
 			PacketType type = (PacketType) IPAddress.NetworkToHostOrder(raw_type);
 			int length = IPAddress.NetworkToHostOrder(raw_length);
 
 			recvBuffer = new byte[length];
 			recvBufferOffset = 0;
 
 			network.BeginRead(recvBuffer, 0, length, OnRecvBody, type);
 		}
 
 		private void OnRecvBody(IAsyncResult result) {
 			int bytes_read = network.EndRead(result);
 			if (bytes_read <= 0) {
 				Console.WriteLine("Error! Zero bytes read when receiving body!");
 				return;
 			}
 
 			recvBufferOffset += bytes_read;
 			if (recvBufferOffset < recvBuffer.Length) {
 				network.BeginRead(recvBuffer, recvBufferOffset,
 						  recvBuffer.Length - recvBufferOffset,
 						  OnRecvBody, result.AsyncState);
 				return;
 			}
 
 			PacketType type = (PacketType) result.AsyncState!;
 			ConnectionResult handlerResult = handlers[type](recvBuffer, this);
 
 			switch (handlerResult) {
 				case ConnectionResult.ReceivePackets:
 					BeginRecv();
 					break;
 
 				case ConnectionResult.CloseConnection:
 					network.Close();
 					break;
 			}
 		}
 	}
 
 	internal class Server {
 		private readonly TcpListener listener;
 
 		private const int MaxConcurrentClients = 16;
 
 		private int nextClientId;
 		private readonly Dictionary<int, Connection> clients;
 
 		private readonly Dictionary<PacketType, PacketHandler> handlers;
 
 		internal Server(IPAddress addr, int port) {
 			listener = new TcpListener(addr, port);
 
 			nextClientId = 0;
 			clients = new Dictionary<int, Connection>();
 
 			handlers = new Dictionary<PacketType, PacketHandler>();
 		}
 
 		internal void On(PacketType type, PacketHandler handler) {
 			handlers[type] = handler;
 		}
 
 		internal void Start() {
 			listener.Start();
 
 			listener.BeginAcceptTcpClient(OnAcceptClient, null);
 		}
 
 		private void OnAcceptClient(IAsyncResult result) {
 			TcpClient peer = listener.EndAcceptTcpClient(result);
 			listener.BeginAcceptTcpClient(OnAcceptClient, null);
 
 			if (clients.Count == MaxConcurrentClients) {
 				peer.Close();
 				peer.Dispose();
 				return;
 			}
 
 			int clientId = nextClientId++;
 			clients[clientId] = new Connection(peer.GetStream(), handlers);
 			Handle(clients[clientId]);
 		}
 
 		private void Handle(Connection connection) {
 			// send the welcome packet
 			connection.Send(new WelcomePacket("Hello!"));
 
 			// start waiting on responses
 			connection.BeginRecv();
 		}
 	}
 
 	internal class Client {
 		private readonly TcpClient connection;
 
 		internal Client() {
 			connection = new TcpClient();
 		}
 
 		internal Connection ConnectTo(IPAddress addr, int port) {
 			connection.Connect(addr, port);
 			return new Connection(connection.GetStream());
 		}
 	}
 }