Need code explanation in C#

Question

I need a detailed explanation of the following code line-by-line and how the flow goes, for example, when I debug. I have just used this code in my program for avoiding a cross thread access error. The code is working fine, but what is this code is all about?

delegate void updateTextField(string Text);
private void updateText(string Text)
{
    if (txtDelegate.InvokeRequired)
    {
        updateTextField del = new updateTextField(updateText);
        txtDelegate.Invoke(del, new object[] { Text });
    }
    else
    {
        txtDelegate.Text = Text;
    }
}

This method is called under backgroundWorker_DoWork():

updateText("using delegate");

I also need an explanation for delegates. I read about it, but what I understood is that a delegate is like a pointer to a function, but I need a clean explanation with a simple example. Think of me as a novice.

pls give me teh explainz

Adrian Grigore
– Adrian Grigore

2010-10-20 11:16:54 +00:00
Commented Oct 20, 2010 at 11:16 — Adrian Grigore
– Adrian Grigore, Commented Oct 20, 2010 at 11:16

jgauffin · Accepted Answer · 2010-10-20 11:33:55Z

// Declaring a delegate function kind of lifts the function away from the 
// current object and the current thread, making it 'thread-safe' to call 
// (although it may still not be thread-safe to execute).
delegate void updateTextField(string Text); 
private void updateText(string Text)
{
    // This asks the control if it's running on the same thread as this method is 
    // currently executing, i.e. can I update you directly or do I need to use 
    // the cross thread calling method "Invoke".
    if (txtDelegate.InvokeRequired) 
    {
        // Here we define the delegate function that's going to be Invoked. 
        // Here it's the same function were currently within but when it's invoked 
        // by the following line, it'll be done on the same thread as the control. 
        // At that point, InvokeRequired will return false and the other branch 
        // will be followed to update the actual text on the control.
        updateTextField del = new updateTextField(updateText);             

        // Here we invoke the function passing in the Text we want to update the
        // control with as a parameter.
        txtDelegate.Invoke(del, new object[] { Text });         
    }
    else
    {
        // When this function is Invoked, this is the branch that will be followed 
        // (as we're on the same thread as the control) and the text on the control
        //  will be replaced with the text passed in from the Invoke.
        txtDelegate.Text = Text;          
    }
}

I hope that covers it in a bit more detail, the actual mechanics of the delegate being 'thread-safe' is beyond the scope of this answer.

Stephen · Accepted Answer · 2010-10-20 11:17:04Z

3

delegate void updateTextField(string Text); // delegate allows updatetext to be passed as a parameter
private void updateText(string Text) 
{ 
    if (txtDelegate.InvokeRequired) // on a different thread so requires invoke
    { 
        updateTextField del = new updateTextField(updateText); 
        txtDelegate.Invoke(del, new object[] { Text }); // invoke/execute the delegate on the thread
    } 
    else 
    { 
        txtDelegate.Text = Text; 
    } 
}

Comments added to the code

answered Oct 20, 2010 at 11:17

Stephen

3,0841 gold badge20 silver badges22 bronze badges

2 Comments

FosterZ Over a year ago

i can also use txtDelegate.Invoke(new Action(delegate() { txtDelegate.Text = Text; })); what is the difference ?

tKe Over a year ago

By using the Action all-purpose delegate that wraps an anonymous delegate that does the setting, the original (as in my answer) calls the updateText method again, but on the correct thread. The downside to using Action in the way you've defined is that you have duplicated the line of code actually setting the text value. For this simple case that is not much of an issue but if you were doing more with the values it would be better to use txtDelegate.Invoke(new Action(delegate(){updateText(Text);})); to call the original method on the correct thread, or use the original method.

Peter Mortensen · Accepted Answer · 2012-11-20 18:31:23Z

3

When updateText is called from the wrong thread (assuming txtDelegate is a control, called from any thread other than the thread it was created on (the UI thread)), the flow is as follows.

updateText(String) called on 'wrong' thread
    txtDelegate.InvokeRequired is true
        wrap updateText(String) in a delegate (updateTextField)
        invoke the delegate on the correct thread (passing Text as parameter)
updateText(String) called on correct thread
    txtDelegate.InvokeRequire is false
        set txtDelegate.Text to Text

When called directly on the "correct" thread (the UI thread):

updateText(String) called on correct thread
    txtDelegate.InvokeRequire = false
        set txtDelegate.Text to Text

edited Nov 20, 2012 at 18:31

Peter Mortensen

31.4k22 gold badges110 silver badges134 bronze badges

answered Oct 20, 2010 at 11:25

tKe

5602 silver badges9 bronze badges

Comments

Peter Mortensen · Accepted Answer · 2012-11-20 18:33:50Z

You're spot on when you say a delegate is like a pointer to a method. It allows you to specify, in a safe way, a method,'Foo', as an argument to another method,'Bar', and chances are, the 'Bar' method will call 'Foo' at some stage.

In your above code, the reason you need to do all this work, is due to threading. In Windows Forms, you may have multiple threads in your application, but only the UI thread is allowed to make changes to the controls. So, in the txtDelegate.InvokeRequired line, you're checking to see if the thread is the UI thread or not. If it is, then just set the value of the txtDelegate as normal (in the else portion), if it's not, it gets a little trickier. You then need to tell the UI thread to run some code that will update the value of the textbox, since the current thread cant do it.

To sum it all up,

The delegate is the code that contains the instructions to do this,
The UI thread is what does it,
Your thread asks the UI thread to do it, via the Invoke method.

Have a read of Control.InvokeRequired Property too.

Peter Mortensen · Accepted Answer · 2012-11-20 18:30:35Z

2

A delegate is like a pointer to the function (I hope you are aware of function pointers in C). So the delegate should have the same signature as a function so that you can point to it.

A cross-thread calls is only allowed in .NET Framework 1.1., it has been stopped after 2.0, So the application checks whether this call is a cross-thread call or normal call using txtDelegate.InvokeRequired, and make a delegate to call the method rather than the real call.....

Otherwise, we can make the normal changes (same thread).

edited Nov 20, 2012 at 18:30

Peter Mortensen

31.4k22 gold badges110 silver badges134 bronze badges

answered Oct 20, 2010 at 11:17

Rajesh Subramanian

6,4755 gold badges33 silver badges42 bronze badges

2 Comments

FosterZ Over a year ago

Delegates are only used when we need cross threading ? or can you tell me some scenario where delegates comes into picture..

Rajesh Subramanian Over a year ago

No, Delegates is not only designed for Cross- thread communications, it is used for Event Handling, Method Calls and etc .. . Think about calling an method when some event happens in the form/controls. There you can point to the delegate....

Collectives™ on Stack Overflow

Need code explanation in C#

5 Answers 5

Comments

2 Comments

Comments

Comments

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

Comments

2 Comments

Comments

Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related