一个简易socket通信结构
服务端
基本的结构
工作需要又需要用到socketTCP通讯，这么多年了，终于稍微能写点了。让我说其实也说不出个啥来，看了很多的异步后稍微对异步socket的导流 endreceive后 再beginreceive 形成一个内循环有了个认识，加上我自己的封包拆包机制，然后再仿那些其它的大多数代码结构弄点onReceive事件进行 收包触发。整个过程就算差不多了 ，基本上是能够可靠运行的 靠谱的 中规中矩的，要说啥创新独到嘛真的谈不上。代码中写了很多low逼注释 也是为了方便自己理解 请无视。下面是server端代码，使用异步机制accept 异步receive ，成员有 clients代表当前在线的客户端 客户端socket包装为EndpointClient ，有onClientAddDel 代表客户端上线掉线事件，有onReceive代表所有客户端的收包事件，clients由于是异步的多线程访问就要涉及多线程管控 所以使用lock ，服务端有sendTo() 毫无疑问这也是通过调用特定的clients来做的。关于close() 网上说socket最好不要直接close ，但是我这里就是简单粗暴的直接close要不然 系统底层socket迟迟不释放 服务端再开的时候端口冲突 ，制造各种问题 ，何况都close了客户端也会断开连接 还会管你数据报文有无接收完整吗，所以不要人云亦云 ，遇到问题了再说 ，结合自己的理解。
然后关于多报文格式的一些补充
这部分其实是后来写了更新上来的：从我们的报文数据定义为 Telegram_Base 就可看的出来，本意是想做成可扩展的，不要管Telegram_Base是什么往后面看你就明白了。并且硬性需求 因为不止一个场景使用我们不可能把报文格式固定住 肯定得做成可扩展的。为此 我们使用模板编程方式 ，好久没有使用模板编程了 ，得复习下 记得上次使用还是《angularjs和ajax的结合使用（四）》里面的 DownloadSomething<T> ，其实我也是半瓢水 ，哈哈哈。
MsgServer 和 MsgClient 初始化的时候 传入不同的泛型 ，则Receive的时候根据不同的泛型解数据包 进而触发 onReceive 事件，你要问为什么就想到这么做可以呢，一句话自然使然 水到渠成，善于观察借鉴 。我上面的处理方式，包括用过的supersocket 也都是这种处理方式。好 改造开始，server和client都变成这样，总之一切都是围绕泛型报文展开的，包括send 和receive都要变成send<T> receive<T> 这样的
整体的类图结构：
左边代表服务端，初始化示例的时候可以通过泛型类方式 绑定Telegram_xxx等不同的 报文处理过程 ，服务端有个全局的缓冲字节receivedbuffer ，收到字节时调用不同报文对应的解析器解析，每当解析到完整包的时候通过action回调执行对应的用户自定义代码，右边是客户端 发送时自然跟服务端报文对应。 大概就这样，整体设计跟上面所描述一致，不太擅长画图 也不知道表述清楚没有。
以下是服务端代码
1 //消息服务器 2 public class MsgServer<T> where T : Telegram_Base 3 { 4 5 6 Socket serverSocket; 7 public Action<List<string>> onClientAddDel; 8 public Action<T> onReceive; 9 bool _isRunning = false; 10 11 int port; 12 13 static List<EndpointClient<T>> clients; 14 15 public bool isRunning { get { return _isRunning; } } 16 public MsgServer(int _port) 17 { 18 this.port = _port; 19 20 clients = new List<EndpointClient<T>>(); 21 22 } 23 24 public void Start() 25 { 26 try 27 { 28 //any 就决定了 ip地址格式是v4 29 //IPEndPoint endPoint = new IPEndPoint(IPAddress.Any, 7654); 30 //socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); 31 IPEndPoint endPoint = new IPEndPoint(IPAddress.Any, port); 32 serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); 33 serverSocket.Bind(endPoint); 34 serverSocket.Listen(port); 35 36 serverSocket.BeginAccept(new AsyncCallback(AcceptCallback), serverSocket); 37 38 _isRunning = true; 39 40 Logger.GetInstance().AppendMessage(LogLevel.Info, "消息服务启动完成"); 41 } 42 catch (Exception ex) 43 { 44 _isRunning = false; 45 serverSocket = null; 46 47 Logger.GetInstance().AppendMessage(LogLevel.Error, ex.Message); 48 } 49 50 } 51 52 public void Stop() 53 { 54 for (int i = 0; i < clients.Count; i++) 55 { 56 clients[i].Close(); 57 } 58 ClientAddDelGetList(null, EndPointClientsChangeType.ClearAll); 59 serverSocket.Close(); 60 _isRunning = false; 61 } 62 63 64 public void SendTo(T tel) 65 { 66 try 67 { 68 if (string.IsNullOrEmpty(tel.remoteIPPort))//发送到所有 69 { 70 for (int i = 0; i < clients.Count; i++) 71 { 72 clients[i].Send(tel); 73 } 74 } 75 else 76 { 77 for (int i = 0; i < clients.Count; i++)//发送到某个客户端 78 { 79 if (clients[i].remoteIPPort == tel.remoteIPPort) 80 { 81 clients[i].Send(tel); 82 break; 83 } 84 } 85 } 86 87 } 88 catch (Exception ex) 89 { 90 Logger.GetInstance().AppendMessage(LogLevel.Error, ex.Message); 91 } 92 } 93 94 //新增与删除客户端 秉持原子操作 95 List<string> ClientAddDelGetList(EndpointClient<T> cli, EndPointClientsChangeType changeType) 96 { 97 //异步同时有新客户端上线 与下线 不进行资源互斥访问会报错 98 lock (this) 99 { 100 if (changeType == EndPointClientsChangeType.Add) 101 { 102 clients.Add(cli); 103 } 104 else if (changeType == EndPointClientsChangeType.Del) 105 { 106 var beRemoveClient = clients.First(r => r.remoteIPPort == cli.remoteIPPort); 107 if (beRemoveClient != null) 108 clients.Remove(beRemoveClient); 109 } 110 else if (changeType == EndPointClientsChangeType.ClearAll) 111 { 112 clients.Clear(); 113 } 114 else if (changeType == EndPointClientsChangeType.GetAll) 115 { 116 List<string> onLines = new List<string>(clients.Count); 117 for (int i = 0; i < clients.Count; i++) 118 { 119 onLines.Add(clients[i].remoteIPPort); 120 } 121 return onLines; 122 } 123 else 124 { 125 return null; 126 } 127 } 128 return null; 129 } 130 //异步监听客户端 有客户端到来时的回调 131 private void AcceptCallback(IAsyncResult iar) 132 { 133 //server端一直在receive 能够感知到客户端掉线 （连上后 关闭客户端 server立即有错误爆出） 134 //但是同情况 关闭server端 客户端无错误爆出 直到点发送 才有错误爆出 135 //由此得出 处于receive才会有掉线感知 ，send时发现发不出去自然也会有感知 跟人的正常思维理解是一样的 136 //虽然tcp是所谓的长连接 ，通过反复测试 ->但是双方相互都处在一个静止状态 是无法 确定在不在的 137 //连上后平常的情况下 并没有数据流通 的 ,双方只是一个状态的保持而已。 138 //这也是为什么 好多服务 客户端 程序 都有个心跳机制（由此我们可以想到继续完善 弄个客户端列表 心跳超时的剔除列表 正常发消息send 或receive 异常的剔除列表 删除clientSocket 139 //其实非要说吧 一般情况 服务端一直在receive 不用心跳其实也是可以的（客户端可能是真的需要 140 //tcp底层就已经有了一个判断对方在不在的机制 ， 对方直接关程序 结束进程 这些 只要tcp在receive就立即能够感知 所以说心跳 用不用看情况吧 141 142 //tcp 不会丢包 哪怕是连接建立了 你还没开始receive 对方却先发了， 143 //对方只要是发了的数据 都由操作系统像个缓存样给你放那的 不会掉 你再隔10秒开始receive都能rec的到 144 145 //tcp甚至在拔掉网线 再重新插上 都可以保证数据一致性 146 //tcp的包顺序能够保证 先发的先到 147 148 //nures代码中那些beginreceivexxx 异步receive的核心机制就是 ，假定数据到的时候把数据保存到xxx数组 149 //真正endreceive的时候 其实数据已经接收 处理完成了 150 try 151 { 152 153 //处理完当前accept 154 Socket currentSocket = serverSocket.EndAccept(iar); 155 156 EndpointClient<T> client = new EndpointClient<T>(currentSocket); 157 158 //新增客户端 159 ClientAddDelGetList(client, EndPointClientsChangeType.Add); 160 161 if (onClientAddDel != null) 162 { 163 List<string> onlines = ClientAddDelGetList(null, EndPointClientsChangeType.GetAll); 164 onClientAddDel(onlines); 165 166 //客户端异常掉线 167 client.onClientDel = new Action<string>((_remoteIPPort) => 168 { 169 ClientAddDelGetList(new EndpointClient<T>() { remoteIPPort = _remoteIPPort }, EndPointClientsChangeType.Del); 170 171 List<string> onlines2 = ClientAddDelGetList(null, EndPointClientsChangeType.GetAll); 172 onClientAddDel(onlines2); 173 }); 174 } 175 176 177 Logger.GetInstance().AppendMessage(LogLevel.Debug, string.Format("new client ->{0}", currentSocket.RemoteEndPoint.ToString())); 178 //Console.WriteLine(string.Format("new client ->{0}", currentSocket.RemoteEndPoint.ToString())); 179 180 //currentSocket.Close(); 181 //Application.Exit(); 182 183 //Thread.Sleep(1000 * 10); 184 client.onReceive += this.onReceive; 185 186 client.BeginReceive(); 187 188 189 //立即开始accept新的客户端 190 if (isRunning == true && serverSocket != null) 191 serverSocket.BeginAccept(AcceptCallback, serverSocket); 192 //beginAccept 最开始的方法可以不一样 ，但最终肯定是一个不断accept的闭环过程 193 //整个过程就像个导流样 ，最开始用异步导流到一个固定的点 然后让其循环源源不断运转 194 195 } 196 catch (Exception ex) 197 { 198 Logger.GetInstance().AppendMessage(LogLevel.Error, ex.Message); 199 Console.WriteLine(ex.Message); 200 } 201 202 } 203 204 205 }
EndpointClient终端代码代表客户端的对口人，他的onReceive 等资源从服务端继承 ，如果服务端想给某个特定客户端发数据则会调用他们中的某一个 毫无疑问这是通过remoteIPport来判断的，这些都是编写基本socket结构轻车熟路的老套路
以下EndpointClient代码
1 public class EndpointClient<T> where T : Telegram_Base 2 { 3 Socket workingSocket; 4 static int receiveBufferLenMax = 5000; 5 byte[] onceReadDatas = new byte[receiveBufferLenMax]; 6 List<byte> receiveBuffer = new List<byte>(receiveBufferLenMax); 7 8 public string remoteIPPort { get; set; } 9 10 //当前残留数据区 长度 11 int receiveBufferLen = 0; 12 13 14 15 public Action<T> onReceive; 16 public Action<string> onClientDel; 17 18 public EndpointClient() 19 { 20 21 } 22 public EndpointClient(Socket _socket) 23 { 24 this.remoteIPPort = _socket.RemoteEndPoint.ToString(); 25 workingSocket = _socket; 26 } 27 28 public void Send(T tel) 29 { 30 //try 31 //{ 32 if (workingSocket == null) 33 { 34 Console.WriteLine("未初始化的EndpointClient"); 35 return; 36 } 37 if (tel is Telegram_Schedule) 38 { 39 Telegram_Schedule telBeSend = tel as Telegram_Schedule; 40 if (telBeSend.dataBytes.Length != telBeSend.dataLen) 41 { 42 Console.WriteLine("尝试发送数据长度格式错误的报文"); 43 return; 44 } 45 46 byte[] sendBytesHeader = telBeSend.dataBytesHeader; 47 byte[] sendbytes = telBeSend.dataBytes; 48 49 //数据超过缓冲区长度 会导致无法拆包 50 if (sendbytes.Length <= receiveBufferLenMax) 51 { 52 workingSocket.BeginSend(sendBytesHeader, 0, sendBytesHeader.Length, 0, null, null); 53 workingSocket.BeginSend(sendbytes, 0, sendbytes.Length, 0, null, null 54 // new AsyncCallback((iar) => 55 //{ 56 // EndpointClient endClient = (EndpointClient)iar.AsyncState; 57 // endClient.workingSocket.EndSend(iar); 58 //}), 59 //this 60 ); 61 } 62 else 63 { 64 Console.WriteLine("发送到调度客户端的数据超过缓冲区长度"); 65 throw new Exception("发送到调度客户端的数据超过缓冲区长度"); 66 } 67 68 69 } 70 else if (tel is Telegram_SDBMsg) 71 { 72 Telegram_SDBMsg telBesendSDB = tel as Telegram_SDBMsg; 73 if (telBesendSDB.dataBytes.Length != telBesendSDB.dataLen) 74 { 75 Console.WriteLine("尝试发送数据长度格式错误的报文"); 76 return; 77 } 78 byte[] sendBytesHeader = telBesendSDB.dataBytesHeader; 79 byte[] sendbytes = telBesendSDB.dataBytes; 80 81 //数据超过缓冲区长度 会导致无法拆包 82 if (sendbytes.Length <= receiveBufferLenMax) 83 { 84 workingSocket.BeginSend(sendBytesHeader, 0, sendBytesHeader.Length, 0, null, null); 85 workingSocket.BeginSend(sendbytes, 0, sendbytes.Length, 0, null, null 86 87 ); 88 } 89 else 90 { 91 Console.WriteLine("发送到调度客户端的数据超过缓冲区长度"); 92 throw new Exception("发送到调度客户端的数据超过缓冲区长度"); 93 } 94 } 95 96 //} 97 //catch (Exception ex) 98 //{ 99 100 // Console.WriteLine(ex.Message); 101 // throw ex; 102 //} 103 } 104 105 public void BeginReceive() 106 { 107 if (workingSocket == null) 108 { 109 Console.WriteLine("未初始化的EndpointClient"); 110 return; 111 } 112 113 receiveBufferLen = 0; 114 workingSocket.BeginReceive(onceReadDatas, 0, receiveBufferLenMax, SocketFlags.None, 115 ReceiveCallback, 116 // new AsyncCallback((IAsyncResult iar) => { 117 // EndpointClient cli = (EndpointClient)iar.AsyncState; 118 // int reds = cli.client.EndReceive(iar); 119 //}), 120 this); 121 } 122 private void ReceiveCallback(IAsyncResult iar) 123 { 124 try 125 { 126 EndpointClient<T> cli = (EndpointClient<T>)iar.AsyncState; 127 Socket socket = cli.workingSocket; 128 int reads = socket.EndReceive(iar); 129 130 if (reads > 0) 131 { 132 133 for (int i = 0; i < reads; i++) 134 { 135 receiveBuffer.Add(onceReadDatas[i]); 136 } 137 138 //具体填充了多少看返回值 此时 数据已经在buffer中了 139 receiveBufferLen += reads; 140 //加完了后解析 阻塞式处理 结束后开启新的接收 141 SloveTelData(); 142 143 if (receiveBufferLenMax - receiveBufferLen > 0) 144 { 145 //接收完了 继续beginreceive 开启异步的下次接收 (如果缓冲区有残留数据 则接收长度变短 ，没接收到的让其留在socket不会丢失 下次接收) 146 socket.BeginReceive(onceReadDatas, 0, receiveBufferLenMax - receiveBufferLen, SocketFlags.None, ReceiveCallback, this); 147 } 148 else//阻塞式处理都完成一遍了 都还没清理出任何缓冲区空间 毫无疑问 整体运转机制已经挂了 不用beginreceive下一次了 149 { 150 Close(); 151 //移除自己 152 if (onClientDel != null) 153 { 154 onClientDel(remoteIPPort); 155 } 156 Logger.GetInstance().AppendMessage(LogLevel.Error, "服务端接口解析数据出现异常"); 157 //Console.WriteLine("服务端接口解析数据出现异常"); 158 //throw new Exception("服务端接口解析数据出现异常"); 159 } 160 } 161 else//reads==0 客户端已关闭 162 { 163 Close(); 164 //移除自己 165 if (onClientDel != null) 166 { 167 onClientDel(remoteIPPort); 168 } 169 } 170 } 171 catch (Exception ex) 172 { 173 Close(); 174 //移除自己 175 if (onClientDel != null) 176 { 177 onClientDel(remoteIPPort); 178 } 179 Logger.GetInstance().AppendMessage(LogLevel.Error, "ReceiveCallback Error" + ex.Message); 180 //Console.WriteLine("ReceiveCallback Error"); 181 //Console.WriteLine(ex.Message); 182 } 183 184 } 185 void SloveTelData() 186 { 187 //进行数据解析 188 189 190 if (typeof(T) == typeof(Telegram_Schedule)) 191 { 192 SloveTelDataUtil slo = new SloveTelDataUtil(); 193 List<Telegram_Schedule> dataEntitys = slo.Slove_Telegram_Schedule(receiveBuffer, receiveBufferLen, this.remoteIPPort); 194 //buffer已经被处理一遍了 使用新的长度 195 receiveBufferLen = receiveBuffer.Count; 196 //解析出的每一个对象都触发 onreceive 197 for (int i = 0; i < dataEntitys.Count; i++) 198 { 199 if (onReceive != null) 200 onReceive(dataEntitys[i] as T); 201 } 202 } 203 else if (typeof(T) == typeof(Telegram_SDBMsg)) 204 { 205 SloveTelSDBMsgUtil sloSDB = new SloveTelSDBMsgUtil(); 206 List<Telegram_SDBMsg> dataEntitys = sloSDB.Slove_Telegram_SDB(receiveBuffer, receiveBufferLen, this.remoteIPPort); 207 receiveBufferLen = receiveBuffer.Count; 208 //解析出的每一个对象都触发 onreceive 209 for (int i = 0; i < dataEntitys.Count; i++) 210 { 211 if (onReceive != null) 212 onReceive(dataEntitys[i] as T); 213 } 214 } 215 216 } 217 218 219 public void Close() 220 { 221 try 222 { 223 receiveBuffer.Clear(); 224 receiveBufferLen = 0; 225 if (workingSocket != null && workingSocket.Connected) 226 workingSocket.Close(); 227 } 228 catch (Exception ex) 229 { 230 Console.WriteLine(ex.Message); 231 } 232 233 } 234 }
数据拆包与封包粘包处理
上面的代码可以看到 数据包处理都在receiveCallback里 SloveTelData，也是通用的套路 ，解析到完整的包后从缓冲区移除 解析多少个包触发多少次事件，残余数据留在缓冲区 然后继续开始新的beginReceive往缓冲区加。在异步机制中 到达endReceive的时候数据已经在缓冲区里了，这个自不用多说噻。数据包和粘包逻辑在公共类库里供客户端服务端共同调用。
以下是Telegram_schedule数据包的粘包处理逻辑 ，当然看代码你知道还有另外一个报文处理逻辑 我不列举了。
1 public class SloveTelDataUtil 2 { 3 List<Telegram_Schedule> solveList; 4 public SloveTelDataUtil() 5 { 6 } 7 8 List<byte> buffer; 9 int bufferLen; 10 int bufferIndex = 0; 11 string remoteIPPort; 12 public List<Telegram_Schedule> Slove_Telegram_Schedule( List< byte> _buffer,int _bufferLen,string _remoteIPPort) 13 { 14 15 solveList = new List<Telegram_Schedule>(); 16 buffer = _buffer; 17 bufferLen = _bufferLen; 18 bufferIndex = 0; 19 remoteIPPort = _remoteIPPort; 20 21 //小于最小长度 直接返回 22 if (bufferLen < 12) 23 return solveList; 24 25 //进行数据解析 26 bool anaysisOK = false; 27 while (anaysisOK=AnaysisData_Schedule()==true)//直到解析的不能解析为止 28 { 29 } 30 return solveList; 31 } 32 33 public bool AnaysisData_Schedule() 34 { 35 if (bufferLen - bufferIndex < GlobalSymbol.Headerlen) 36 return false; 37 38 //解析出一个数据对象 39 Telegram_Schedule telObj = new Telegram_Schedule(); 40 41 //必定是大于最小数据大小的 42 telObj.dataBytesHeader = new byte[GlobalSymbol.Headerlen]; 43 buffer.CopyTo(bufferIndex, telObj.dataBytesHeader, 0, GlobalSymbol.Headerlen); 44 45 byte[] btsHeader = new byte[4]; 46 byte[] btsCommand = new byte[4]; 47 byte[] btsLen = new byte[4]; 48 49 btsHeader[0] = buffer[bufferIndex]; 50 btsHeader[1] = buffer[bufferIndex+1]; 51 btsHeader[2] = buffer[bufferIndex+2]; 52 btsHeader[3] = buffer[bufferIndex+3]; 53 54 bufferIndex += 4; 55 56 btsCommand[0] = buffer[bufferIndex]; 57 btsCommand[1] = buffer[bufferIndex + 1]; 58 btsCommand[2] = buffer[bufferIndex + 2]; 59 btsCommand[3] = buffer[bufferIndex + 3]; 60 61 bufferIndex += 4; 62 63 btsLen[0] = buffer[bufferIndex]; 64 btsLen[1] = buffer[bufferIndex + 1]; 65 btsLen[2] = buffer[bufferIndex + 2]; 66 btsLen[3] = buffer[bufferIndex + 3]; 67 68 bufferIndex += 4; 69 70 71 72 int dataLen = BitConverter.ToInt32(btsLen, 0); 73 telObj.head = BitConverter.ToUInt32(btsHeader, 0); 74 telObj.command = BitConverter.ToInt32(btsCommand, 0); 75 telObj.remoteIPPort = remoteIPPort; 76 77 if(dataLen>0) 78 { 79 //数据区小于得到的数据长度 说明数据部分还没接收到 不删除缓冲区 不做任何处理 80 //下次来了连着头一起解析 81 if (bufferLen - GlobalSymbol.Headerlen < dataLen) 82 { 83 84 bufferIndex -= 12;// 85 86 87 return false; 88 89 } 90 else 91 { 92 93 telObj.dataLen = dataLen; 94 telObj.dataBytes = new byte[dataLen]; 95 buffer.CopyTo(bufferIndex, telObj.dataBytes, 0, dataLen); 96 97 solveList.Add(telObj); 98 //bufferIndex += dataLen; 99 100 //解析成功一次 移除已解析的 101 for (int i = 0; i < GlobalSymbol.Headerlen+dataLen; i++) 102 { 103 buffer.RemoveAt(0); 104 } 105 bufferIndex = 0; 106 bufferLen = buffer.Count; 107 return true; 108 } 109 } 110 else 111 { 112 113 telObj.dataLen = 0; 114 solveList.Add(telObj); 115 //bufferIndex += 0; 116 //解析成功一次 移除已解析的 117 for (int i = 0; i < GlobalSymbol.Headerlen; i++) 118 { 119 buffer.RemoveAt(0); 120 } 121 //解析成功一次因为移除了缓冲区 bufferIndex置0 122 bufferIndex = 0; 123 bufferLen = buffer.Count; 124 return true; 125 } 126 127 } 128 129 }
我们看到用到的数据包对象是Telegram_Schedule ，中间保存有报文数据，数据发送的目标等信息。
以下是数据包结构代码
1 public class Telegram_Base 2 { 3 public string remoteIPPort { get; set; } 4 5 //头部内容的序列化 6 public byte[] dataBytesHeader { get; set; } 7 8 //数据内容 9 public byte[] dataBytes { get; set; } 10 11 public int headerLen { get; set; } 12 //数据长度 4字节 13 public int dataLen { get; set; } 14 15 public string jsonStr { get; set; } 16 virtual public void SerialToBytes() 17 { 18 19 } 20 21 virtual public void SloveToTel() 22 { 23 24 } 25 26 } 27 28 29 public class Telegram_Schedule:Telegram_Base 30 { 31 32 //头部标识 4字节 33 public UInt32 head { get; set; } 34 //命令对应枚举的 int 4字节 35 public int command { get; set; } 36 37 38 override public void SerialToBytes() 39 { 40 //有字符串数据 但是待发送字节是空 41 if ((string.IsNullOrEmpty(jsonStr) == false ))//&& (dataBytes==null || dataBytes.Length==0) 42 { 43 dataBytes = Encoding.UTF8.GetBytes(jsonStr); 44 dataLen = dataBytes.Length; 45 dataBytesHeader = new byte[GlobalSymbol.Headerlen]; 46 47 head = GlobalSymbol.HeaderSymbol; 48 49 byte[] btsHeader = BitConverter.GetBytes(head); 50 byte[] btsCommand = BitConverter.GetBytes(command); 51 byte[] btsLen = BitConverter.GetBytes(dataLen); 52 53 Array.Copy(btsHeader, 0, dataBytesHeader, 0, 4); 54 Array.Copy(btsCommand, 0, dataBytesHeader, 4, 4); 55 Array.Copy(btsLen, 0, dataBytesHeader, 8, 4); 56 57 } 58 else if((string.IsNullOrEmpty(jsonStr) == true )&& (dataBytes==null || dataBytes.Length==0)){ 59 dataLen = 0; 60 dataBytes = new byte[0]; 61 62 dataBytesHeader = new byte[GlobalSymbol.Headerlen]; 63 64 head = GlobalSymbol.HeaderSymbol; 65 66 byte[] btsHeader = BitConverter.GetBytes(head); 67 byte[] btsCommand = BitConverter.GetBytes(command); 68 byte[] btsLen = BitConverter.GetBytes(dataLen); 69 70 Array.Copy(btsHeader, 0, dataBytesHeader, 0, 4); 71 Array.Copy(btsCommand, 0, dataBytesHeader, 4, 4); 72 Array.Copy(btsLen, 0, dataBytesHeader, 8, 4); 73 } 74 } 75 76 override public void SloveToTel() 77 { 78 //只解析字符串数据部分 ，header 和len 在接收之初就已解析 79 try 80 { 81 if (this.dataBytes != null && this.dataBytes.Length > 0) 82 this.jsonStr = Encoding.UTF8.GetString(this.dataBytes); 83 } 84 catch (Exception ex) 85 { 86 Logger.GetInstance().AppendMessage(LogLevel.Error, "data部分字符串解析出错 " + ex.Message); 87 } 88 } 89 90 }
客户端代码
最后是客户端，有了上面的结构，客户端就不足为谈了，稍微了解socket的人都熟知套路的 基本跟EndpointClient一致
1 public class MsgClient<T> where T : Telegram_Base 2 { 3 Socket workingSocket; 4 //缓冲区最大数据长度 5 static int receiveBufferLenMax = 5000; 6 //单次receive数据（取决于tcp底层封包 但是不会超过缓冲区最大长度 7 byte[] onceReadDatas = new byte[receiveBufferLenMax]; 8 //未解析到完整数据包时的残余数据保存区 9 List<byte> receiveBuffer = new List<byte>(receiveBufferLenMax); 10 11 string serverIP { get; set; } 12 int serverPort { get; set; } 13 public string localIPPort { get; set; } 14 15 //残余缓冲区数据长度 16 int receiveBufferLen = 0; 17 18 bool _isConnected { get; set; } 19 20 21 //收一个包时触发 22 public Action<T> onReceive; 23 //与服务端断链时触发 24 public Action<string> onClientDel; 25 26 27 public bool isConnected { get { return _isConnected; } } 28 public MsgClient(string _serverIP, int _port) 29 { 30 serverIP = _serverIP; 31 serverPort = _port; 32 _isConnected = false; 33 } 34 35 public void Connect() 36 { 37 try 38 { 39 workingSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP); 40 IPEndPoint ipport = new IPEndPoint(IPAddress.Parse(serverIP), serverPort); 41 workingSocket.Connect(ipport); 42 43 localIPPort = workingSocket.LocalEndPoint.ToString(); 44 _isConnected = true; 45 BeginReceive(); 46 } 47 catch (Exception ex) 48 { 49 workingSocket = null; 50 _isConnected = false; 51 52 Logger.GetInstance().AppendMessage(LogLevel.Error,"连接到服务端出错："+ ex.Message); 53 } 54 55 } 56 57 58 59 60 public void Send(T tel) 61 { 62 try 63 { 64 if (_isConnected == false) 65 { 66 Console.WriteLine("未连接到服务器"); 67 return; 68 } 69 if (tel is Telegram_Schedule) 70 { 71 Telegram_Schedule telBeSend = tel as Telegram_Schedule; 72 if (telBeSend.dataBytes.Length != telBeSend.dataLen) 73 { 74 Console.WriteLine("尝试发送数据长度格式错误的报文"); 75 return; 76 } 77 byte[] sendBytesHeader = telBeSend.dataBytesHeader; 78 byte[] sendbytes = telBeSend.dataBytes; 79 80 //数据超过缓冲区长度 会导致无法拆包 81 if (sendbytes.Length <= receiveBufferLenMax) 82 { 83 workingSocket.BeginSend(sendBytesHeader, 0, sendBytesHeader.Length, 0, null, null); 84 workingSocket.BeginSend(sendbytes, 0, sendbytes.Length, 0, null, null 85 86 ); 87 } 88 else 89 { 90 Logger.GetInstance().AppendMessage(LogLevel.Error, "发送到调度客户端的数据超过缓冲区长度"); 91 throw new Exception("发送到调度客户端的数据超过缓冲区长度"); 92 } 93 94 95 } 96 else if (tel is Telegram_SDBMsg) 97 { 98 Telegram_SDBMsg telBesendSDB = tel as Telegram_SDBMsg; 99 if (telBesendSDB.dataBytes.Length != telBesendSDB.dataLen) 100 { 101 Console.WriteLine("尝试发送数据长度格式错误的报文"); 102 return; 103 } 104 byte[] sendBytesHeader = telBesendSDB.dataBytesHeader; 105 byte[] sendbytes = telBesendSDB.dataBytes; 106 107 //数据超过缓冲区长度 会导致无法拆包 108 if (sendbytes.Length <= receiveBufferLenMax) 109 { 110 workingSocket.BeginSend(sendBytesHeader, 0, sendBytesHeader.Length, 0, null, null); 111 workingSocket.BeginSend(sendbytes, 0, sendbytes.Length, 0, null, null); 112 } 113 else 114 { 115 Logger.GetInstance().AppendMessage(LogLevel.Error, "发送到调度客户端的数据超过缓冲区长度"); 116 throw new Exception("发送到调度客户端的数据超过缓冲区长度"); 117 } 118 } 119 120 } 121 catch (Exception ex) 122 { 123 Logger.GetInstance().AppendMessage(LogLevel.Error, ex.Message); 124 Close(); 125 //Console.WriteLine(ex.Message); 126 //throw ex; 127 } 128 } 129 130 public void BeginReceive() 131 { 132 receiveBufferLen = 0; 133 workingSocket.BeginReceive(onceReadDatas, 0, receiveBufferLenMax, SocketFlags.None, 134 ReceiveCallback, 135 136 this); 137 } 138 private void ReceiveCallback(IAsyncResult iar) 139 { 140 try 141 { 142 MsgClient<T> cli = (MsgClient<T>)iar.AsyncState; 143 Socket socket = cli.workingSocket; 144 int reads = socket.EndReceive(iar); 145 146 if (reads > 0) 147 { 148 149 for (int i = 0; i < reads; i++) 150 { 151 receiveBuffer.Add(onceReadDatas[i]); 152 } 153 154 //具体填充了多少看返回值 此时 数据已经在buffer中了 155 156 receiveBufferLen += reads; 157 158 //加完了后解析 阻塞式处理 结束后开启新的接收 159 SloveTelData(); 160 161 162 163 if (receiveBufferLenMax - receiveBufferLen > 0) 164 { 165 //接收完了 继续beginreceive 开启异步的下次接收 (如果缓冲区有残留数据 则接收长度变短 ，没接收到的让其留在socket不会丢失 下次接收) 166 socket.BeginReceive(onceReadDatas, 0, receiveBufferLenMax - receiveBufferLen, SocketFlags.None, ReceiveCallback, this); 167 } 168 else//阻塞式处理都完成一遍了 都还没清理出任何缓冲区空间 毫无疑问 整体运转机制已经挂了 不用beginreceive下一次了 169 { 170 Close(); 171 172 Console.WriteLine("服务端接口解析数据出现异常"); 173 throw new Exception("服务端接口解析数据出现异常"); 174 } 175 } 176 else//reads==0客户端已关闭 177 { 178 Close(); 179 } 180 } 181 catch (Exception ex) 182 { 183 Close(); 184 185 Console.WriteLine("ReceiveCallback Error"); 186 Console.WriteLine(ex.Message); 187 } 188 189 } 190 private void SloveTelData() 191 { 192 193 //进行数据解析 194 195 196 if (typeof(T) == typeof(Telegram_Schedule)) 197 { 198 SloveTelDataUtil slo = new SloveTelDataUtil(); 199 List<Telegram_Schedule> dataEntitys = slo.Slove_Telegram_Schedule(receiveBuffer, receiveBufferLen, serverIP + ":" + serverPort.ToString()); 200 //buffer已经被处理一遍了 使用新的长度 201 receiveBufferLen = receiveBuffer.Count; 202 //解析出的每一个对象都触发 onreceive 203 for (int i = 0; i < dataEntitys.Count; i++) 204 { 205 if (onReceive != null) 206 onReceive(dataEntitys[i] as T); 207 } 208 } 209 else if (typeof(T) == typeof(Telegram_SDBMsg)) 210 { 211 SloveTelSDBMsgUtil sloSDB = new SloveTelSDBMsgUtil(); 212 List<Telegram_SDBMsg> dataEntitys = sloSDB.Slove_Telegram_SDB(receiveBuffer, receiveBufferLen, serverIP + ":" + serverPort.ToString()); 213 receiveBufferLen = receiveBuffer.Count; 214 //解析出的每一个对象都触发 onreceive 215 for (int i = 0; i < dataEntitys.Count; i++) 216 { 217 if (onReceive != null) 218 onReceive(dataEntitys[i] as T); 219 } 220 } 221 222 } 223 224 225 public void Close() 226 { 227 try 228 { 229 _isConnected = false; 230 231 receiveBuffer.Clear(); 232 receiveBufferLen = 0; 233 if (workingSocket != null && workingSocket.Connected) 234 workingSocket.Close(); 235 } 236 catch (Exception ex) 237 { 238 Console.WriteLine(ex.Message); 239 } 240 241 } 242 243 }
服务端调用
构建一个winform基本项目
1 List<string> clients; 2 TCPListener server2; 3 private void button1_Click(object sender, EventArgs e) 4 { 5 server = new MsgServer<Telegram_Schedule>(int.Parse(tbx_port.Text)); 6 7 server.Start(); 8 if (server.isRunning == true) 9 { 10 button1.Enabled = false; 11 12 server.onReceive += new Action<Telegram_Base>( 13 (tel) => 14 { 15 this.BeginInvoke(new Action(() => 16 { 17 if (tel is Telegram_Schedule) 18 { 19 Telegram_Schedule ts = tel as Telegram_Schedule; 20 ts.SloveToTel(); 21 //Console.WriteLine(string.Format("commandType:{0}", ((ScheduleTelCommandType)ts.command).ToString())); 22 23 textBox1.Text += ts.remoteIPPort + ">" + ts.jsonStr + "\r\n"; 24 25 //数据回发测试 26 string fromip = ts.remoteIPPort; 27 string srcMsg = ts.jsonStr; 28 string fromServerMsg = ts.jsonStr + " -from server"; 29 ts.jsonStr = fromServerMsg; 30 31 32 //如果消息里有指向信息 则转送到对应的客户端 33 if (clients != null) 34 { 35 string to = null; 36 for (int i = 0; i < clients.Count; i++) 37 { 38 if (srcMsg.Contains(clients[i])) 39 { 40 to = clients[i]; 41 break; 42 } 43 } 44 45 if (to != null) 46 { 47 ts.remoteIPPort = to; 48 string toMsg; 49 //toMsg= srcMsg.Replace(to, ""); 50 toMsg = srcMsg.Replace(to, fromip); 51 ts.jsonStr = toMsg; 52 ts.SerialToBytes(); 53 54 server.SendTo(ts); 55 } 56 else 57 { 58 ts.SerialToBytes(); 59 server.SendTo(ts); 60 } 61 } 62 } 63 })); 64 65 } 66 ); 67 68 server.onClientAddDel += new Action<List<string>>((onlines) => 69 { 70 this.BeginInvoke( 71 new Action(() => 72 { 73 clients = onlines; 74 listBox1.Items.Clear(); 75 76 for (int i = 0; i < onlines.Count; i++) 77 { 78 listBox1.Items.Add(onlines[i]); 79 } 80 })); 81 }); 82 } 83 }
客户端调用
1 MsgClient<Telegram_Schedule> client; 2 TCPClient client2; 3 private void btn_start_Click(object sender, EventArgs e) 4 { 5 client = new MsgClient<Telegram_Schedule>(tbx_ip.Text, int.Parse(tbx_port.Text)); 6 7 client.Connect(); 8 9 if (client.isConnected == true) 10 { 11 btn_start.Enabled = false; 12 13 label1.Text = client.localIPPort; 14 15 client.onReceive = new Action<Telegram_Base>((tel) => 16 { 17 this.BeginInvoke( 18 new Action(() => 19 { 20 tel.SloveToTel(); 21 tbx_rec.Text += tel.jsonStr + "\r\n"; 22 23 })); 24 }); 25 } 26 27 } 28 29 30 private void btn_send_Click(object sender, EventArgs e) 31 { 32 33 34 if (client == null || client.isConnected == false) 35 return; 36 37 //for (int i = 0; i < 2; i++) 38 //{ 39 Telegram_Schedule tel = new Telegram_Schedule(); 40 //tel.command = (int)ScheduleTelCommandType.MsgC2S; 41 42 tel.jsonStr = tbx_remoteip.Text+">"+ tbx_msgSend.Text; 43 tel.SerialToBytes();//发出前要先序列化 44 45 client.Send(tel); 46 //} 47 48 }
实现效果
可以多客户端连接互相自由发送消息，服务端可以编写转发规则代码，那些什么棋牌啊 互动白板 以及其他类似的应用就可以基于此之上发挥想象了。标题叫一个简易socket通信结构 ，一路走下来你看整个结构其实也并不是那么简易 ，断断续续调了几周 解决了很多问题。完美的支持报文格式切换，这里只是拿聊天功能做个示例，但是其实这已经是一个由我编写出来 然后测试 并成功商业应用了的部分哈 ，可靠 稳定 你值得拥有。都知道流行GitHub 但是本人并不习惯把代码放GitHub上见谅。
