tasks and global variables c#

Question

I have a function that is kicked off by an event handler. In this function a new task is created and ran to set a global variable that I will need later, within another event handler.

There are a couple other functions between these two as well which don't change any of the variables used within these. But here is what it kind of looks like this.

private void EventWhereINeedTheGlobalVariableLater(object sender, Event e)
{
    //...work...

    need _variableIneed


    //....more work...
}


private void EventWhereISetGlobalVariable(object sender, Event e)
{
    //....work....
    //...make cancellationToken...
    //groups, isCommonalityGroup are other global variables already set. 

    Task.Factory.StartNew(() =>
    {
        // Clear variable to get new value
        _variableIneed = null;

        // Execute query to get new value
        _variableIneed = _workingManager.GetValue(groups, isCommonalityGroup, cancellationToken);

       RefreshView();

    }, cancellationToken);
}

I'm running into race conditions where the variable I need _variableIneed is null within the second event handler and it can't be. It works fine if I'm not flying through and trying to create enough events to crash the wpf program, but I need it work even if I do that.

Is there something I can do to get past these race conditions?

I've tried using the .ContinueWith with the option of OnlyOnRanToCompletion or whatever it is. Any other things I could try?

**Note I can't do a lot with changing how the events are ordered/handled/worked through. It's a pretty set in stone design and I just have to work around it and keep it more or less how it is.

**Update

I have also tried using the ParallelExtensionsExtras with the OrderedTaskScheduler class and I still end up getting a null reference on the variable I need.

Answer 1

When you have a Task to generate a value don't set the result to a global variable, have that result be the Result of the task, and store that task. When some other code later on needs that result it can get it from the task. This will allow the Task class to handle all of the complex synchronization logic, prevent the result from being used before the task has actually computed it, etc.

Of course for the event that needs to use the result it'll presumably need to not block on that task, but execute the remainder of the code that needs the result asynchronously after the task completes. This can be done very easily by using await on that task. If you're only using .NET 4.0 then you can use ContinueWith explicitly instead.

Answer 2

Use Servy's approach - async/Tasks. This answer is strictly for entertainment purposes or if you can't use .Net 4.0+ or 3.5 with Rx.

---

Since you can't change order of events you either need to expect the variable to be null from time to time or prevent it from ever being seen as null.

One option would be to poll this variable and only do work when it is not set to null (may need timer if your EventWhereINeedTheGlobalVariableLater does not fire repeatedly).

Alternatively you can just always keep value in the variable OR prevent other threads from seeing null value.

Preventing null from being visible in success case, still may be null if "long computation" fails:

   object lockObj = new object(); // at class level

   private void EventWhereISetGlobalVariable ...
   {
     lock(lockObj)
     {
       _variableIneed = null;
       // some long and convoluted computations
       _variableIneed = someResult;
     }
   }

   private void EventWhereINeedTheGlobalVariableLater(object sender, Event e)
   {
     lock(lockObj)
     {
      // unsing _variableIneed 
     }
   }

Preventing it to be set to null by only setting value when we have one (either locking around access to variable or volatile would work, prefer locking as in other sample). This is common pattern for caching some value that takes long time to compute and it is ok if users of the variable see slightly stale value.

   volatile WhateverYourType _variableIneed;
   private void EventWhereISetGlobalVariable ...
   {
       // some long and convoluted computations
       _variableIneed = someResult ?? _variableIneed;
   }

Note:

• make sure you understand how you deals with any locking / synchronization in your code - so be very careful using that variable in more than one place. Consider to to wrap access to the variable with lock.
• consider copying value to local variable inside lock and using local variable in code that "need value". Otherwise other thread may change it to new value/null.
• for one-time set variables consider Lazy<T> class that deals with such initialization or if use of Cache to store value is more appropriate.