碼上快樂

相關內容    簡體    繁體

C# + Socket斷線重連

本文轉載自   查看原文   2014-03-15 12:09   6097    Scoket

一、網上常用方法
1、當Socket.Conneted == false時，調用如下函數進行判斷

點擊(此處)折疊或打開

  1. /// <summary>
  2. /// 當socket.connected為false時，進一步確定下當前連接狀態
  3. /// </summary>
  4. /// <returns></returns>
  5. private bool IsSocketConnected()
  6. {
  7.     #region remarks
  8.     /********************************************************************************************
  9.      * 當Socket.Conneted為false時， 如果您需要確定連接的當前狀態，請進行非阻塞、零字節的 Send 調用。
  10.      * 如果該調用成功返回或引發 WAEWOULDBLOCK 錯誤代碼 (10035)，則該套接字仍然處於連接狀態；
  11.      * 否則，該套接字不再處於連接狀態。
  12.      * Depending on http://msdn.microsoft.com/zh-cn/library/system.net.sockets.socket.connected.aspx?cs-save-lang=1&cs-lang=csharp#code-snippet-2
  13.     ********************************************************************************************/
  14.     #endregion

  16.     #region 過程
  17.             // This is how you can determine whether a socket is still connected.
  18.             bool connectState = true;
  19.             bool blockingState = socket.Blocking;
  20.             try
  21.             {
  22.                 byte[] tmp = new byte[1];

  24.                 socket.Blocking = false;
  25.                 socket.Send(tmp, 0, 0);
  26.                 //Console.WriteLine("Connected!");
  27.                 connectState = true; //若Send錯誤會跳去執行catch體，而不會執行其try體里其之后的代碼
  28.             }
  29.             catch (SocketException e)
  30.             {
  31.                 // 10035 == WSAEWOULDBLOCK
  32.                 if (e.NativeErrorCode.Equals(10035))
  33.                 {
  34.                     //Console.WriteLine("Still Connected, but the Send would block");
  35.                     connectState = true;
  36.                 }

  38.                 else
  39.                 {
  40.                     //Console.WriteLine("Disconnected: error code {0}!", e.NativeErrorCode);
  41.                     connectState = false;
  42.                 }
  43.             }
  44.             finally
  45.             {
  46.                 socket.Blocking = blockingState;
  47.             }

  49.             //Console.WriteLine("Connected: {0}", client.Connected);
  50.             return connectState;
  51.             #endregion
  52. }

2、根據socket.poll判斷

點擊(此處)折疊或打開

  1. /// <summary>
  2. /// 另一種判斷connected的方法，但未檢測對端網線斷開或ungraceful的情況
  3. /// </summary>
  4. /// <param name="s"></param>
  5. /// <returns></returns>
  6. static bool IsSocketConnected(Socket s)
  7. {
  8.     #region remarks
  9.             /* As zendar wrote, it is nice to use the Socket.Poll and Socket.Available, but you need to take into conside                ration
  10.              * that the socket might not have been initialized in the first place.
  11.              * This is the last (I believe) piece of information and it is supplied by the Socket.Connected property.
  12.              * The revised version of the method would looks something like this:
  13.              * from：http://stackoverflow.com/questions/2661764/how-to-check-if-a- socket-is-connected-disconnected-in-c */
  14.             #endregion

  16.     #region 過程

  18.             return !((s.Poll(1000, SelectMode.SelectRead) && (s.Available == 0)) || !s.Connected);

  20.             /* The long, but simpler-to-understand version:

  22.                     bool part1 = s.Poll(1000, SelectMode.SelectRead);
  23.                     bool part2 = (s.Available == 0);
  24.                     if ((part1 && part2 ) || !s.Connected)
  25.                         return false;
  26.                     else
  27.                         return true;

  29.             */
  30.             #endregion
  31. }

總結：--1--此兩種方法出處可在函數體中的remark中找到鏈接
         --2--此兩種方法適用於對端正常關閉socket下的本地socket狀態檢測，在非正常關閉如斷電、拔網線的情況下不起作用
               因為Socket.Conneted存在bug，詳見.Net Bugs

二、支持物理斷線重連功能的類

        利用BeginReceive + KeepAlive實現物理斷線重連，初步測驗了一下，正常。(部分代碼參考帖子#26及blog在C#中利用keep-alive處理socket網絡異常斷開)
        Keep-Alive機制的介紹請看TCP Keepalive HOWTO
        以此備忘，同時希望能幫助到有需要的同學。

點擊(此處)折疊或打開

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Net.Sockets;
  6. using System.Net;
  7. using System.Threading;

  9. namespace MySocket
  10. {
  11.     public class Socket_wrapper
  12.     {
  13.         //委托
  14.         private delegate void delSocketDataArrival(byte[] data);
  15.         static delSocketDataArrival socketDataArrival = socketDataArrivalHandler;

  17.         private delegate void delSocketDisconnected();
  18.         static delSocketDisconnected socketDisconnected = socketDisconnectedHandler;

  20.         public static Socket theSocket = null;
  21.         private static string remoteHost = "192.168.1.71";
  22.         private static int remotePort = 6666;

  24.         private static String SockErrorStr = null;
  25.         private static ManualResetEvent TimeoutObject = new ManualResetEvent(false);
  26.         private static Boolean IsconnectSuccess = false; //異步連接情況，由異步連接回調函數置位
  27.         private static object lockObj_IsConnectSuccess = new object();

  29.         /// <summary>
  30.         /// 構造函數
  31.         /// </summary>
  32.         /// <param name="strIp"></param>
  33.         /// <param name="iPort"></param>
  34.         public Socket_wrapper(string strIp, int iPort)
  35.         {
  36.             remoteHost = strIp;
  37.             remotePort = iPort;
  38.         }

  40.         /// <summary>
  41.         /// 設置心跳
  42.         /// </summary>
  43.         private static void SetXinTiao()
  44.         {
  45.             //byte[] inValue = new byte[] { 1, 0, 0, 0, 0x20, 0x4e, 0, 0, 0xd0, 0x07, 0, 0 };// 首次探測時間20 秒, 間隔偵測時間2 秒
  46.             byte[] inValue = new byte[] { 1, 0, 0, 0, 0x88, 0x13, 0, 0, 0xd0, 0x07, 0, 0 };// 首次探測時間5 秒, 間隔偵測時間2 秒
  47.             theSocket.IOControl(IOControlCode.KeepAliveValues, inValue, null);
  48.         }

  50.         /// <summary>
  51.         /// 創建套接字+異步連接函數
  52.         /// </summary>
  53.         /// <returns></returns>
  54.         private static bool socket_create_connect()
  55.         {
  56.             IPAddress ipAddress = IPAddress.Parse(remoteHost);
  57.             IPEndPoint remoteEP = new IPEndPoint(ipAddress, remotePort);
  58.             theSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
  59.             theSocket.SendTimeout = 1000;

  61.             SetXinTiao();//設置心跳參數

  63.             #region 異步連接代碼

  65.             TimeoutObject.Reset(); //復位timeout事件
  66.             try
  67.             {
  68.                 theSocket.BeginConnect(remoteEP, connectedCallback, theSocket);
  69.             }
  70.             catch (Exception err)
  71.             {
  72.                 SockErrorStr = err.ToString();
  73.                 return false;
  74.             }
  75.             if (TimeoutObject.WaitOne(10000, false))//直到timeout，或者TimeoutObject.set()
  76.             {
  77.                 if (IsconnectSuccess)
  78.                 {
  79.                     return true;
  80.                 }
  81.                 else
  82.                 {
  83.                     return false;
  84.                 }
  85.             }
  86.             else
  87.             {
  88.                 SockErrorStr = "Time Out";
  89.                 return false;
  90.             }
  91.             #endregion
  92.         }

  94.         /// <summary>
  95.         /// 同步receive函數
  96.         /// </summary>
  97.         /// <param name="readBuffer"></param>
  98.         /// <returns></returns>
  99.         public string socket_receive(byte[] readBuffer)
  100.         {
  101.             try
  102.             {
  103.                 if (theSocket == null)
  104.                 {
  105.                     socket_create_connect();
  106.                 }
  107.                 else if (!theSocket.Connected)
  108.                 {
  109.                     if (!IsSocketConnected())
  110.                         Reconnect();
  111.                 }

  113.                 int bytesRec = theSocket.Receive(readBuffer);

  115.                 if (bytesRec == 0)
  116.                 {
  117.                     //warning 0 bytes received
  118.                 }
  119.                 return Encoding.ASCII.GetString(readBuffer, 0, bytesRec);
  120.             }
  121.             catch (SocketException se)
  122.             {
  123.                 //print se.ErrorCode
  124.                 throw;
  125.             }
  126.         }

  128.         /// <summary>
  129.         /// 同步send函數
  130.         /// </summary>
  131.         /// <param name="sendMessage"></param>
  132.         /// <returns></returns>
  133.         public bool socket_send(string sendMessage)
  134.         {
  135.             if (checkSocketState())
  136.             {
  137.                 return SendData(sendMessage);
  138.             }
  139.             return false;
  140.         }

  142.         /// <summary>
  143.         /// 斷線重連函數
  144.         /// </summary>
  145.         /// <returns></returns>
  146.         private static bool Reconnect()
  147.         {
  148.             //關閉socket
  149.             theSocket.Shutdown(SocketShutdown.Both);

  151.             theSocket.Disconnect(true);
  152.             IsconnectSuccess = false;

  154.             theSocket.Close();

  156.             //創建socket
  157.             return socket_create_connect();
  158.         }

  160.         /// <summary>
  161.         /// 當socket.connected為false時，進一步確定下當前連接狀態
  162.         /// </summary>
  163.         /// <returns></returns>
  164.         private bool IsSocketConnected()
  165.         {
  166.             #region remarks
  167.             /********************************************************************************************
  168.              * 當Socket.Conneted為false時， 如果您需要確定連接的當前狀態，請進行非阻塞、零字節的 Send 調用。
  169.              * 如果該調用成功返回或引發 WAEWOULDBLOCK 錯誤代碼 (10035)，則該套接字仍然處於連接狀態；
  170.              * 否則，該套接字不再處於連接狀態。
  171.              * Depending on http://msdn.microsoft.com/zh-cn/library/system.net.sockets.socket.connected.aspx?cs-save-lang=1&cs-lang=csharp#code-snippet-2
  172.             ********************************************************************************************/
  173.             #endregion

  175.             #region 過程
  176.             // This is how you can determine whether a socket is still connected.
  177.             bool connectState = true;
  178.             bool blockingState = theSocket.Blocking;
  179.             try
  180.             {
  181.                 byte[] tmp = new byte[1];

  183.                 theSocket.Blocking = false;
  184.                 theSocket.Send(tmp, 0, 0);
  185.                 //Console.WriteLine("Connected!");
  186.                 connectState = true; //若Send錯誤會跳去執行catch體，而不會執行其try體里其之后的代碼
  187.             }
  188.             catch (SocketException e)
  189.             {
  190.                 // 10035 == WSAEWOULDBLOCK
  191.                 if (e.NativeErrorCode.Equals(10035))
  192.                 {
  193.                     //Console.WriteLine("Still Connected, but the Send would block");
  194.                     connectState = true;
  195.                 }

  197.                 else
  198.                 {
  199.                     //Console.WriteLine("Disconnected: error code {0}!", e.NativeErrorCode);
  200.                     connectState = false;
  201.                 }
  202.             }
  203.             finally
  204.             {
  205.                 theSocket.Blocking = blockingState;
  206.             }

  208.             //Console.WriteLine("Connected: {0}", client.Connected);
  209.             return connectState;
  210.             #endregion
  211.         }

  213.         /// <summary>
  214.         /// 另一種判斷connected的方法，但未檢測對端網線斷開或ungraceful的情況
  215.         /// </summary>
  216.         /// <param name="s"></param>
  217.         /// <returns></returns>
  218.         public static bool IsSocketConnected(Socket s)
  219.         {
  220.             #region remarks
  221.             /* As zendar wrote, it is nice to use the Socket.Poll and Socket.Available, but you need to take into consideration
  222.              * that the socket might not have been initialized in the first place.
  223.              * This is the last (I believe) piece of information and it is supplied by the Socket.Connected property.
  224.              * The revised version of the method would looks something like this:
  225.              * from：http://stackoverflow.com/questions/2661764/how-to-check-if-a- socket-is-connected-disconnected-in-c */
  226.             #endregion

  228.             #region 過程

  230.             if (s == null)
  231.                 return false;
  232.             return !((s.Poll(1000, SelectMode.SelectRead) && (s.Available == 0)) || !s.Connected);

  234.             /* The long, but simpler-to-understand version:

  236.                     bool part1 = s.Poll(1000, SelectMode.SelectRead);
  237.                     bool part2 = (s.Available == 0);
  238.                     if ((part1 && part2 ) || !s.Connected)
  239.                         return false;
  240.                     else
  241.                         return true;

  243.             */
  244.             #endregion
  245.         }

  247.         /// <summary>
  248.         /// 異步連接回調函數
  249.         /// </summary>
  250.         /// <param name="iar"></param>
  251.         static void connectedCallback(IAsyncResult iar)
  252.         {
  253.             #region <remarks>
  254.             /// 1、置位IsconnectSuccess
  255.             #endregion </remarks>

  257.             lock (lockObj_IsConnectSuccess)
  258.             {
  259.                 Socket client = (Socket)iar.AsyncState;
  260.                 try
  261.                 {
  262.                     client.EndConnect(iar);
  263.                     IsconnectSuccess = true;
  264.                     StartKeepAlive(); //開始KeppAlive檢測
  265.                 }
  266.                 catch (Exception e)
  267.                 {
  268.                     //Console.WriteLine(e.ToString());
  269.                     SockErrorStr = e.ToString();
  270.                     IsconnectSuccess = false;
  271.                 }
  272.                 finally
  273.                 {
  274.                     TimeoutObject.Set();
  275.                 }
  276.             }
  277.         }

  279.         /// <summary>
  280.         /// 開始KeepAlive檢測函數
  281.         /// </summary>
  282.         private static void StartKeepAlive()
  283.         {
  284.             theSocket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(OnReceiveCallback), theSocket);
  285.         }

  287.         /// <summary>
  288.         /// BeginReceive回調函數
  289.         /// </summary>
  290.         static byte[] buffer = new byte[1024];
  291.         private static void OnReceiveCallback(IAsyncResult ar)
  292.         {
  293.             try
  294.             {
  295.                 Socket peerSock = (Socket)ar.AsyncState;
  296.                 int BytesRead = peerSock.EndReceive(ar);
  297.                 if (BytesRead > 0)
  298.                 {
  299.                     byte[] tmp = new byte[BytesRead];
  300.                     Array.ConstrainedCopy(buffer, 0, tmp, 0, BytesRead);
  301.                     if (socketDataArrival != null)
  302.                     {
  303.                         socketDataArrival(tmp);
  304.                     }
  305.                 }
  306.                 else//對端gracefully關閉一個連接
  307.                 {
  308.                     if (theSocket.Connected)//上次socket的狀態
  309.                     {
  310.                         if (socketDisconnected != null)
  311.                         {
  312.                             //1-重連
  313.                             socketDisconnected();
  314.                             //2-退出，不再執行BeginReceive
  315.                             return;
  316.                         }
  317.                     }
  318.                 }
  319.                 //此處buffer似乎要清空--待實現 zq
  320.                 theSocket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(OnReceiveCallback), theSocket);
  321.             }
  322.             catch (Exception ex)
  323.             {
  324.                 if (socketDisconnected != null)
  325.                 {
  326.                     socketDisconnected(); //Keepalive檢測網線斷開引發的異常在這里捕獲
  327.                     return;
  328.                 }
  329.             }
  330.         }

  332.         /// <summary>
  333.         /// 異步收到消息處理器
  334.         /// </summary>
  335.         /// <param name="data"></param>
  336.         private static void socketDataArrivalHandler(byte[] data)
  337.         {
  338.         }

  340.         /// <summary>
  341.         /// socket由於連接中斷(軟/硬中斷)的后續工作處理器
  342.         /// </summary>
  343.         private static void socketDisconnectedHandler()
  344.         {
  345.             Reconnect();
  346.         }

  348.         /// <summary>
  349.         /// 檢測socket的狀態
  350.         /// </summary>
  351.         /// <returns></returns>
  352.         public static bool checkSocketState()
  353.         {
  354.             try
  355.             {
  356.                 if (theSocket == null)
  357.                 {
  358.                     return socket_create_connect();
  359.                 }
  360.                 else if (IsconnectSuccess)
  361.                 {
  362.                     return true;
  363.                 }
  364.                 else//已創建套接字，但未connected
  365.                 {
  366.                     #region 異步連接代碼

  368.                     TimeoutObject.Reset(); //復位timeout事件
  369.                     try
  370.                     {
  371.                         IPAddress ipAddress = IPAddress.Parse(remoteHost);
  372.                         IPEndPoint remoteEP = new IPEndPoint(ipAddress, remotePort);
  373.                         theSocket.BeginConnect(remoteEP, connectedCallback, theSocket);

  375.                         SetXinTiao();//設置心跳參數
  376.                     }
  377.                     catch (Exception err)
  378.                     {
  379.                         SockErrorStr = err.ToString();
  380.                         return false;
  381.                     }
  382.                     if (TimeoutObject.WaitOne(2000, false))//直到timeout，或者TimeoutObject.set()
  383.                     {
  384.                         if (IsconnectSuccess)
  385.                         {
  386.                             return true;
  387.                         }
  388.                         else
  389.                         {
  390.                             return false;
  391.                         }
  392.                     }
  393.                     else
  394.                     {
  395.                         SockErrorStr = "Time Out";
  396.                         return false;
  397.                     }

  399.                     #endregion
  400.                 }

  402.             }
  403.             catch (SocketException se)
  404.             {
  405.                 SockErrorStr = se.ToString();
  406.                 return false;
  407.             }
  408.         }


  411.         /// <summary>
  412.         /// 同步發送
  413.         /// </summary>
  414.         /// <param name="dataStr"></param>
  415.         /// <returns></returns>
  416.         public static bool SendData(string dataStr)
  417.         {
  418.             bool result = false;
  419.             if (dataStr == null || dataStr.Length < 0)
  420.                 return result;
  421.             try
  422.             {
  423.                 byte[] cmd = Encoding.Default.GetBytes(dataStr);
  424.                 int n = theSocket.Send(cmd);
  425.                 if (n < 1)
  426.                     result = false;
  427.             }
  428.             catch (Exception ee)
  429.             {
  430.                 SockErrorStr = ee.ToString();
  431.                 result = false;
  432.             }
  433.             return result;
  434.         }
  435.     }
  436. }


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 C#之Socket斷線和重連 C#之Socket斷線重連 C# Socket之異步TCP客戶端斷線重連 C# Mqtt 斷線重連 C# Mqtt 斷線重連 關於socket tcp 斷線重連 Socket實現斷線重連 android java socket斷線重連 c# socket 心跳 重連 grpc c++ 設置斷線重連時間
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM