Unresponsive UI when using BeginInvoke

Question

Bckground
I have a networked application written in C#. my server program has a UI and several communication threads, that read from tcp sockets and display messages on controller UI.

Communication with each client is done through a seprate thread. When i recieve some stream of messages from one client , the thread for that client writes on UI, which is a richtextbox on a Form.

I call SetTextHelper(string text) method of the form.

which looks like this

private delegate void MyTextUpdateHandler(string text);
public void SetTextHelper(string text)
{
   BeginInvoke(new MyTextUpdateHandler(SetText), new object[] { text });
}

public setText(string text)
{
   richtext.Text+= text;
}

Question
- If i use BeginInvoke my UI is entirely unresponsive when i m writing large stream of data to UI - Invoke solves that problem, but i read that for multi threaded environment where many thereads are sharing same resource Invoke can lead to deadlocks I share the common ichtextbox between around 16 threads - What would be a good desing for my situation?

Answer 1

You're probably simply spending all your time setting the text.

Try replacing the RichTextBox with an ordinary TextBox; it should be much faster.

Answer 2

Invoke shouldn't lead to deadlocks unless you own a lock while you're doing the invoking... but BeginInvoke shouldn't make the UI unresponsive either. Could the problem be that you're simply trying to update the textbox too often? Perhaps buffer the incoming text more? For example, only update the UI once every half second rather than any time you read any data.

Answer 3

You are calling BeginInvoke() too often. The UI thread will dispatch the delegate before it does its normal duties, like painting controls and responding to the mouse. If the delegate target is doing a lot of work (appending text to an RTB is expensive) or you are simply flooding it with requests, it doesn't get around to doing its normal job anymore. The UI will freeze. That happens pretty easily, about a 1000 invokes per second is enough.

The key to solve this is to realize that it is wasted effort to invoke so often. The human eye can't perceive updates faster than 25 times per second. So buffer the text until 50 milliseconds have passed since the last update. Environment.TickCount is a cheap timer.

Also beware that you might actually produce text faster than can be appended to the RTB. That requires throttling the thread. That's easy: use Invoke instead of BeginInvoke.