wake-up-neo.com

So konfigurieren Sie das Timeout für die Socket-Verbindung

Wenn der Client versucht, eine Verbindung zu einer nicht verbundenen IP-Adresse herzustellen, liegt eine lange Zeitüberschreitung von mehr als 15 Sekunden vor. Wie kann diese Zeitüberschreitung verringert werden? Was ist die Methode, um es zu konfigurieren?

Der Code, den ich zum Einrichten einer Socket-Verbindung verwende, lautet wie folgt:

try
{
    m_clientSocket = new Socket(
         AddressFamily.InterNetwork,
         SocketType.Stream,
         ProtocolType.Tcp);

    IPAddress ip = IPAddress.Parse(serverIp);
    int iPortNo = System.Convert.ToInt16(serverPort);
    IPEndPoint ipEnd = new IPEndPoint(ip, iPortNo);

    m_clientSocket.Connect(ipEnd);
    if (m_clientSocket.Connected)
    {
        lb_connectStatus.Text = "Connection Established";
        WaitForServerData();
    }
}
catch (SocketException se)
{
    lb_connectStatus.Text = "Connection Failed";
    MessageBox.Show(se.Message);
}
96
ninikin

Ich habe das Problem mit der Socket.ConnectAsync-Methode anstelle der Socket.Connect-Methode gelöst. Starten Sie nach dem Aufrufen von Socket.ConnectAsync (SocketAsyncEventArgs) einen Timer (timer_connection). Wenn die Zeit abgelaufen ist, überprüfen Sie, ob die Socket-Verbindung hergestellt ist (if (m_clientSocket.Connected)). Andernfalls wird ein Timeout-Fehler angezeigt.

private void connect(string ipAdd,string port)
    {
        try
        {
            SocketAsyncEventArgs e=new SocketAsyncEventArgs();


            m_clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            IPAddress ip = IPAddress.Parse(serverIp);
            int iPortNo = System.Convert.ToInt16(serverPort);
            IPEndPoint ipEnd = new IPEndPoint(ip, iPortNo);

            //m_clientSocket.
            e.RemoteEndPoint = ipEnd;
            e.UserToken = m_clientSocket;
            e.Completed+=new EventHandler<SocketAsyncEventArgs>(e_Completed);                
            m_clientSocket.ConnectAsync(e);

            if (timer_connection != null)
            {
                timer_connection.Dispose();
            }
            else
            {
                timer_connection = new Timer();
            }
            timer_connection.Interval = 2000;
            timer_connection.Tick+=new EventHandler(timer_connection_Tick);
            timer_connection.Start();
        }
        catch (SocketException se)
        {
            lb_connectStatus.Text = "Connection Failed";
            MessageBox.Show(se.Message);
        }
    }
private void e_Completed(object sender,SocketAsyncEventArgs e)
    {
        lb_connectStatus.Text = "Connection Established";
        WaitForServerData();
    }
    private void timer_connection_Tick(object sender, EventArgs e)
    {
        if (!m_clientSocket.Connected)
        {
            MessageBox.Show("Connection Timeout");
            //m_clientSocket = null;

            timer_connection.Stop();
        }
    }
4
ninikin

Ich habe das gefunden. Einfacher als die akzeptierte Antwort und funktioniert mit .NET v2

Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

// Connect using a timeout (5 seconds)

IAsyncResult result = socket.BeginConnect( sIP, iPort, null, null );

bool success = result.AsyncWaitHandle.WaitOne( 5000, true );

if ( socket.Connected )
{
    socket.EndConnect( result );
}
else 
{
     // NOTE, MUST CLOSE THE SOCKET

     socket.Close();
     throw new ApplicationException("Failed to connect server.");
}

//... 
135
FlappySocks

Meine Einstellung:

public static class SocketExtensions
{
    /// <summary>
    /// Connects the specified socket.
    /// </summary>
    /// <param name="socket">The socket.</param>
    /// <param name="endpoint">The IP endpoint.</param>
    /// <param name="timeout">The timeout.</param>
    public static void Connect(this Socket socket, EndPoint endpoint, TimeSpan timeout)
    {
        var result = socket.BeginConnect(endpoint, null, null);

        bool success = result.AsyncWaitHandle.WaitOne(timeout, true);
        if (success)
        {
            socket.EndConnect(result);
        }
        else
        {
            socket.Close();
            throw new SocketException(10060); // Connection timed out.
        }
    }
}
29
bevacqua

Ich habe gerade eine Erweiterungsklasse geschrieben, um Timeouts in Verbindungen zuzulassen. Verwenden Sie es genauso wie die Standardmethoden Connect() mit einem zusätzlichen Parameter namens timeout.

using System;
using System.Net;
using System.Net.Sockets;

/// <summary>
/// Extensions to Socket class
/// </summary>
public static class SocketExtensions
{
    /// <summary>
    /// Connects the specified socket.
    /// </summary>
    /// <param name="socket">The socket.</param>
    /// <param name="Host">The Host.</param>
    /// <param name="port">The port.</param>
    /// <param name="timeout">The timeout.</param>
    public static void Connect(this Socket socket, string Host, int port, TimeSpan timeout)
    {
        AsyncConnect(socket, (s, a, o) => s.BeginConnect(Host, port, a, o), timeout);
    }

    /// <summary>
    /// Connects the specified socket.
    /// </summary>
    /// <param name="socket">The socket.</param>
    /// <param name="addresses">The addresses.</param>
    /// <param name="port">The port.</param>
    /// <param name="timeout">The timeout.</param>
    public static void Connect(this Socket socket, IPAddress[] addresses, int port, TimeSpan timeout)
    {
        AsyncConnect(socket, (s, a, o) => s.BeginConnect(addresses, port, a, o), timeout);
    }

    /// <summary>
    /// Asyncs the connect.
    /// </summary>
    /// <param name="socket">The socket.</param>
    /// <param name="connect">The connect.</param>
    /// <param name="timeout">The timeout.</param>
    private static void AsyncConnect(Socket socket, Func<Socket, AsyncCallback, object, IAsyncResult> connect, TimeSpan timeout)
    {
        var asyncResult = connect(socket, null, null);
        if (!asyncResult.AsyncWaitHandle.WaitOne(timeout))
        {
            try
            {
                socket.EndConnect(asyncResult);
            }
            catch (SocketException)
            { }
            catch (ObjectDisposedException)
            { }
        }
    }
22
picrap

Ich programmiere nicht in C #, aber in C lösen wir das gleiche Problem, indem wir den Socket nicht blockieren und dann den fd in eine Select/Poll-Schleife mit einem Timeout-Wert setzen, der der Zeit entspricht, die wir bereit sind, auf die Verbindung zu warten erfolgreich sein.

Ich habe this für Visual C++ gefunden, und die Erklärung dort geht auch in Richtung des zuvor erläuterten Auswahl-/Abfragemechanismus.

Nach meiner Erfahrung können Sie die Werte für das Verbindungszeitlimit nicht pro Socket ändern. Sie können dies für alle ändern (indem Sie die Betriebssystemparameter anpassen).

8
Aditya Sehgal

Überprüfen Sie dies auf MSDN . Es scheint nicht, dass Sie dies mit den implementierten Eigenschaften in der Socket-Klasse tun können.

Das Poster auf MSDN tatsächlich löste sein Problem mit Threading. Er hatte einen Haupt-Thread, der andere Threads anrief, die den Verbindungscode einige Sekunden lang ausführten und dann die Connected-Eigenschaft des Sockets überprüften:

Ich habe eine andere Methode erstellt, mit der der Socket tatsächlich verbunden ist ... habe den Haupt-Thread für 2 Sekunden schlafen lassen und dann die Verbindungsmethode (die in einem separaten Thread ausgeführt wird) überprüft, ob der Socket ordnungsgemäß verbunden ist. Anderenfalls wird eine Ausnahme "Zeitüberschreitung" ausgelöst. und das ist alles. Nochmals vielen Dank für die Antworten.

Was versuchst du zu tun und warum kann es nicht 15 bis 30 Sekunden warten, bevor die Zeit abgelaufen ist?

2
ecounysis

Ich hatte das gleiche Problem beim Anschließen an einen Socket und fand die folgende Lösung: Es funktioniert einwandfrei für mich. `

private bool CheckConnectivityForProxyHost(string hostName, int port)
       {
           if (string.IsNullOrEmpty(hostName))
               return false;

           bool isUp = false;
           Socket testSocket = null;

           try
           {

               testSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
               IPAddress ip = null;
               if (testSocket != null && NetworkingCollaboratorBase.GetResolvedConnecionIPAddress(hostName, out ip))//Use a method to resolve your IP
               {
                   IPEndPoint ipEndPoint = new IPEndPoint(ip, port);

                   isUp = false;
//time out 5 Sec
                  CallWithTimeout(ConnectToProxyServers, 5000, testSocket, ipEndPoint);

                       if (testSocket != null && testSocket.Connected)
                       {
                           isUp = true;
                       }
                   }

               }
           }
           catch (Exception ex)
           {
               isUp = false;
           }
           finally
           {
               try
               {
                   if (testSocket != null)
                   {
                       testSocket.Shutdown(SocketShutdown.Both);
                   }
               }
               catch (Exception ex)
               {

               }
               finally
               {
                   if (testSocket != null)
                       testSocket.Close();
               }

           }

           return isUp;
       }


 private void CallWithTimeout(Action<Socket, IPEndPoint> action, int timeoutMilliseconds, Socket socket, IPEndPoint ipendPoint)
       {
           try
           {
               Action wrappedAction = () =>
               {
                   action(socket, ipendPoint);
               };

               IAsyncResult result = wrappedAction.BeginInvoke(null, null);

               if (result.AsyncWaitHandle.WaitOne(timeoutMilliseconds))
               {
                   wrappedAction.EndInvoke(result);
               }

           }
           catch (Exception ex)
           {

           }
       }

  private void ConnectToProxyServers(Socket testSocket, IPEndPoint ipEndPoint)
       {
           try
           {
               if (testSocket == null || ipEndPoint == null)
                   return;

                   testSocket.Connect(ipEndPoint);

           }
           catch (Exception ex)
           {

           }
       } 
2
Tyronne Thomas

Dies ist wie die Antwort von FlappySock, aber ich habe einen Rückruf hinzugefügt, weil mir das Layout und die Rückgabe des Booleschen Werts nicht gefallen hat. In den Kommentaren dieser Antwort von Nick Miller:

Nach meiner Erfahrung wird AsyncWaitHandle.WaitOne signalisiert, wenn der Endpunkt erreicht werden kann, aber kein Server auf dem Endpunkt die Verbindung empfangen kann, aber der Socket bleibt nicht verbunden

Daher scheint es gefährlich zu sein, sich auf das zu verlassen, was zurückgegeben wird. Ich bevorzuge die Verwendung von socket.Connected. Ich setze einen nullfähigen Booleschen Wert und aktualisiere ihn in der Rückruffunktion. Ich habe auch festgestellt, dass es nicht immer fertig ist, das Ergebnis zu melden, bevor ich zur Hauptfunktion zurückkehre - ich kümmere mich auch darum und lasse es mit dem Timeout auf das Ergebnis warten:

private static bool? areWeConnected = null;

private static bool checkSocket(string svrAddress, int port)
{
    IPEndPoint endPoint = new IPEndPoint(IPAddress.Parse(svrAddress), port);
    Socket socket = new Socket(endPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);

    int timeout = 5000; // int.Parse(ConfigurationManager.AppSettings["socketTimeout"].ToString());
    int ctr = 0;
    IAsyncResult ar = socket.BeginConnect(endPoint, Connect_Callback, socket);
    ar.AsyncWaitHandle.WaitOne( timeout, true );

    // Sometimes it returns here as null before it's done checking the connection
    // No idea why, since .WaitOne() should block that, but it does happen
    while (areWeConnected == null && ctr < timeout)
    {
        Thread.Sleep(100);
        ctr += 100;
    } // Given 100ms between checks, it allows 50 checks 
      // for a 5 second timeout before we give up and return false, below

    if (areWeConnected == true)
    {
        return true;
    }
    else
    {
        return false;
    }
}

private static void Connect_Callback(IAsyncResult ar)
{
    areWeConnected = null;
    try
    {
        Socket socket = (Socket)ar.AsyncState;
        areWeConnected = socket.Connected;
        socket.EndConnect(ar);
    }
    catch (Exception ex)
    {
      areWeConnected = false;
      // log exception 
    }
}

Verwandte: Wie überprüfe ich, ob ich verbunden bin?

1
vapcguy

Ich habe mit Unity gearbeitet und hatte ein Problem mit BeginConnect und anderen asynchronen Methoden von Socket.

Es gibt etwas, das ich nicht verstehe, aber die vorherigen Codebeispiele funktionieren bei mir nicht.

Also habe ich diesen Code geschrieben, damit er funktioniert. Ich teste es in einem Ad-hoc-Netzwerk mit Android und PC, auch lokal auf meinem Computer. Ich hoffe, es kann helfen.

using System.Net.Sockets;
using System.Threading;
using System.Net;
using System;
using System.Diagnostics;

class ConnexionParameter : Guardian
{
    public TcpClient client;
    public string address;
    public int port;
    public Thread principale;
    public Thread thisthread = null;
    public int timeout;

    private EventWaitHandle wh = new AutoResetEvent(false);

    public ConnexionParameter(TcpClient client, string address, int port, int timeout, Thread principale)
    {
        this.client = client;
        this.address = address;
        this.port = port;
        this.principale = principale;
        this.timeout = timeout;
        thisthread = new Thread(Connect);
    }


    public void Connect()
    {
        WatchDog.Start(timeout, this);
        try
        {
            client.Connect(IPAddress.Parse(address), port);

        }
        catch (Exception)
        {
            UnityEngine.Debug.LogWarning("Unable to connect service (Training mode? Or not running?)");
        }
        OnTimeOver();
        //principale.Resume();
    }

    public bool IsConnected = true;
    public void OnTimeOver()
    {
        try
        {
            if (!client.Connected)
            {
                    /*there is the trick. The abort method from thread doesn't
 make the connection stop immediately(I think it's because it rise an exception
 that make time to stop). Instead I close the socket while it's trying to
 connect , that make the connection method return faster*/
                IsConnected = false;

                client.Close();
            }
            wh.Set();

        }
        catch(Exception)
        {
            UnityEngine.Debug.LogWarning("Connexion already closed, or forcing connexion thread to end. Ignore.");
        }
    }


    public void Start()
    {

        thisthread.Start();
        wh.WaitOne();
        //principale.Suspend();
    }

    public bool Get()
    {
        Start();
        return IsConnected;
    }
}


public static class Connexion
{


    public static bool Connect(this TcpClient client, string address, int port, int timeout)
    {
        ConnexionParameter cp = new ConnexionParameter(client, address, port, timeout, Thread.CurrentThread);
        return cp.Get();
    }

//http://stackoverflow.com/questions/19653588/timeout-at-acceptsocket
    public static Socket AcceptSocket(this TcpListener tcpListener, int timeoutms, int pollInterval = 10)
    {
        TimeSpan timeout = TimeSpan.FromMilliseconds(timeoutms);
        var stopWatch = new Stopwatch();
        stopWatch.Start();
        while (stopWatch.Elapsed < timeout)
        {
            if (tcpListener.Pending())
                return tcpListener.AcceptSocket();

            Thread.Sleep(pollInterval);
        }
        return null;
    }


}

und es gibt einen sehr einfachen Watchdog auf C #, damit es funktioniert:

using System.Threading;

public interface Guardian
{
    void OnTimeOver();
}

public class WatchDog {

    int m_iMs;
    Guardian m_guardian;

    public WatchDog(int a_iMs, Guardian a_guardian)
    {
        m_iMs = a_iMs;
        m_guardian = a_guardian;
        Thread thread = new Thread(body);
        thread.Start(this);
    }


    private void body(object o)
    {
        WatchDog watchdog = (WatchDog)o;
        Thread.Sleep(watchdog.m_iMs);
        watchdog.m_guardian.OnTimeOver();
    }

    public static void Start(int a_iMs, Guardian a_guardian)
    {
        new WatchDog(a_iMs, a_guardian);
    }
}
1
Hugo Zevetel

es könnte zu spät sein, aber es gibt eine saubere Lösung basierend auf Task.WaitAny (c # 5 +):

 public static bool ConnectWithTimeout(this Socket socket, string Host, int port, int timeout)
        {
            bool connected = false;
            Task result = socket.ConnectAsync(Host, port);               
            int index = Task.WaitAny(new[] { result }, timeout);
            connected = socket.Connected;
            if (!connected) {
              socket.Close();
            }

            return connected;
        }
1
Oleg Bondarenko