Question

In this article:

http://msdn.microsoft.com/en-us/library/ms171728(VS.80).aspx

The author uses the following method to make thread-safe calls to a Windows Forms control:

private void SetText(string text) {     // InvokeRequired required compares the thread ID of the     // calling thread to the thread ID of the creating thread.     // If these threads are different, it returns true.     if (this.textBox1.InvokeRequired)     {             SetTextCallback d = new SetTextCallback(SetText);         this.Invoke(d, new object[] { text });     }     else     {         this.textBox1.Text = text;     } } 

Is there a shorter way to accomplish the same thing?

Answer 1

C# 3.0 and after:

An extension method would generally be the way to go, since you’re always going to want to perform an action on an ISynchronizeInvoke interface implementation, it’s a good design choice.

You can also take advantage of anonymous methods (closures) to account for the fact that you don’t know what parameters to pass to the extension method; the closure will capture the state of everything needed.

// Extension method. static void SynchronizedInvoke(this ISynchronizeInvoke sync, Action action) {     // If the invoke is not required, then invoke here and get out.     if (!sync.InvokeRequired)     {         // Execute action.         action();          // Get out.         return;     }      // Marshal to the required context.     sync.Invoke(action, new object[] { }); } 

You’d then call it like this:

private void SetText(string text) {     textBox1.SynchronizedInvoke(() => textBox1.Text = text); } 

Here, the closure is over the text parameter, that state is captured and passed as part of the Action delegate passed to the extension method.

Before C# 3.0:

You don’t have the luxury of lambda expressions, but you can still generalize the code. It’s pretty much the same, but not an extension method:

static void SynchronizedInvoke(ISynchronizeInvoke sync, Action action) {     // If the invoke is not required, then invoke here and get out.     if (!sync.InvokeRequired)     {         // Execute action.         action();          // Get out.         return;     }      // Marshal to the required context.     sync.Invoke(action, new object[] { }); } 

And then you call it with anonymous method syntax:

private void SetText(string text) {     SynchronizedInvoke(textBox1, delegate() { textBox1.Text = text; }); }