Unity网络通信方式之Socket

【字节流处理类】
public class ByteBuffer {
		MemoryStream stream = null;
		BinaryWriter writer = null;
		BinaryReader reader = null;

		public ByteBuffer() {
			stream = new MemoryStream();
			writer = new BinaryWriter(stream);
		}

		public ByteBuffer(byte[] data) {
			if (data != null) {
				stream = new MemoryStream(data);
				reader = new BinaryReader(stream);
			} else {
				stream = new MemoryStream();
				writer = new BinaryWriter(stream);
			}
		}

		public void Close() {
			if (writer != null) writer.Close();
			if (reader != null) reader.Close();

			stream.Close();
			writer = null;
			reader = null;
			stream = null;
		}

		public void WriteByte(byte v) {
			writer.Write(v);
		}

		public void WriteInt(int v) {
			writer.Write((int)v);
		}

		public void WriteShort(ushort v) {
			writer.Write((ushort)v);
		}

		public void WriteLong(long v) {
			writer.Write((long)v);
		}

		public void WriteFloat(float v) {
			byte[] temp = BitConverter.GetBytes(v);
			Array.Reverse(temp);
			writer.Write(BitConverter.ToSingle(temp, 0));
		}

		public void WriteDouble(double v) {
			byte[] temp = BitConverter.GetBytes(v);
			Array.Reverse(temp);
			writer.Write(BitConverter.ToDouble(temp, 0));
		}

		public void WriteString(string v) {
			byte[] bytes = Encoding.UTF8.GetBytes(v);
			writer.Write((ushort)bytes.Length);
			writer.Write(bytes);
		}

		public void WriteBytes(byte[] v) {
			writer.Write((int)v.Length);
			writer.Write(v);
		}

		public byte[] WriteMessage(byte[] message) {
			MemoryStream ms = null;
			using (ms = new MemoryStream()) {
				ms.Position = 0;
				BinaryWriter writer = new BinaryWriter(ms);
				ushort msglen = (ushort)message.Length;
				writer.Write(msglen);
				writer.Write(message);
				writer.Flush();
				return ms.ToArray();
			}
		}

		public byte ReadByte() {
			return reader.ReadByte();
		}

		public int ReadInt() {
			return (int)reader.ReadInt32();
		}

		public ushort ReadShort() {
			return (ushort)reader.ReadInt16();
		}

		public long ReadLong() {
			return (long)reader.ReadInt64();
		}

		public float ReadFloat() {
			byte[] temp = BitConverter.GetBytes(reader.ReadSingle());
			Array.Reverse(temp);
			return BitConverter.ToSingle(temp, 0);
		}

		public double ReadDouble() {
			byte[] temp = BitConverter.GetBytes(reader.ReadDouble());
			Array.Reverse(temp);
			return BitConverter.ToDouble(temp, 0);
		}

		public string ReadString() {
			ushort len = ReadShort();
			byte[] buffer = new byte[len];
			buffer = reader.ReadBytes(len);
			return Encoding.UTF8.GetString(buffer);
		}

		public byte[] ReadBytes() {
			int len = ReadInt();
			return reader.ReadBytes(len);
		}

		public byte[] ToBytes() {
			writer.Flush();
			return stream.ToArray();
		}

		public void Flush() {
			writer.Flush();
		}
	}

【客户端】
public class Client {
		private Socket clientSocket = null;
		private Thread messageReciever = null;
		private ByteBuffer recieveBuffer = null;
		private byte[] datas = null;
		public string message = null;
		public bool connected = false;

		public Client() {}

		~Client() { }

		public void OpenConnectServer(string ipAddress, int port) {
			try {
				if(datas == null) { datas = new byte[1024]; }
				IPAddress ip = IPAddress.Parse(ipAddress);
				IPEndPoint ipEndPoint = new IPEndPoint(ip, port);
				clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
				clientSocket.Connect(ipEndPoint);

				messageReciever = new Thread(RecieveMessageFromServer);
				messageReciever.Start();
				connected = true;
			} catch (Exception ex) {
				connected = false;
				UnityEngine.Debug.Log(ex.ToString());
			}
		}

		public void CloseConnectServer() {
			if (messageReciever != null) {
				messageReciever.Abort();
				messageReciever = null;
			}
			clientSocket.Close();
			clientSocket = null;
			recieveBuffer = null;
			message = null;
			connected = false;
		}

		public void SendMessageToServer(string message) {
			if (connected == true) {
				try {
					ByteBuffer sendBuffer = new ByteBuffer();
					sendBuffer.WriteString(message);
					clientSocket.Send(sendBuffer.WriteMessage(sendBuffer.ToBytes()));
				} catch (Exception ex) {
					UnityEngine.Debug.Log(ex.ToString());
				}
			}
		}

		private void RecieveMessageFromServer() {
			while (true) {
				clientSocket.Receive(datas);
				if (recieveBuffer == null) {
					recieveBuffer = new ByteBuffer(datas);
					recieveBuffer.ReadShort();
					message = recieveBuffer.ReadString();
					recieveBuffer = null;
				}
			}
		}
	}

【服务端】
public class Server {
		private Socket serverSocket = null;
		private Thread connectListener = null;
		private byte[] datas = null;
		public string message;
		public bool opened = false;

		public Dictionary<int, Socket> clientSockets = null;
		private int index = 1;
		private int maxConnectCount = 0;
		private bool isReceived = false;
		public int connectedCount = 0;

		public Server() { }

		~Server() { }

		public void OpenServer(string ipAddress, int port, int count) {
			maxConnectCount = count;
			try {
				if(datas == null) { datas = new byte[1024]; }
				if(clientSockets == null) { clientSockets = new Dictionary<int, Socket>(); }
				IPAddress ip;
				IPAddress.TryParse(ipAddress,out ip);
				IPEndPoint ipEndPoint = new IPEndPoint(ip, port);
				serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
				serverSocket.Bind(ipEndPoint);
				serverSocket.Listen(maxConnectCount);

				connectListener = new Thread(ListenClientConnect);
				connectListener.Start();
				opened = true;
			} catch(Exception ex) {
				opened = false;
				UnityEngine.Debug.Log(ex.ToString());
			}
		}

		public void CloseServer() {
			if (connectListener != null) {
				connectListener.Abort();
				connectListener = null;
			}
			serverSocket.Close();
			serverSocket = null;
			clientSockets.Clear();
			clientSockets = null;
			message = null;
			index = 1;
			connectedCount = 0;
			isReceived = false;
			opened = false;
		}

		private void ListenClientConnect() {
			while (opened) {
				if(index == maxConnectCount) {
					index = 1;
				}
				Socket clientSocket = serverSocket.Accept();

				if (clientSocket != null) {
					if (!clientSockets.ContainsKey(index)) {
						clientSockets.Add(index, clientSocket);
					}

					index++;
					connectedCount++;
					isReceived = true;
					Thread messageListener = new Thread(RecieveMessageFromClient);
					messageListener.Start(clientSocket);
				}
			}
		}

		public void SendMessageToClient(string message) {
			if (opened) {
				foreach(KeyValuePair<int,Socket> pair in clientSockets) {
					ByteBuffer sendBuffer = new ByteBuffer();
					sendBuffer.WriteString(message);
					if (pair.Value != null) {
						pair.Value.Send(sendBuffer.WriteMessage(sendBuffer.ToBytes()));
					}
				}
			}
		}

		private void RecieveMessageFromClient(object clientSocket) {
			Socket socket = (Socket)clientSocket;
			while (isReceived) {
				socket.Receive(datas);
				ByteBuffer receiveBuffer = new ByteBuffer(datas);
				receiveBuffer.ReadShort();
				message = receiveBuffer.ReadString();
				if(message == "ClientRequestOffline") {
					ByteBuffer sendBuffer = new ByteBuffer();
					sendBuffer.WriteString("AllowClientOffline");
					socket.Send(sendBuffer.WriteMessage(sendBuffer.ToBytes()));

					connectedCount--;
					foreach(KeyValuePair<int,Socket>pair in clientSockets) {
						if(pair.Value == socket) {
							clientSockets.Remove(pair.Key);
							break;
						}
					}
					isReceived = false;
				}
			}
		}
	}