title: Awaitable AutoResetEvent
body: <p>What would be the async (awaitable) equivalent of AutoResetEvent?</p>
  
  <p>If in the classic thread synchronization we would use something like this:</p>
  
  <pre><code>    AutoResetEvent signal = new AutoResetEvent(false);
  
      void Thread1Proc()
      {
          //do some stuff
          //..
          //..
  
          signal.WaitOne(); //wait for an outer thread to signal we are good to continue
  
          //do some more stuff
          //..
          //..
      }
  
      void Thread2Proc()
      {
          //do some stuff
          //..
          //..
  
          signal.Set(); //signal the other thread it's good to go
  
          //do some more stuff
          //..
          //..
      }
  </code></pre>
  
  <p>I was hoping that in the new async way of doing things, something like this would come to be:</p>
  
  <pre><code>SomeAsyncAutoResetEvent asyncSignal = new SomeAsyncAutoResetEvent();
  
  async void Task1Proc()
  {
      //do some stuff
      //..
      //..
  
      await asyncSignal.WaitOne(); //wait for an outer thread to signal we are good to continue
  
      //do some more stuff
      //..
      //..
  }
  
  async void Task2Proc()
  {
      //do some stuff
      //..
      //..
  
      asyncSignal.Set(); //signal the other thread it's good to go
  
      //do some more stuff
      //..
      //..
  }
  </code></pre>
  
  <p>I've seen other custom made solutions, but what I've managed to get my hands on, at some point in time, still involves locking a thread. I don't want this just for the sake of using the new await syntax. I'm looking for a true awaitable signaling mechanism which does not lock any thread.</p>
  
  <p>Is it something I'm missing in the Task Parallel Library?</p>
  
  <p>EDIT: Just to make clear: SomeAsyncAutoResetEvent is an entirely made up class name used as a placeholder in my example.</p>