如何阻塞一个线程，直到另一个线程在 C# 中获得服务器响应

Question

I am working on a library where you can create a server with a name:

UtilityServer server = new UtilityServer("TestServer1", 3500);

You can also create a client with a name:

UtilityClient client = new UtilityClient("TestClient1");

The server creates a socket on the local computer with the port you choose. When the server is running, the client can connect via:

client.Connect(ServerIP, 3500);

Everything works fine when I do it event-based with for example:

client.UserNamesArrived += OnUserNamesArrived;
client.RequestUserNames();

private void OnUserNamesArrived(ReadOnlyCollection<string> userNames)
{
    // Do something with userNames
}

But when I try to create a blocking method in my library for example:

public ReadOnlyCollection<string> GetUserNames()
{
    // Request userNames from server
    // Wait until server sent us userNames
    // return userNames
}

// Running on seperate thread, gets messages that server sents to client
ReceiveMessages()
{
    while(_isConnected)
    {
    // Waits until message is received (_strReader.ReadLine())
    // Looks what message contains (Can also be other things then userNames)
    // Gets collection of userNames when message contains it (Working)
    // Triggers event 'UserNamesArrived' with userNames as argument
    }
}

I don't know how.

Now here is my question, how do I wait in my GetUserNames-Thread until my ReceiveMessages-Thread gets the collection of userNames and how can I return them?

There are similar Methods in the .Net-Framework that block the Thread, for example:

sqlCommand.ExecuteNonQuery();

This also blocks it and waits for a response, but how?

Answer 1

Consider one of the implementations of System.Threading.WaitHandle .

I often use AutoResetEvent for cross thread notifications that require blocking.

AutoResetEvent allows threads to communicate with each other by signaling. Typically, you use this class when threads need exclusive access to a resource.

https://msdn.microsoft.com/en-us/library/system.threading.autoresetevent%28v=vs.110%29.aspx

You will often hear this construct called a semaphore due to the signalling nature. WaitHandles are an OS feature so be make sure you dispose of the handle correctly.

The significant feature of WaitHandle is the WaitOne method.

WaitOneBlocks the current thread until the current WaitHandle receives a signal.

Answer 2

You can use the async and await properties of .NET framework. You'll need to set the ReceiveMessages() method as an async task and make the main thread which runs that method ReadOnlyCollection<string> GetUserNames() wait for the ReceiveMessages() to finish... I think it will work.

public async ReadOnlyCollection<string> GetUserNames()
{
    // Request userNames from server
    List<UserNames> userNameList = await ReceiveMessages();
    // return userNames
}

// Running on seperate thread, gets messages that server sents to client
async Task<List<UserNames>> ReceiveMessages()
{
    // Looks what message contains
    // Gets collection of userNames when requested (Working)
    // Triggers event 'UserNamesArrived' with userNames as argument
}

Take a look at that example: await and async example