Why to use TEMPORARY reference is event raising?

Question

0.00/5 (No votes)

See more:

Hi everyone!

I have a method to raise an event TextChanged in my class

C#

  protected virtual void OnTextChanged( EventArgs e )
{
   EventHandler  temp = this.TextChanged;

 if (temp != null)  
    // --- possible unscribing ---
    temp(this, e);

}

I know that in multithreaded applications sometimes other calls
in other threads might unscribe from the event right after the NULL
check and before the invocation of delegate...
but what is the DIFFERENCE???
TextChanged is a reference and temp is also a reference and
temp points to TextChanged so it points to the same block of memory where TextChanged points
if TextChanged == null then temp is also NULL
Please explain

Posted 27-Apr-10 4:58am

Nick Reshetinsky

Updated 27-Apr-10 5:04am

DaveAuld

v2

Add a Solution

1 solution

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

OriginalGriff · Answer 1 · 2010-04-27T05:23:00

When you execute the OnTextChanged method, the current value of TextChanged is loaded into temp: both are referring to the same object - an event handler that has subscribed to the TextChanged event.

If after this, another thread unsubscribes, then TextChanged can become null. But temp is still referring to the original event handler. The value of temp does not change. You can then test temp, and if not null, signal the event.

If you didn't take a copy of the TextChanged event, then the test could pass, but another thread could then change TextChanged between the test and the execute. It is unlikely, but it is possible.