title: await not using current SynchronizationContext
body: <p>I'm getting confusing behavior when using a different SynchronizationContext inside an async function than outside.</p>
  
  <p>Most of my program's code uses a custom SynchronizationContext that simply queues up the SendOrPostCallbacks and calls them at a specific known point in my main thread. I set this custom SynchronizationContext at the beginning of time and everything works fine when I only use this one.</p>
  
  <p>The problem I'm running into is that I have functions that I want their await continuations to run in the thread pool. </p>
  
  <pre><code>void BeginningOfTime() {
      // MyCustomContext queues each endOrPostCallback and runs them all at a known point in the main thread.
      SynchronizationContext.SetSynchronizationContext( new MyCustomContext() ); 
  
  
      // ... later on in the code, wait on something, and it should continue inside 
      // the main thread where MyCustomContext runs everything that it has queued
      int x = await SomeOtherFunction();
      WeShouldBeInTheMainThreadNow(); // ********* this should run in the main thread
  }
  
  async int SomeOtherFunction() {
      // Set a null SynchronizationContext because this function wants its continuations 
      // to run in the thread pool.
      SynchronizationContext prevContext = SynchronizationContext.Current;
      SynchronizationContext.SetSynchronizationContext( null );
  
      try {
  
          // I want the continuation for this to be posted to a thread pool 
          // thread, not MyCustomContext.
          await Blah();
  
          WeShouldBeInAThreadPoolThread(); // ********* this should run in a thread pool thread
  
      } finally {
          // Restore the previous SetSynchronizationContext.
          SynchronizationContext.SetSynchronizationContext( prevContext );
      }
  }
  </code></pre>
  
  <p>The behavior I'm getting is that the code right after each await is executed in a seemingly-random thread. Sometimes, WeShouldBeInTheMainThreadNow() is running in a thread pool thread and sometimes the main thread. Sometimes WeShouldBeInAThreadPoolThread() is running</p>
  
  <p>I don't see a pattern here, but I thought that whatever SynchronizationContext.Current was set to at the line where you use await is the one that will define where the code following the await will execute. Is that an incorrect assumption? If so, is there a compact way to do what I'm trying to do here?</p>