C# Socket BeginConnect // CallBackMethod

Question

C# Socket BeginConnect // CallBackMethod

Markus Freitag 3,791

My analysis is that the callback is called immediately whether there is a connection or not.

This is the reason why the behavior I expect does not occur.

So I had a misunderstanding of the function.

var result = socket.BeginConnect(remoteEndPoint, CallBackMethod, socket);

I want to press Connect and then give the client 60 seconds to connect. That is the goal.

Does anyone have an idea how to do this correctly? By BeginConnect I thought that this is asynchronous. When do I need EndConnect? Do I need a timer, then yes asynchronous is not needed.

public void Connect(IPEndPoint remoteEndPoint, int timeoutMSec)
{
	//socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
	//socket.Blocking = true;

	//var result = socket.BeginConnect(remoteEndPoint, null, null);

	//bool success = result.AsyncWaitHandle.WaitOne(125000, true);
	//if (success)
	//{
	//    socket.EndConnect(result);
	//    //_connectionStatus = ConnectionStatus.Connected;
	//    //_connectionStatusMessage = "Connected.";
	//}
	//else
	//{
	//    socket.Close();
	//    //_connectionStatus = ConnectionStatus.Error;
	//    //_connectionStatusMessage = "Connection timed out.";
	//}
	TimeoutObject.Reset();
	socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
	var result = socket.BeginConnect(remoteEndPoint, CallBackMethod, socket);

	WaitHandle wait = result.AsyncWaitHandle;

	//block the current thread        
	//if (TimeoutObject.WaitOne(timeoutMSec, false))
	if (wait.WaitOne(timeoutMSec))
	//if (!TimeoutObject.WaitOne(timeoutMSec, false))
	{
		Log("Port is ok");
		Thread th = new Thread(receive);
		th.IsBackground = true;
		th.Start();
	}
	else
	{
		Log("timeout");
	}
}
//--asynchronous callback method   
private void CallBackMethod(IAsyncResult asyncresult)
{
	//Make a blocked thread continue      
	//TimeoutObject.Set();


	TimeoutObject.Set();
	Socket s = (Socket)asyncresult.AsyncState;
	if (s.Connected)
	{
		// Success...should EndConnect only be called here?
		s.EndConnect(asyncresult);
	}
	else
	{
		// Or should EndConnect also be called here (in a try/catch block)?
		s.Close();
	}
}

Accepted answer

1 additional answer

Your answer

Answer 1

Michael Taylor 60,161

BeginConnect is an async call. When you call that method it returns immediately so the caller isn't blocked. Behind the scenes a connection is made to the remote server. As soon as the handshaking is done then your callback is called to let you know you now have a connection to the remote endpoint. In many cases this should be really fast but if the server is slow to respond or the network is swamped then it could take a little longer. The purpose of this method is to allow your code to move on and do other things while waiting (such as displaying a connecting message to the user).

When the callback gets called you need to call EndConnect. Every Begin... method has a corresponding End... method. The Begin call has to allocate resources for the async callback. The End call tells the runtime that those resources can be cleaned up. If you don't call this method then you end up leaking the resources that were allocated. You just need to call it at some point during your callback. Most people tend to call this early in the callback in case the callback fails.

Note that you should really never be using the Begin/End methods. These are provided for backwards compatibility and to provide a thin wrapper over the underlying winsock library that supports async. This is how async used to work. For current code you should be using the ConnectAsync method instead. Task-based async is the preferred approach in all cases now. It requires less code and it just works. The equivalent code would look something like this.

async void ConnectAsync (...)
{
   await socket.ConnectAsync(...);

   //Connected so do real work now
}

It looks like you want to give up if you cannot connect within 30 seconds. You can do that by passing a CancellationToken that auto-cancels after 30 seconds.

async void ConnectAsync (...)
{
   var cancel = new CancellationTokenSource(TimeSpan.FromSeconds(30));
   try
   {
      await socket.ConnectAsync(..., cancel.Token);

      //Connected, do real work
   } catch (OperationCanceledException)   
   {
      //Connection was cancelled
   };
}

Markus Freitag 3,791 Reputation points

2023-02-12T07:39:52.08+00:00
Hello,

async void ConnectAsync (...

I have a class, the functions are there without async. Now I should call an async method. How do I do that in practice?

How would you solve the problem? Give the client 30 seconds to connect, otherwise error message.

var cancel = new CancellationTokenSource(TimeSpan.FromSeconds(30));

Would it solve that?

I have a WinForms application, Button Event. Can you show how I have to invoke this? THANKS.
Michael Taylor 60,161 Reputation points

2023-02-12T23:06:50.42+00:00
The code I posted auto-cancels the request after 30 seconds. That is what the cancel source is for.

You should put the async ConnectAsync method in your class. A class can have a mix of sync and async methods. It is up to the caller to decide which one's to call. The rule is async all the way so at some point all the code from your root call to ConnectAsync needs to be async. But you can migrate methods one by one by having a sync call use an async. However this can cause issues including deadlocks so you need to treat this as a temporary solution. Async is the way to go, move away from sync code.

//In the same class as ConnectAsync expose a temporary sync version - this is for compatibility ONLY public void Connect (...) { //If the async method throws it'll bubble up here //so wrap in a try-catch if you need to prevent async exceptions //for some reason ConnectAsync(...).GetAwaiter().GetResult(); }
Markus Freitag 3,791 Reputation points

2023-02-13T16:50:45.12+00:00

Async is the way to go, move away from sync code.

You are right, of course. I also see it that way. I need a sample example there.

My problem is that at some time, I have a synchronous function that then calls an asynchronous function.

Like a button inside a WinForm application.

Picture WinForms

I haven't cancellation.

Is there a way to install this after for VS2017?

Are these options only available in the newer version?

How could I solve this with my function?

Are there any possibilities?

The button is synchronous, how do I then call the async?

Michael Taylor 60,161

VS 2017 uses C# 7.2 so it is supported. Winforms has supported async for a while and doesn't need to be sync.

//Winforms supports async event handlers...
private async void Connect8_Click ( object sender, EventArgs e )
{
   try
   {  
      //All this is running on the UI thread
      ...

      //Call the async method on a worker thread
      //await causes the current method to stop until the async work is complete
      //But the UI thread will resume so the user doesn't get a blocked UI
      await ConnectAsync(...);

      //The async method is complete and this code is now running on the UI thread again
      ...
   } catch (Exception e)
   { 
     ...
   };
}

Markus Freitag 3,791

ok, then I can use async in WinForms.
How could I solve the connection under VS2017.

I have no cancellation in the socket class. CancellationTokenSource

async void ConnectAsync (...)
{
   var cancel = new CancellationTokenSource(TimeSpan.FromSeconds(30));
   try
   {
      await socket.ConnectAsync(..., cancel.Token);

      //Connected, do real work
   } catch (OperationCanceledException)   
   {
      //Connection was cancelled
   };
}

Michael Taylor 60,161 Reputation points

2023-02-13T18:27:39.04+00:00

The code I posted works in VS2017 and you should be able to drop it into your exist code and try it out, after you update to connect using your app-specific connection logic.
Markus Freitag 3,791 Reputation points

2023-02-13T19:27:24.59+00:00
https://learn.microsoft.com/de-de/dotnet/api/system.net.sockets.tcpclient.connectasync?view=netcore-3.1
The problem is cancel token not available in my version.

await socket.ConnectAsync(..., cancel.Token);
Michael Taylor 60,161 Reputation points

2023-02-13T19:47:22.3866667+00:00

I understand now. .NET 4.7.2 doesn't have the necessary cancellation token overloads that you need. Unfortunately there is no way to force this in. Without actual cancellation support the Socket or TcpClient types will attempt to connect until they fail or succeed. However you can still emulate the behavior a little bit. Refer to this StackOverflow post where someone created their own extension method on ConnectAsync that allows for cancellation. While it is coded for TcpClient it would behave the same with Socket. The gist of the code is to register a method to be called if the token is cancelled. When cancelled the method closes the connection/socket which will trigger an exception (at some point) in the calling code. The method handles that exception and rethrows the cancellation request. This effectively terminates the connection. Until you can upgrade to a newer framework this is your best option.

Markus Freitag 3,791

Until you can upgrade to a newer framework this is your best option.

Sure, the best option.

It seems to be very difficult.

It also does not work.

This is my code.

Do you have another tip for me?

Unfortunately, I can't get this solved on my own. It would be very nice if you could give a good tip again. Thanks in advance.

WinForms - Button as async works.

private async void btnAsynConnect_Click(object sender, EventArgs e)
{
	using (var tcpClient = new TcpClient())
	{
		await RunTask(tcpClient.ConnectAsync("127.0.0.1", 6001), 15000, cancellationToken: CancellationToken.None);
	}
}


public async Task<T> RunTask<T>(Task<T> task, int timeout = 0, CancellationToken cancellationToken = default(CancellationToken))
{
	await RunTask((Task)task, timeout, cancellationToken);
	return await task;
}

public async Task RunTask(Task task, int timeout = 0, CancellationToken cancellationToken = default(CancellationToken))
{
	if (timeout == 0) timeout = -1;

	var timeoutTask = Task.Delay(timeout, cancellationToken);
	await Task.WhenAny(task, timeoutTask);

	cancellationToken.ThrowIfCancellationRequested();
	if (timeoutTask.IsCompleted)
		throw new TimeoutException();

	await task;
}

Picture 1 and 2

enter image description here

Michael Taylor 60,161 Reputation points

2023-02-14T19:45:26.2033333+00:00

You copied the wrong code from the SO post. The poster said that is what they had and it wasn't working. That isn't the code for you. Scroll down to the actual answer to their post and someone provided the code you need. It is an extension method off of TcpClient. Get rid of that RunTask stuff you added as that does nothing.
Markus Freitag 3,791 Reputation points

2023-02-15T04:25:12.5566667+00:00

OK, I should replace await task with call Wait() .Where? Can you show me please?Thanks .
Markus Freitag 3,791 Reputation points

2023-02-15T09:51:12.5433333+00:00

Can you post the code, how you mean it, how you understood it.

Then we can close the thread. Thanks.

Michael Taylor 60,161

//From StackOverflow post
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();
                }
            }
        }
    }

//My post with the method that times out after 30 seconds
async void ConnectAsync (...)
{
   var cancel = new CancellationTokenSource(TimeSpan.FromSeconds(30));
   try
   {
      await socket.ConnectAsync(..., cancel.Token);

      //Connected, do real work
   } catch (OperationCanceledException)   
   {
      //Connection was cancelled
   };
}

//The button handler you posted with the call to ConnectAsync
private async void Connect8_Click ( object sender, EventArgs e )
{
   try
   {  
      //All this is running on the UI thread
      ...

      //Call the async method on a worker thread
      //await causes the current method to stop until the async work is complete
      //But the UI thread will resume so the user doesn't get a blocked UI
      await ConnectAsync(...);

      //The async method is complete and this code is now running on the UI thread again
      ...
   } catch (Exception e)
   { 
     ...
   };
}

Markus Freitag 3,791

Hello

First, thanks for your support.

Unfortunately, it does not work. The idea is good.

Can you please check it. Maybe a small thing.

I coming in no exception.

If it doesn't work at all I have to discard it. Would be a pity, because a lot of time invested.

I give the function time to connect.

The loop is then done in the background, right?

Compiler said wrong, void does not work.

//private async Task btnAsynConnect_Click(object sender, EventArgs e)

private async void btnAsynConnect_Click(object sender, EventArgs e)

Now works with button and void, however.

Can you test the code snippet. Would be very nice and thanks in advance. Also as a file, then it goes fast.

I get these messages cyclically.

https://learn.microsoft.com/en-us/dotnet/api/system.ObjectDisposedException?view=netframework-4.7.2

Exception: "System.ObjectDisposedException" in System.dll Exception: "System.ObjectDisposedException" in System.dll Exception: "System.ObjectDisposedException" in System.dll Exception: "System.ObjectDisposedException" in System.dll Exception: "System.ObjectDisposedException" in System.dll Exception: "System.ObjectDisposedException" in System.dll Exception: "System.ObjectDisposedException" in System.dll Exception: "System.ObjectDisposedException" in System.dll Exception: "System.ObjectDisposedException"

// ** Own file and own class in a own folder

namespace IpClient.Core
{
    public static class MyExtensions
    {
        public static async Task MyConnectAsync(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();
                }
                catch (ObjectDisposedException eDisposedException)
                {
                    Trace.WriteLine("Caught: {0}", eDisposedException.Message);
                }
            }
        }
    }
}

// ** WinForms
TcpClient TcpClient;

//From StackOverflow post


//My post with the method that times out after 30 seconds
public async Task ConnectAsyncMy(string host, int port)
{
	var cancel = new CancellationTokenSource(TimeSpan.FromSeconds(65));
	try
	{
		TcpClient = new TcpClient();

		await TcpClient.MyConnectAsync(host, port, cancel.Token);

		//Connected, do real work
	}
	catch (OperationCanceledException eC)
	{
		//Connection was cancelled
		Trace.WriteLine($"{eC.Message}");
	};
}

//private async Task btnAsynConnect_Click(object sender, EventArgs e)
private async void btnAsynConnect_Click(object sender, EventArgs e)
{
	try
	{
		int z = 0;
		//All this is running on the UI thread
		//...

		Trace.WriteLine($"AAA");

		//Call the async method on a worker thread
		//await causes the current method to stop until the async work is complete
		//But the UI thread will resume so the user doesn't get a blocked UI
		await ConnectAsyncMy("127.0.0.1", 7775);

		//The async method is complete and this code is now running on the UI thread again
		//...
		Trace.WriteLine($"BBBB");
	}
	catch (ObjectDisposedException eDisposedException)
	{
		Trace.WriteLine("Caught: {0}", eDisposedException.Message);
	}
	catch (Exception ee2)
	{
		Trace.WriteLine($"{ee2.Message}");
	};
}

That would still be super great. Very gladly also a new thread. What about send and receive if there is no response after send (Timeout 6 seconds). How could I solve this? Is this similar to solve?

Extensions_CS.txt

WinForms_CS.txt

Michael Taylor 60,161 Reputation points

2023-02-17T03:50:40.9866667+00:00

It's supposed to throw an exception if it has to cancel. That is the only way to get out of a sync call that cannot be cancelled. So don't Trace.WriteLine the exceptions as they are expected. Your app shouldn't be crashing because of it. But I'll have to test it later.

As for how to handle send timeouts that is already built into the client. Set the SendTimeout property to the # of milliseconds to wait for a send to complete. If it times out then it throws a SockectException so you'll need to wrap your send requests in a try-catch. Receive requests have a corresponding receive timeout if you need it as well. They don't need cancellation token support in this case.
Markus Freitag 3,791 Reputation points

2023-02-17T16:56:35.2666667+00:00
But I'll have to test it later.

Then I thank you in advance for your help.

Timeout

<ROOT> <Request track="1" productGroup = "wash machine"/> </ROOT>

<ROOT> <Response track="1" product="Bosch Typ CXY"/> </ROOT>

I mean, when I send a request, the receiving station should respond in a time interval.

Michael Taylor 60,161

The code is behaving correctly. If the timeout occurs then the underlying code throws a NullReferenceException. The wrapper extension method handles that exception and converts it to a cancellation on the token. The UI code will need to handle that exception in order to know the connect was cancelled. Here's a minimally reproducible example of this working. The test form has a _host textbox for the host address and _port textbox for the port number. The TcpClient cannot be wrapped in a using and must have a lifetime outside the event handler otherwise you won't be able to use it.

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }

    //The button handler you posted with the call to ConnectAsync
    private async void Connect8_Click ( object sender, EventArgs e )
    {
        try
        {
            //All this is running on the UI thread                
            if (_host.Text.Length == 0 || !Int32.TryParse(_port.Text, out var port))
            {
                MessageBox.Show("Missing data", "Error");
                return;
            };

            //Call the async method on a worker thread
            var cancelAfter = new CancellationTokenSource();
            cancelAfter.CancelAfter(500);
            await _client.ConnectAsync(_host.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) {
            MessageBox.Show("Timeout", "Connect Failed");
        } catch (Exception ex)
        {
            MessageBox.Show(ex.Message, "Connect Failed");
        };
    }

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

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();
            }
        }
    }
}

If you are running this code in the debugger then the debugger might break on the ConnectAsync throw, that is by design. Continue running anyway and the cancellation will be reported properly. The only way to disable this behavior is to configure the debugger to ignore the exception unless it is unhandled but the debugger is flaky in newer VS versions.

Michael Taylor 60,161 Reputation points

2023-02-17T17:15:03.5566667+00:00

Send and receive timeouts are handled by the corresponding properties on the client. They will time out the request if it takes too long to send or receive. There is no additional cancellation support in .NET 4.8 for them and the hack I showed for Connect isn't going to work. You really need to update your .NET version if you need this functionality. You are limited by what the framework provides otherwise.
Markus Freitag 3,791 Reputation points

2023-02-19T15:01:13.5966667+00:00

OK, Do you have a whole project in the current .NET framework?
I think we close this thread now. Thanks for your help.
Is really difficult, but I think, I don't really want anything out of the norm. Many people should need these requirements, why there are no complete examples, I do not understand.
Deleted

This comment has been deleted due to a violation of our Code of Conduct. The comment was manually reported or identified through automated detection before action was taken. Please refer to our Code of Conduct for more information.

Answer 2

Deleted

This answer has been deleted due to a violation of our Code of Conduct. The answer was manually reported or identified through automated detection before action was taken. Please refer to our Code of Conduct for more information.

Comments have been turned off. Learn more

Share via

C# Socket BeginConnect // CallBackMethod

1 additional answer

Your answer