C# Socket BeginConnect give a connection n seconds to connect

Question

C# Socket BeginConnect give a connection n seconds to connect

Markus Freitag 3,791

Is there any way in .NET4.7.2 so that I can give a connection 60 seconds to connect.

Unfortunately, this solution will not work. Wait only 2 seconds instead of 60 seconds

The idea is good. Maybe someone sees the error, why this does not work.

//TcpClient needs to persist for life of form...
private TcpClient _client = new TcpClient();


private async void btnAsynConnect_Click(object sender, EventArgs e)
{
	Stopwatch s = new Stopwatch();
	try
	{
		//All this is running on the UI thread                
		if (Ipbox.Text.Length == 0 || !Int32.TryParse(PortBox.Text, out var port))
		{
			MessageBox.Show("Missing data", "Error");
			return;
		};

		//Call the async method on a worker thread
		var cancelAfter = new CancellationTokenSource();

	   
		s.Start(); // Start 

		cancelAfter.CancelAfter(60000);
		await _client.ConnectAsync(Ipbox.Text, port, cancelAfter.Token);
	   

		//The async method is complete and this code is now running on the UI thread again                
		MessageBox.Show("Success", "Connect");
	}
	catch (OperationCanceledException)
	{
		// Algorythmus
		s.Stop();
		TimeSpan timeSpan = s.Elapsed;
		MessageBox.Show(String.Format("Timeout Time: {0}h{1}m{2}s{3}ms", timeSpan.Hours, timeSpan.Minutes, timeSpan.Seconds, timeSpan.Milliseconds), "Connect Failed");
	}
	catch (Exception ex)
	{
		 // Algorythmus
		s.Stop();
		TimeSpan timeSpan = s.Elapsed;
		MessageBox.Show(ex.Message + Environment.NewLine + String.Format("Timeout Time: {0}h{1}m{2}s{3}ms", timeSpan.Hours, timeSpan.Minutes, timeSpan.Seconds, timeSpan.Milliseconds), "Connect Failed");
	};
	
	
	
public static class Extensions
{
	public static async Task ConnectAsync(this TcpClient tcpClient, string host, int port, CancellationToken cancellationToken)
	{
		if (tcpClient == null)
		{
			throw new ArgumentNullException(nameof(tcpClient));
		}

		cancellationToken.ThrowIfCancellationRequested();

		using (cancellationToken.Register(() => tcpClient.Close()))
		{
			try
			{
				cancellationToken.ThrowIfCancellationRequested();

				await tcpClient.ConnectAsync(host, port).ConfigureAwait(false);
			}
			catch (NullReferenceException) when (cancellationToken.IsCancellationRequested)
			{
				cancellationToken.ThrowIfCancellationRequested();
			}
		}
	}
}

Anonymous

2023-02-23T09:43:45.04+00:00

Hi @Markus Freitag, "Wait only 2 seconds instead of 60 seconds", what is the error thrown to you when it fails? Have you tried adding a breakpoint to see where the error occurs? I still need further research and will follow up when I progress.
Markus Freitag 3,791 Reputation points

2023-02-23T15:46:47.6433333+00:00

Thanks for your help!

Error message {"Could not connect because the target computer refused to connect"}
row 342 is the exception.

Accepted answer

0 additional answers

Your answer

Anonymous

2023-02-23T09:43:45.04+00:00

Hi @Markus Freitag, "Wait only 2 seconds instead of 60 seconds", what is the error thrown to you when it fails? Have you tried adding a breakpoint to see where the error occurs? I still need further research and will follow up when I progress.
Markus Freitag 3,791 Reputation points

2023-02-23T15:46:47.6433333+00:00

Thanks for your help!

Error message {"Could not connect because the target computer refused to connect"}
row 342 is the exception.

Answer 1

Michael Taylor 60,161

The error message indicates the server you're trying to connect to using the IP/port is rejecting the call. This doesn't have anything to do with cancellation or your code. You're trying to connect to a machine and port that isn't listening for a connection.

Confirm that the IP address/port is actively listening, meaning you have a TCP server listening for connections on that port. Given that you're using your local machine you should also confirm that it is listening on port 7775. Note that your firewall may be getting in the way so ensure that the firewall allows the connection through as well. This is generally not a problem for localhost though.

Markus Freitag 3,791 Reputation points

2023-02-24T15:12:06.37+00:00

Well, my goal is to start the client, give it 60, 90 or more seconds until it can connect to the server.

What is the solution approach?
Michael Taylor 60,161 Reputation points

2023-02-24T16:33:03.1433333+00:00

Again, the error you're getting has nothing to do with the cancellation code. You are attempting to connect to a host that isn't listening. The code you posted (from the other thread where you got the answer) is working correctly. You can confirm this by switching your code back to just calling ConnectAsync without the timeout and it'll still fail. If it doesn't then let us know.
Markus Freitag 3,791 Reputation points

2023-02-25T13:57:33.32+00:00

Good, then I don't understand the ConnectAsync function. Where is then the advantage disadvantage compared to only Connect.
My goal is to open the client, allow it time to connect to the server. How then do I need to develop this?

I make a request with XML and expect a response within 30 seconds, otherwise error message.

That's all I want. Sounds simple, seems very difficult. Do you have a real example? Thanks in advance for your help.
With TcpClient, TcpListener or only socket.
Michael Taylor 60,161 Reputation points

2023-02-25T16:31:49.5+00:00

The ConnectAsync method does what you want. Given the extension code that was already posted in the other thread then it'll wait up to 30 seconds to connect. If it succeeds within that time then you can send or data. If it fails then you get an exception and can report an error. All that is working with the code as you posted. I really don't understand why you're saying it isn't working. It does exactly what you're asking for.

Can we agree that the code, as given, is doing this correctly? Otherwise I'm afraid I don't know what else to tell you as you're asking for code to do something, we've provided it and you're saying it doesn't do what you want, but it does.

The exact issue you reported on this thread (not the other thread where you were given the working code) has absolutely nothing to do with the connect logic. You are trying to connect to a TCP server that doesn't exist. This has nothing to do with connection timeouts or anything else. You're going to an address that doesn't exist. No connection logic will work here. It is always an error. You have yet to confirm whether the endpoint you're listening on (127.0.0.1/7775) actually has code listening on the other end. You need to fix that issue by bringing up a TCP server that listens on that port.

You were provided a full sample in the other thread already so I don't know what more we can provide. The code that was posted worked against a TCP server that would listen on the other end. If you need an example of a TCP server then refer to this example. Under the Create a Socket Server section it has code you can put into a console app (separate from your main client app) and run to get a TCP server up and running. When setting up the ipEndPoint ensure it is using port 7775 so your main client will work. As an aside the Create a Socket client section in this same example shows what the connect async code would look like. The only change you'd really need to make there is to pass a timeout to the ConnectAsync call.

The timeout logic can be used on Socket or TcpClient but you'd need to adjust the types accordingly.
Markus Freitag 3,791 Reputation points

2023-03-02T18:12:17.31+00:00
Difficult. Perhaps we have a misunderstanding. I am trying to describe the goal.

Please try this.

Timeout is 120 seconds, two minutes

Open the client, no server is running.

After 70 seconds you start the server, then

I expect a connection. Anything else makes no sense.

I need a solution for .NET4.7.2

That means server and client connect automatically if they are present.

The same with question answer game. Request/response we have here also a timeout.

  <ROOT> <REQUEST_GROUP> <MODEL_2023 active="true" /> </REQUEST_GROUP> </ROOT>   <ROOT> <RESPONSE_GROUP> <MODEL_2023 active="true" current="wash machine ser.no. 20230302-BOSCH-Group"/> </RESPONSE_GROUP> </ROOT>  <ROOT> <REQUEST_GROUP> <MODEL_2023 active="true" /> </REQUEST_GROUP> </ROOT>   <ROOT> <RESPONSE_GROUP> <MODEL_2023 active="true" current="wash machine ser.no. 20230302-BOSCH-Group"/> </RESPONSE_GROUP> </ROOT>

But I think, that https://learn.microsoft.com/en-us/dotnet/api/system.net.sockets.networkstream.readtimeout?view=netframework-4.7.2

This has nothing to do with the stream timeout, isn't? I send an XML message and expect a response after n time, complete message, otherwise error or timeout.

Did you understand my requirements? Thanks for help in advance.
Michael Taylor 60,161 Reputation points

2023-03-02T19:49:29.6666667+00:00
After 70 seconds you start the server, then I expect a connection. Anything else makes no sense.

That isn't how TCP connections work, or even any connections for that matter. A connection attempt either succeeds or fails. The connection timeout is how long to wait for it to succeed. As soon as we know it won't succeed (because the server isn't there) then the call can fail.

What you're talking about is quite a bit different. You're talking about a retry policy. This is often done with HTTP clients. WIth a retry policy you specify that if the connection attempt fails, for a few pre-defined reasons (server not available, etc), then try again later. For a retry policy to work you have to specify how long to wait between requests, generally exponential, otherwise you can swamp your network with requests for a case where it'll never work.

There is no support for retry policies in the framework at all. It can be done using third party NuGet packages if you need it, at least for HTTP clients. Otherwise you're on your own. Implementing a simplistic retry policy isn't hard.

Attempt to connect to server While Failed for a recoverable reason Wait for some reasonable amount of time Try to connect again

But that is not something you'd want in production. In a production environment you'd want to probably do exponential backoff on the connection. For example, checking every second is wasteful if the server isn't going to be online so start at 1 second, then 5, etc because the longer the connection is down the more likely it is to remain down.

You'll also want to only retry if the error is recoverable. A server not found, server rejected, etc are recoverable. A bad IP address or access denied are generally fatal.
Markus Freitag 3,791 Reputation points

2023-03-03T16:13:26.3966667+00:00
ok.

The ConnectAsync method does what you want.

I agree.

But then I see to Connect, so synchronously no advantage. Where is the big advantage from ConnectAsync to only Connect. oth return immediate errors if there is no server.

Otherwise you're on your own. Implementing a simplistic retry policy isn't hard.

If you have experience with sure, if you have never created it before, difficult. I think you understood my requirements. Do you know a good example project?

Maybe with TcpClient and TcpListener. I think here the library is already better than using only socket.

I need a solution for .NET4.7.2

On the side. Google Chrome Cast or Amazon Firestick. Internet is offline. Both try to connect automatically again, again and again. How is this created? After a certain time a message appears, no network connection. I am looking there a good start, a good software architecture.
Michael Taylor 60,161 Reputation points

2023-03-03T20:16:47.25+00:00

In terms of behavior between Connect and ConnectAsync when the remote server isn't even available then they are not different. Again, this is not a connection issue that these methods would ever handle. You need a retry policy to attempt to reconnect over and over again until successful. The only benefit of ConnectAsync over Connect is if you connect but the remote server or network is running slow. In that case the caller can continue to do other work while the slow network connection catches up. With Connect you are blocked until the connection is fully established or fails.

In terms of sample code, there isn't very many because the algorithm isn't terribly difficult for the simple case, as I gave. For .NET we are generally working with HttpClient and that client has Poly so this type of implementation is rarely needed. For something more generic take a look at this blog post. I've never used it but it seems to try to provide what you want. There is also this library. You'll have to decide which one might work best for your case and your restrictions on frameworks.

Chrome/Firestick? I have no idea how they are implemented but they are using a combination of a retry policy that eventually gives up and likely a library that detects when a network request fails because of a network issue and tries to automatically reconnect. None of this is built in and pretty specific to your app. If you need that functionality then you'll have to build it yourself.
Markus Freitag 3,791 Reputation points

2023-03-04T16:54:31.42+00:00

Thanks for your answer.

You really don't know a good example for C# and a Windows desktop application? (WPF)? Yes is so difficult without sample for TcpClient and TcpListener.

https://weblogs.asp.net/dixin/transientfaulthandling-core-retry-library-for-net-core-net-standard

Looks very complicated again and I don't have an executable example. Too bad I have to keep looking. I just want a full duplex operation.

Michael Taylor 60,161

Here's a poor man's implementation of retry using TcpClient. It works the same with Socket. Of course you'd need to test this in your situation to make sure it behaves how you need it. You'd also need to expand the list of possible errors that it considers recoverable from because you don't want to blindly retry on any exception.

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

namespace ConsoleApp1
{
    public class Program
    {
        public static async Task Main ()
        {
            var endpoint = new IPEndPoint(IPAddress.Loopback, 50);

            var client = new TcpClient();

            try
            {
                await client.ConnectWithRetryAsync(endpoint, TimeSpan.FromSeconds(30));
                Console.WriteLine("Connected");
            } catch (Exception e)
            {
                Console.WriteLine(e.Message);
            };
        }
    }

    public static class TcpClientExtensions
    {
        public static async Task ConnectWithRetryAsync ( this TcpClient client, IPEndPoint endpoint, TimeSpan timeout, CancellationToken cancellationToken = default )
        {
            //Attempt to connect           
            if (await TryConnectCore(client, endpoint))
                return;

            //TODO: Implement a backoff retry policy
            var maxDelay = TimeSpan.FromSeconds(5);
            var delay = TimeSpan.FromMilliseconds(500);
            var startTime = Stopwatch.StartNew();
            do
            {
                cancellationToken.ThrowIfCancellationRequested();

                //Wait for some amount of time
                Debug.WriteLine($"Waiting {delay}...");
                await Task.Delay(delay);

                cancellationToken.ThrowIfCancellationRequested();
                if (await TryConnectCore(client, endpoint))
                    return;

                //Double the delay up to the max
                if (delay < maxDelay)
                {
                    delay = delay.Add(delay);
                    if (delay > maxDelay)
                        delay = maxDelay;
                };
            } while (startTime.Elapsed < timeout);

            //Timed out
            Debug.WriteLine("Timed out");
            throw new TimeoutException("Timeout waiting to connect.");
        }

        private static async Task<bool> TryConnectCore ( TcpClient client, IPEndPoint endpoint )
        {
            try
            {
                Debug.WriteLine("Attempting connection");
                await client.ConnectAsync(endpoint.Address, endpoint.Port);
                Debug.WriteLine("Connection successful");
                return true;
            } catch (Exception e) when (CanRetry(e))
            {
                Debug.WriteLine("Recoverable error occurred");
                return false;
            };
        }

        private static bool CanRetry ( Exception e )
        {
            if (e is SocketException socketError)
            {
                //TODO: Add possible recoverable errors here
                switch (socketError.ErrorCode)
                {
                    case 10061: return true;  //Connection refused
                };                
            };

            return false;
        }
    }
}

The debug statements slow things down but are useful for diagnostics. In this sample implementation it backs off retries up to 5 seconds. The request can succeed, time out or be cancelled.

Markus Freitag 3,791

This looks really good.

Thank you very much for your help. I am using .NET4.7.2, I don't have that.

I think we can close the thread then, the questions would still be important. I need to understand.

The code is so manageable. Great!

What would be the correct way and what is the best way to test the Cancel? When, where and how would I need to trigger the CancelToken?

I use VS2017, .NET4.5.7, C# DesktopApp.

CancellationToken.None

CancellationToken.Default don't exist for .NET4.7.2

Picture all well!

Problems_Cancellation_Token_Default


// #############################   06.03.2023
TcpClient MyAsyncClient;// = new TcpClient();
NetworkStream MyAsyncSendStream;

private async void btnAsynConnect_Click(object sender, EventArgs e)
{
	var endpoint = new IPEndPoint(IPAddress.Loopback, 7775);

	MyAsyncClient = new TcpClient();

	try
	{
		await MyAsyncClient.ConnectWithRetryAsync(endpoint, TimeSpan.FromSeconds(30), CancellationToken.None);
		Console.WriteLine("Connected");
	}
	catch (Exception e2)
	{
		Console.WriteLine(e2.Message);
	};

}

private void btnSendAsync_Click(object sender, EventArgs e)
{
	string txt = SendText.Text;
	byte[] buffer = Encoding.UTF8.GetBytes(txt);

	this.MyAsyncSendStream = this.MyAsyncClient.GetStream();

	this.MyAsyncSendStream.Write(buffer, 0, buffer.Length);         

}

Michael Taylor 60,161 Reputation points

2023-03-06T18:00:27.5266667+00:00

If you don't support cancellation in your app then don't worry about it right now. In the future however if you want the user to be able to click a cancel button to stop the connection request then you'd define a CancellationTokenSource in your UI, pass the token it has to the method and then in your cancel button handler you'd set the source to cancel. This would trigger the cancellation request. You can see one example of this here. Ignore all the discussion up to the cancel header as it isn't relevant here.
Markus Freitag 3,791 Reputation points

2023-03-07T17:55:42.33+00:00

Thank you!

Share via

C# Socket BeginConnect give a connection n seconds to connect

0 additional answers

Your answer