SocketOperation网络通信封装

  1     public sealed class SocketOperation
  2     {
  3         string strBufferLeft = string.Empty;
  4 
  5         public SocketOperation()
  6         {
  7         }
  8 
  9         /**/
 10         /// <summary>  
 11         /// 连接使用 tcp 协议的服务端  
 12         /// </summary>  
 13         /// <param name="ip">服务端的ip地址</param>  
 14         /// <param name="port">服务端的端口号</param>  
 15         /// <returns></returns>  
 16         public Socket ConnectServer(string ip, int port)
 17         {
 18             Socket s = null;
 19 
 20             try
 21             {
 22                 IPAddress ipAddress = IPAddress.Parse(ip);
 23                 IPEndPoint ipEndPoint = new IPEndPoint(ipAddress, port);
 24                 //EndPoint EndPointLocal=(EndPoint)(new IPEndPoint(IPAddress.Parse(Global.PCIP), 35001));
 25 
 26                 s = new Socket(ipEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
 27                 //s.Bind(EndPointLocal);
 28                 if (0 != Global.TestCount)
 29                 {
 30                     Thread.Sleep(15000);
 31                 }
 32                 //MessageBox.Show(Global.PCIP);
 33                 s.Connect(ipEndPoint);
 34                 //MessageBox.Show(s.Connected.ToString());
 35                 if (s.Connected == false)
 36                 {
 37                     s = null;
 38                 }
 39             }
 40             catch (Exception e)
 41             {
 42                 //Log.WriteLog ( e );  
 43             }
 44             return s;
 45         }
 46 
 47         /**/
 48         /// <summary>  
 49         /// 用主机名称连接使用Tcp协议的服务端  
 50         /// </summary>  
 51         /// <param name="hostName">在hosts 文件中存在的主机名称</param>  
 52         /// <param name="port">服务端的端口号</param>  
 53         /// <returns></returns>  
 54         public Socket ConnectServByHostName(string hostName, int port)
 55         {
 56             Socket s = null;
 57             IPHostEntry iphe = null;
 58 
 59             try
 60             {
 61                 iphe = Dns.Resolve(hostName);
 62                 foreach (IPAddress ipad in iphe.AddressList)
 63                 {
 64                     IPEndPoint ipe = new IPEndPoint(ipad, port);
 65                     Socket tmps = new Socket(ipe.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
 66                     tmps.Connect(ipe);
 67 
 68                     if (tmps.Connected)
 69                     {
 70                         s = tmps;
 71                         break;
 72                     }
 73                     else
 74                         continue;
 75                 }
 76             }
 77             catch (Exception e)
 78             {
 79                 //Log.WriteLog ( e );  
 80             }
 81             return s;
 82         }
 83 
 84         /**/
 85         /// <summary>  
 86         /// 向远程主机发送数据  
 87         /// </summary>  
 88         /// <param name="socket">要发送数据且已经连接到远程主机的 Socket</param>  
 89         /// <param name="buffer">待发送的数据</param>  
 90         /// <param name="outTime">发送数据的超时时间，以秒为单位，可以精确到微秒</param>  
 91         /// <returns>0:发送数据成功；-1:超时；-2:发送数据出现错误；-3:发送数据时出现异常</returns>  
 92         /// <remarks >  
 93         /// 当 outTime 指定为-1时，将一直等待直到有数据需要发送  
 94         /// </remarks>  
 95         public int SendData(Socket socket, byte[] buffer, int outTime)
 96         {
 97             if (socket == null || socket.Connected == false)
 98             {
 99                 throw new ArgumentException("参数socket 为null，或者未连接到远程计算机");
100             }
101             if (buffer == null || buffer.Length == 0)
102             {
103                 throw new ArgumentException("参数buffer 为null ,或者长度为 0");
104             }
105 
106             int flag = 0;
107             try
108             {
109                 int left = buffer.Length;
110                 int sndLen = 0;
111 
112                 while (true)
113                 {
114                     if ((socket.Poll(outTime * 1000000, SelectMode.SelectWrite) == true))
115                     {        // 收集了足够多的传出数据后开始发送  
116                         sndLen = socket.Send(buffer, sndLen, left, SocketFlags.None);
117                         left -= sndLen;
118                         if (left == 0)
119                         {                                        // 数据已经全部发送  
120                             flag = 0;
121                             break;
122                         }
123                         else
124                         {
125                             if (sndLen > 0)
126                             {                                    // 数据部分已经被发送  
127                                 continue;
128                             }
129                             else
130                             {                                                // 发送数据发生错误  
131                                 flag = -2;
132                                 break;
133                             }
134                         }
135                     }
136                     else
137                     {                                                        // 超时退出  
138                         flag = -1;
139                         break;
140                     }
141                 }
142             }
143             catch (SocketException e)
144             {
145                 //Log.WriteLog ( e );  
146                 flag = -3;
147             }
148             return flag;
149         }
150 
151 
152         /**/
153         /// <summary>  
154         /// 向远程主机发送数据  
155         /// </summary>  
156         /// <param name="socket">要发送数据且已经连接到远程主机的 Socket</param>  
157         /// <param name="buffer">待发送的字符串</param>  
158         /// <param name="outTime">发送数据的超时时间，以秒为单位，可以精确到微秒</param>  
159         /// <returns>0:发送数据成功；-1:超时；-2:发送数据出现错误；-3:发送数据时出现异常</returns>  
160         /// <remarks >  
161         /// 当 outTime 指定为-1时，将一直等待直到有数据需要发送  
162         /// </remarks>  
163         public int SendData(Socket socket, string buffer, int outTime)
164         {
165             if (buffer == null || buffer.Length == 0)
166             {
167                 throw new ArgumentException("待发送的字符串长度不能为零.");
168             }
169             return (SendData(socket, System.Text.Encoding.Default.GetBytes(buffer), outTime));
170         }
171 
172 
173         /**/
174         /// <summary>  
175         /// 接收远程主机发送的数据  
176         /// </summary>  
177         /// <param name="socket">要接收数据且已经连接到远程主机的 socket</param>  
178         /// <param name="buffer">接收数据的缓冲区</param>  
179         /// <param name="outTime">接收数据的超时时间，以秒为单位，可以精确到微秒</param>  
180         /// <returns>0:接收数据成功；-1:超时；-2:接收数据出现错误；-3:接收数据时出现异常</returns>  
181         /// <remarks >  
182         /// 1、当 outTime 指定为-1时，将一直等待直到有数据需要接收；  
183         /// 2、需要接收的数据的长度，由 buffer 的长度决定。  
184         /// </remarks>  
185         public int RecvData(Socket socket, byte[] buffer, int outTime)
186         {
187             if (socket == null || socket.Connected == false)
188             {
189                 throw new ArgumentException("参数socket 为null，或者未连接到远程计算机");
190             }
191             if (buffer == null || buffer.Length == 0)
192             {
193                 throw new ArgumentException("参数buffer 为null ,或者长度为 0");
194             }
195             buffer.Initialize();
196             int left = buffer.Length;
197             int curRcv = 0;
198             int flag = 0;
199 
200             try
201             {
202                 while (true)
203                 {
204                     if (socket.Poll(outTime * 1000000, SelectMode.SelectRead) == true)
205                     {        // 已经有数据等待接收  
206                         curRcv = socket.Receive(buffer, curRcv, left, SocketFlags.None);
207                         left -= curRcv;
208                         if (left == 0)
209                         {                                    // 数据已经全部接收   
210                             flag = 0;
211                             break;
212                         }
213                         else
214                         {
215                             if (curRcv > 0)
216                             {                                // 数据已经部分接收  
217                                 continue;
218                             }
219                             else
220                             {                                            // 出现错误  
221                                 flag = -2;
222                                 break;
223                             }
224                         }
225                     }
226                     else
227                     {                                                    // 超时退出  
228                         flag = -1;
229                         break;
230                     }
231                 }
232             }
233             catch (SocketException e)
234             {
235                 //Log.WriteLog ( e );  
236                 flag = -3;
237             }
238             return flag;
239         }
240 
241         /**/
242         /// <summary>  
243         /// 接收远程主机发送的数据  
244         /// </summary>  
245         /// <param name="socket">要接收数据且已经连接到远程主机的 socket</param>  
246         /// <param name="buffer">存储接收到的数据的字符串</param>  
247         /// <param name="bufferLen">待接收的数据的长度</param>  
248         /// <param name="outTime">接收数据的超时时间，以秒为单位，可以精确到微秒</param>  
249         /// <returns>0:接收数据成功；-1:超时；-2:接收数据出现错误；-3:接收数据时出现异常</returns>  
250         /// <remarks >  
251         /// 当 outTime 指定为-1时，将一直等待直到有数据需要接收；  
252         /// </remarks>  
253         public int RecvData(Socket socket, string buffer, int bufferLen, int outTime)
254         {
255             if (bufferLen <= 0)
256             {
257                 throw new ArgumentException("存储待接收数据的缓冲区长度必须大于0");
258             }
259             byte[] tmp = new byte[bufferLen];
260             int flag = 0;
261             if ((flag = RecvData(socket, tmp, outTime)) == 0)
262             {
263                 buffer = System.Text.Encoding.Default.GetString(tmp);
264             }
265             return flag;
266         }
267 
268 
269         /**/
270         /// <summary>  
271         /// 向远程主机发送文件  
272         /// </summary>  
273         /// <param name="socket" >要发送数据且已经连接到远程主机的 socket</param>  
274         /// <param name="fileName">待发送的文件名称</param>  
275         /// <param name="maxBufferLength">文件发送时的缓冲区大小</param>  
276         /// <param name="outTime">发送缓冲区中的数据的超时时间</param>  
277         /// <returns>0:发送文件成功；-1:超时；-2:发送文件出现错误；-3:发送文件出现异常；-4:读取待发送文件发生错误</returns>  
278         /// <remarks >  
279         /// 当 outTime 指定为-1时，将一直等待直到有数据需要发送  
280         /// </remarks>  
281         public int SendFile(Socket socket, string fileName, int maxBufferLength, int outTime)
282         {
283             if (fileName == null || maxBufferLength <= 0)
284             {
285                 throw new ArgumentException("待发送的文件名称为空或发送缓冲区的大小设置不正确.");
286             }
287 
288             int flag = 0;
289             try
290             {
291                 FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read);
292                 long fileLen = fs.Length;                        // 文件长度  
293                 long leftLen = fileLen;                            // 未读取部分  
294                 int readLen = 0;                                // 已读取部分  
295                 byte[] buffer = null;
296 
297                 if (fileLen <= maxBufferLength)
298                 {            /**//* 文件可以一次读取*/
299                     buffer = new byte[fileLen];
300                     readLen = fs.Read(buffer, 0, (int)fileLen);
301                     flag = SendData(socket, buffer, outTime);
302                 }
303                 else
304                 {                                    /**//* 循环读取文件,并发送 */
305                     buffer = new byte[maxBufferLength];
306                     while (leftLen != 0)
307                     {
308                         readLen = fs.Read(buffer, 0, maxBufferLength);
309                         if ((flag = SendData(socket, buffer, outTime)) < 0)
310                         {
311                             break;
312                         }
313                         leftLen -= readLen;
314                     }
315                 }
316                 fs.Close();
317             }
318             catch (IOException e)
319             {
320                 //Log.WriteLog ( e );  
321                 flag = -4;
322             }
323             return flag;
324         }
325 
326         /**/
327         /// <summary>  
328         /// 向远程主机发送文件  
329         /// </summary>  
330         /// <param name="socket" >要发送数据且已经连接到远程主机的 socket</param>  
331         /// <param name="fileName">待发送的文件名称</param>  
332         /// <returns>0:发送文件成功；-1:超时；-2:发送文件出现错误；-3:发送文件出现异常；-4:读取待发送文件发生错误</returns>  
333         public int SendFile(Socket socket, string fileName)
334         {
335             return SendFile(socket, fileName, 2048, 1);
336         }
337 
338 
339         /**/
340         /// <summary>  
341         /// 接收远程主机发送的文件  
342         /// </summary>  
343         /// <param name="socket">待接收数据且已经连接到远程主机的 socket</param>  
344         /// <param name="fileName">保存接收到的数据的文件名</param>  
345         /// <param name="fileLength" >待接收的文件的长度</param>  
346         /// <param name="maxBufferLength">接收文件时最大的缓冲区大小</param>  
347         /// <param name="outTime">接受缓冲区数据的超时时间</param>  
348         /// <returns>0:接收文件成功；-1:超时；-2:接收文件出现错误；-3:接收文件出现异常；-4:写入接收文件发生错误</returns>  
349         /// <remarks >  
350         /// 当 outTime 指定为-1时，将一直等待直到有数据需要接收  
351         /// </remarks>  
352         public int RecvFile(Socket socket, string fileName, long fileLength, int maxBufferLength, int outTime)
353         {
354             if (fileName == null || maxBufferLength <= 0)
355             {
356                 throw new ArgumentException("保存接收数据的文件名称为空或发送缓冲区的大小设置不正确.");
357             }
358 
359             int flag = 0;
360             try
361             {
362                 FileStream fs = new FileStream(fileName, FileMode.Create);
363                 byte[] buffer = null;
364 
365                 if (fileLength <= maxBufferLength)
366                 {                /**//* 一次读取所传送的文件 */
367                     buffer = new byte[fileLength];
368                     if ((flag = RecvData(socket, buffer, outTime)) == 0)
369                     {
370                         fs.Write(buffer, 0, (int)fileLength);
371                     }
372                 }
373                 else
374                 {                                        /**//* 循环读取网络数据，并写入文件 */
375                     int rcvLen = maxBufferLength;
376                     long leftLen = fileLength;                        //剩下未写入的数据  
377                     buffer = new byte[rcvLen];
378 
379                     while (leftLen != 0)
380                     {
381                         if ((flag = RecvData(socket, buffer, outTime)) < 0)
382                         {
383                             break;
384                         }
385                         fs.Write(buffer, 0, rcvLen);
386                         leftLen -= rcvLen;
387                         rcvLen = (maxBufferLength < leftLen) ? maxBufferLength : ((int)leftLen);
388                     }
389                 }
390                 fs.Close();
391             }
392             catch (IOException e)
393             {
394                 //Log.WriteLog ( e );  
395                 flag = -4;
396             }
397             return flag;
398         }
399 
400         /**/
401         /// <summary>  
402         /// 接收远程主机发送的文件  
403         /// </summary>  
404         /// <param name="socket">待接收数据且已经连接到远程主机的 socket</param>  
405         /// <param name="fileName">保存接收到的数据的文件名</param>  
406         /// <param name="fileLength" >待接收的文件的长度</param>  
407         /// <returns>0:接收文件成功；-1:超时；-2:接收文件出现错误；-3:接收文件出现异常；-4:写入接收文件发生错误</returns>  
408         public int RecvFile(Socket socket, string fileName, long fileLength)
409         {
410             return RecvFile(socket, fileName, fileLength, 2048, 1);
411         }
412 
413         //public static int SendAndReceive(Socket socket, string strCmd, out string strBuffer, TimeSpan timeout)
414         //{
415         //    try
416         //    {
417         //        return 0;
418         //    }
419         //    catch (Exception ex)
420         //    {
421         //        return -1;
422         //    }
423         //}
424 
425         public bool SendCmd(Socket socket, string strCmd, out string strErrorInfo)
426         {
427             strErrorInfo = string.Empty;
428             byte[] byteCmd;
429             //int flag = 0;
430             int left = 0;
431             int sndLen = 0;
432             int outTime = 60;
433 
434             try
435             {
436                 if (null == socket || !socket.Connected)
437                 {
438                     strErrorInfo = "socket is null or unconnected.";
439                     return false;
440                 }
441 
442                 if (string.IsNullOrEmpty(strCmd))
443                 {
444                     strErrorInfo = "Cmd is null or empty.";
445                     return false;
446                 }
447 
448                 byteCmd = Encoding.UTF8.GetBytes(strCmd);
449                 left = byteCmd.Length;
450                 while (true)
451                 {
452                     if ((socket.Poll(outTime * 1000000, SelectMode.SelectWrite) == true))
453                     {        // 收集了足够多的传出数据后开始发送  
454                         sndLen = socket.Send(byteCmd, sndLen, left, SocketFlags.None);
455                         left -= sndLen;
456                         if (left == 0)
457                         {                                        // 数据已经全部发送  
458                             //flag = 0;
459                             break;
460                         }
461                         else
462                         {
463                             if (sndLen > 0)
464                             {                                    // 数据部分已经被发送  
465                                 continue;
466                             }
467                             else
468                             {                                                // 发送数据发生错误  
469                                 //flag = -2;
470                                 //break;
471                                 strErrorInfo = "Send cmd error.";
472                                 return false;
473                             }
474                         }
475                     }
476                     else
477                     {                                                        // 超时退出  
478                         //flag = -1;
479                         //break;
480                         strErrorInfo = "Send cmd timeout.";
481                         return false;
482                     }
483                 }
484 
485                 Global.frmAUACOSS.Invoke(Global.frmAUACOSS.updateRTxt, Global.frmAUACOSS.rtxtDEBUG, PrintLevel.Zero, "发送报文：\n" + strCmd + "\n\n", Color.Black, true);
486 
487                 return true;
488 
489             }
490             catch (Exception ex)
491             {
492                 strErrorInfo = "Send cmd occurs Ex: " + ex.ToString();
493                 return false;
494             }
495         }
496 
497         public bool WaitReply(Socket socket, string strWaitString, out string strBuffer, TimeSpan timeout, out string strErrorInfo)
498         {
499             strBuffer = string.Empty;
500             string strBufferTemp = string.Empty;
501             strErrorInfo = string.Empty;
502             int bufferLen = 10240;
503             byte[] tmp = new byte[bufferLen];
504             int left = 0;
505             int curRcv = 0;
506             //int flag = 0;
507 
508             bool IsContainWaitString = false;
509 
510             try
511             {
512                 if (null == socket || !socket.Connected)
513                 {
514                     strErrorInfo = "socket is null or unconnected.";
515                     return false;
516                 }
517 
518                 tmp.Initialize();
519                 left = tmp.Length;
520                 strBuffer = strBufferLeft;
521 
522                 while (true)
523                 {
524                     if (socket.Poll((int)timeout.TotalSeconds * 1000000, SelectMode.SelectRead) == true)
525                     {        // 已经有数据等待接收  
526                         //    curRcv = socket.Receive(tmp, curRcv, left, SocketFlags.None);
527                         //    left -= curRcv;
528                         //    if (left == 0)
529                         //    {                                    // 数据已经全部接收   
530                         //        //flag = 0;
531                         //        break;
532                         //    }
533                         //    else
534                         //    {
535                         //        if (curRcv > 0)
536                         //        {                                // 数据已经部分接收  
537                         //            continue;
538                         //        }
539                         //        else
540                         //        {                                            // 出现错误  
541                         //            //flag = -2;
542                         //            strErrorInfo = "Receive buffer error.";
543                         //            break;
544                         //        }
545                         //    }
546 
547                         curRcv = socket.Receive(tmp, curRcv, left, SocketFlags.None);
548 
549                         strBufferTemp = Encoding.UTF8.GetString(tmp);
550 
551                         strBuffer = strBuffer.Trim('\0');
552 
553                         strBuffer += strBufferTemp;
554 
555                         foreach (string strWaitStringTemp in strWaitString.Split('|'))
556                         {
557                             if (strBuffer.Contains(strWaitStringTemp))
558                             {
559                                 IsContainWaitString = true;
560                                 break;
561                             }
562                         }
563                         if (IsContainWaitString)
564                         {
565                             strBufferLeft = strBuffer.Substring(strBuffer.IndexOf(strWaitString) + strWaitString.Length);
566                             strBuffer = strBuffer.Substring(0, strBuffer.IndexOf(strWaitString) + strWaitString.Length);
567                             break;
568                         }
569                     }
570                     else
571                     {                                                    // 超时退出  
572                         //flag = -1;
573                         strErrorInfo = "Receive buffer timeout.";
574                         return false;
575                     }
576                 }
577 
578                 Global.frmAUACOSS.Invoke(Global.frmAUACOSS.updateRTxt, Global.frmAUACOSS.rtxtDEBUG, PrintLevel.Zero, "接收报文：\n" + strBuffer + "\n\n", Color.Black, true);
579 
580                 return true;
581             }
582             catch (Exception ex)
583             {
584                 strErrorInfo = "Wait reply occurs Ex: " + ex.ToString();
585                 return false;
586             }
587         }
588     }

View Code