Ensuring execution order between multiple thread
===

I am having a kinda annoying problem mostly due to my low skill level/experience in C# multithreading.

Here is the background. In my framework, I have a static class named `WaitFormHelper`, which has two static methods (well... actually more but we don't care here), `Start()` and `Close()`
The `Start()` method initializes and starts a thread which will acquire a lock on the `locker` object and create a `WaitForm` (which is a small loading control with a custom message and a progress bar)

In my current project, I have a method which starts a `WaitForm`, performs calculations, then closes the `WaitForm`. Nothing fancy at all.
The method looks like the following, I simplified it as much as possible:

    public void PerformCalculations()
    {
       try
       {
          WaitFormHelper.Start("Title", "message", false);
          if (this.CalculationsParameters.IsInvalid)
          {
             return;
          }
          // Perform all those lengthy calculations here
       } 
       // catch whatever exception I may have to catch, we don't care here
       finally
       {
          WaitFormHelper.Close();
       }
    }


Here are the `Start()` and `Close()` methods with related methods & attributes, simplified as well:


    private static Thread instanceCaller;
    private static WaitForm instance;

    private static AutoResetEvent waitFormStarted = new AutoResetEvent(false);
    private static object locker = new object();

    /// <summary>
    /// Initializes WaitForm to start a single task
    /// </summary>
    /// <param name="header">WaitForm header</param>
    /// <param name="message">Message displayed</param>
    /// <param name="showProgressBar">True if we want a progress bar, else false</param>
    public static void Start(string header, string message, bool showProgressBar)
    {
        InitializeCallerThread(showProgressBar, header, message);
        instanceCaller.Start();
    }

    /// <summary>
    /// Initializes caller thread for executing a single command
    /// </summary>
    /// <param name="showProgressBar"></param>
    /// <param name="header"></param>
    /// <param name="message"></param>
    private static void InitializeCallerThread(bool showProgressBar, string header, string message)
    {
        waitFormStarted.Reset();

        instanceCaller = new Thread(() =>
        {
            lock (locker)
            {
                instance = new WaitForm()
                {
                    Header = header,
                    Message = message,
                    IsProgressBarVisible = showProgressBar
                };
                waitFormStarted.Set();
            }
            instance.ShowDialog();
        });
        instanceCaller.Name = "WaitForm thread";
        instanceCaller.SetApartmentState(ApartmentState.STA);
        instanceCaller.IsBackground = true;
    }

    /// <summary>
    /// Closes current form
    /// </summary>
    public static void Close()
    {
        lock (locker)
        {
            if (instance != null && !instance.IsClosed)
            {
                waitFormStarted.WaitOne();
                instance.FinalizeWork();
                instance.Dispatcher.Invoke(
                    new Action(() =>
                    {
                        instance.Close();
                    }));
            }
        }
    }


**Now let's get to the problem**

This usually works fine, except in this case:
If `this.CalculationsParameters.IsInvalid` is true (ie. as you probably already understood, I can't perform calculations for some reason, such as "user entering crap in my forms"), the execution directly closes my `WaitForm`.
However in this case, the main thread will reach the `Close` method and acquire a lock on the `locker` object **before** the thread fired by the `Start()` method.

What happens is that: `Close` acquires lock, tries to close the form but `instance` is still null because the `Thread` created in `InitializeCallerThread` is still waiting for the lock to actually create it. `Close` releases lock, `InitializeCallerThread` acquires it and... shows a `WaitForm` which will not close.




Now I know that I can simply fix this problem by testing if the calculation parameters are invalid before actually starting the WaitForm, but well, problem is this `WaitForm` is supposed to be used by all applications of our framework (which includes 40+ different apps used and maintained in 4 countries), so ideally I'd rather prefer seeing my `WaitForm` working at all cases.

Do you have any idea on how could I synchronize this to make sure the starter thread is definitely called and executed first?
As you can see I already use an `AutoResetEvent` for this matter, but if I listen to it before the test `if (instance != null)` I will end up stuck in my case.


Hope this is clear enough! Thank you!