[C#]Sockets (No packet splitting)

	public class SocketServer
	{
		private Socket serverSocket;
		private int backlog;

		public SocketServer(int backlog = 100)
		{
			this.backlog = backlog;
		}

		public void Start(string IP, int Port)
		{
			serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
			serverSocket.Bind(new IPEndPoint(IPAddress.Parse(IP), Port));
			serverSocket.Listen(backlog);
			AcceptConnections();
		}

		private void AcceptConnections()
		{
			serverSocket.BeginAccept(new AsyncCallback(AcceptCallback), null);
		}

		private void AcceptCallback(IAsyncResult asyncResult)
		{
			try
			{
				SocketClient client = new SocketClient();
				if (client.EndAccept(serverSocket, asyncResult))
				{
					if (SocketEvents.OnConnection != null)
						SocketEvents.OnConnection.Invoke(client);

					client.ReceiveData();
				}
			}
			catch { }

			AcceptConnections();
		}
	}

	public class SocketClient
	{
		private Socket clientSocket;
		private byte[] dataHolder;
		private ushort requiredSize;
		private ushort currentSize;
		private byte[] sizePacket;
		private bool inHeader = true;

		private byte[] CombineData()
		{
			if (inHeader)
			{
				sizePacket = new byte[2];
				System.Buffer.BlockCopy(dataHolder, 0, sizePacket, 0, 2);
				return null;
			}
			else
			{
				byte[] cmbData = new byte[requiredSize];
				System.Buffer.BlockCopy(sizePacket, 0, cmbData, 0, 2);
				System.Buffer.BlockCopy(dataHolder, 0, cmbData, 2, (requiredSize - 2));
				return cmbData;
			}
		}

		public bool EndAccept(Socket serverSocket, IAsyncResult asyncResult)
		{
			try
			{
				clientSocket = serverSocket.EndAccept(asyncResult);
				return true;
			}
			catch
			{
				return false;
			}
		}

		public void ReceiveData()
		{
			ReceiveData(2);
		}

		private void ReceiveData(int size)
		{
			dataHolder = new byte[size];
			clientSocket.BeginReceive(dataHolder, 0, size, SocketFlags.None, new AsyncCallback(ReceiveCallback), null);
		}

		private void ReceiveCallback(IAsyncResult asyncResult)
		{
			try
			{
				SocketError err;
				int rSize = clientSocket.EndReceive(asyncResult, out err);
				if (err == SocketError.Success)
				{
					if (rSize >= 2)
					{
						if (inHeader)
							HandleHeader();
						else
							HandleBody(rSize);
					}
					else
						Disconnect();
				}
				else
					Disconnect();
			}
			catch
			{
				Disconnect();
			}
		}

		private unsafe void HandleHeader()
		{
			currentSize = 2;
			fixed (byte* bPtr = dataHolder)
			{
				requiredSize = (*(ushort*)(bPtr + 0));
			}
			CombineData();
			inHeader = false;
			ReceiveData(requiredSize);
		}

		private void HandleBody(int rSize)
		{
			currentSize += (ushort)rSize;
			if (currentSize == requiredSize)
			{
				byte[] nData = CombineData();
				if (currentSize == nData.Length)
				{
					if (SocketEvents.OnReceive != null)
						SocketEvents.OnReceive.Invoke(this, nData);

					inHeader = true;
					ReceiveData();
				}
				else
					Disconnect();
			}
			else if (currentSize > requiredSize)
				Disconnect();
		}

		private bool alreadyDisconnected = false;
		public void Disconnect()
		{
			if (alreadyDisconnected)
				return;
			alreadyDisconnected = true;

			try
			{
				if (clientSocket.Connected)
					clientSocket.Disconnect(false);
			}
			catch { }

			if (SocketEvents.OnDisconnection != null)
				SocketEvents.OnDisconnection.Invoke(this);
		}

		public void Send(byte[] data)
		{
			byte[] sendBuffer = new byte[data.Length];
			System.Buffer.BlockCopy(data, 0, sendBuffer, 0, data.Length);
			
			try
			{
				Monitor.Enter(this);

				if (clientSocket.Connected)
				{
					clientSocket.BeginSend(sendBuffer, 0, sendBuffer.Length, SocketFlags.None, new AsyncCallback(Send_Callback), null);
				}
			}
			finally
			{
				Monitor.Exit(this);
			}
		}
		
		private void Send_Callback(IAsyncResult asyncResult)
		{
			try
			{
				int size = clientSocket.EndSend(asyncResult);
				if (size < 4)
					Disconnect();
			}
			catch
			{
				Disconnect();
			}
		}

		public bool Connect(string IP, int Port)
		{
			clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
			int tries = 0;
			while (tries < 3 && !clientSocket.Connected)
			{
				try
				{
					clientSocket.Connect(new IPEndPoint(IPAddress.Parse(IP), Port));
					return true;
				}
				catch { }
				tries++;
				Thread.Sleep(2000);
			}
			return false;
		}
	}

	public delegate void ConnectionEvent(SocketClient client);
	public delegate void BufferEvent(SocketClient client, byte[] data);

	public static class SocketEvents
	{
		public static ConnectionEvent OnConnection;
		public static ConnectionEvent OnDisconnection;
		public static BufferEvent OnReceive;
	}

	class Program
	{
		public static void Main(string[] args)
		{
			SocketEvents.OnConnection += new ConnectionEvent(SocketEvents_OnConnection);
			SocketEvents.OnDisconnection += new ConnectionEvent(SocketEvents_OnDisconnection);
			SocketEvents.OnReceive += new BufferEvent(SocketEvents_OnReceive);
			
			SocketServer server = new SocketServer(); // or new SocketServer(500);
			server.Start("127.0.0.1", 9959);
			
			while (true)
				Console.ReadLine();
		}

		static void SocketEvents_OnReceive(SocketClient client, byte[] data)
		{
			Console.WriteLine("received data.");
			client.Send(data);
			Console.WriteLine("send data.");
		}

		static void SocketEvents_OnDisconnection(SocketClient client)
		{
			Console.WriteLine("disconnected.");
		}

		static void SocketEvents_OnConnection(SocketClient client)
		{
			Console.WriteLine("connection.");
		}
	}

	class Program
	{
		public static unsafe void Main(string[] args)
		{
			SocketEvents.OnDisconnection += new ConnectionEvent(SocketEvents_OnDisconnection);
			SocketEvents.OnReceive += new BufferEvent(SocketEvents_OnReceive);
			SocketClient client = new SocketClient();
			client.Connect("127.0.0.1", 9959);
			client.ReceiveData();
			Console.WriteLine("connected.");
			
			while (true)
			{
				Console.ReadLine();
				byte[] sendData = new byte[8];
				fixed (byte* b = sendData)
				{
					(*(ushort*)(b + 0)) = 8;
				}
				client.Send(sendData);
				Console.WriteLine("send data.");
			}
		}
		
		static void SocketEvents_OnReceive(SocketClient client, byte[] data)
		{
			Console.WriteLine("received data.");
		}

		static void SocketEvents_OnDisconnection(SocketClient client)
		{
			Console.WriteLine("disconnected.");
		}
	}