Question

I’m now implementing the network program using the namedpipe and C#. Within the server program’s main method, I started one thread named “ReadingMessage” which is to read the messages from the client program. In this thread, it needs to change the properties of controls (Text of textbox, Position of labels, etc.) based on the messages returned from the client. Therefore, it had cross-threaded errors in this procedure (“ReadingMesssage between UI thread”). I found out that there are two ways to solve this problem

1. Invoke the controls using Delegate
2. Form.CheckForIllegalCrossThreadCalls = false;

I tested both of them but there is one problem. When the form started as first time, the properties of control are changed without any errors. When the form is closed and started again as second time, the properties of control are not changed and any error messages are not shown. I catch the breakpoint to the code where the properties of controls are instructed to change. The code run smoothly but the problem still occurs.

I don’t know what’s that problem. Therefore, if anyone knows this problem, please suggest me…

Update: (Posting Code and Correcting some errors in my first question)

The thread is not in the main method of server program. I was wrong because I wanted to describe my question in short. Now, I will describe my question in more detail. There is one button click event in the main form of server program.

//Main Form
public partial class MainForm : Form
{
    private void btnButton_Click(object sender, EventArgs e)
    {
       AnotherForm aform = new AnotherForm(); //This is the form where threading run
       aform.show();    
    }
}

//AnotherForm
public partial class AnotherForm : Form
{
    private void CargoLoading_Load(object sender, EventArgs e)
    {
        (new System.Threading.Thread(readingMessage)).Start(myPipe);    
    }
}

private void readingMessage(Object myPipeObject) //Read the messages send from the client machine
{
     while (true)
     {
         //Code of serverstream
         SetTextofTextBox1("AnyText"); //Code where the properties of control are instructed to change
     }
}

private void SetTextofTextBox1(string text)
{
     if (this.txtTextBox1.InvokeRequired) //the debugger return false at second time of this form is opened
     {
         SetTextCallback d = new SetTextCallback(SetTextofTextBox1);
         this.Invoke(d, new object[] { text });
     }
     else
     {
          this.txtTextBox1.Text = text;
          this.txtTextBox1.Update();
     }
}

That’s all the code where problem occur. When “AnotherForm” is open as first time, it’s OK. But it is opened again as second time, the properties of control (text of TextBox1) is not effected and not changed. At there, I noticed that the debugger return false to Control.InvokeRequired at this second time. Really sorry for all for long question because I’m a novice as a programmer.

Still expecting your suggestions…

Update 2:

Finally I tried all the ways but it doesn’t come out the best solution. Therefore, I would like to suggest all to just avoid this condition and re-write some of your code in another concept when u meet this situation like me.

Answer 1

From your background thread, you should use Control.InvokeRequired and Control.Invoke in order to cause the UI thread to execute the code that updates the UI.

Only the UI thread is allowed to “touch” control properties, so your background thread cannot update them.

To be more specific, in case you’re interesting in more details: in Windows, each form and control usually have 1 or more HWND associated with them. An HWND is a handle to the Windows operating system object representing a Windows window.

Each HWND is always associated to a specific thread, the thread that created it. Any Windows message sent to that HWND will reach that thread’s message queue and must be handled by that thread’s message loop.

When you make seemingly innocent calls to Controls methods, the implementation of these methods might sometime destroy and create HWND under the hood (for example, creating a submenu for a Menu control or adding a button to a Toolbar control). Now, if you were to make such calls from different threads, you would end up with HWNDs belonging to different threads, and the processing of your controls’ messages would be broken.

For that reason, all access to controls’ methods are prohibited from any thread other than the thread that created the control’s HWND (e.g. the thread on which `Control.CreateControl() was called).

In the bottom line, for most simple applications, the main thread is the only one creating windows, and so you should be touching Forms and Controls only from your main thread.