¿Es posible esperar un evento en lugar de otro método asincrónico?

Cuando tienes algo inusual que necesitas await encendido, la respuesta más fácil es a menudo TaskCompletionSource (o algún primitivo habilitado async basado en TaskCompletionSource).

En este caso, su necesidad es bastante simple, por lo que solo puede usar TaskCompletionSource directamente:

private TaskCompletionSource<object> continueClicked;

private async void Button_Click_1(object sender, RoutedEventArgs e) 
{
  // Note: You probably want to disable this button while "in progress" so the
  //  user can't click it twice.
  await GetResults();
  // And re-enable the button here, possibly in a finally block.
}

private async Task GetResults()
{ 
  // Do lot of complex stuff that takes a long time
  // (e.g. contact some web services)

  // Wait for the user to click Continue.
  continueClicked = new TaskCompletionSource<object>();
  buttonContinue.Visibility = Visibility.Visible;
  await continueClicked.Task;
  buttonContinue.Visibility = Visibility.Collapsed;

  // More work...
}

private void buttonContinue_Click(object sender, RoutedEventArgs e)
{
  if (continueClicked != null)
    continueClicked.TrySetResult(null);
}

Lógicamente, TaskCompletionSource es como un async ManualResetEvent, excepto que solo puede " establecer "el evento una vez y el evento puede tener un" resultado " (en este caso, no lo estamos usando, por lo que solo establecemos el resultado en null).

Lo ideal es que no. Si bien ciertamente puede bloquear el hilo asincrónico, eso es un desperdicio de recursos, y no lo ideal.

Considere el ejemplo canónico donde el usuario va a almorzar mientras el botón espera que se haga clic.

Si ha detenido su código asincrónico mientras espera la entrada del usuario, entonces solo está desperdiciando recursos mientras ese hilo está en pausa.

Dicho esto, es mejor si en su operación asíncrona, establece el estado que es necesario mantener hasta el punto en el que el botón está habilitado y usted está "esperando" en un clic. En ese punto, su GetResults método se detiene.

Luego, cuando se hace clic en el botón , en función del estado que haya almacenado, inicia otra tarea asíncrona para continuar el trabajo.

Porque el SynchronizationContext se capturará en el controlador de eventos que llama a GetResults (el compilador hará esto como resultado de usar la palabra clave await que se está utilizando, y hecho de que SynchronizationContext.Current should be non-null, given you are in a UI application), you can use async/await así:

private async void Button_Click_1(object sender, RoutedEventArgs e) 
{
     await GetResults();

     // Show dialog/UI element.  This code has been marshaled
     // back to the UI thread because the SynchronizationContext
     // was captured behind the scenes when
     // await was called on the previous line.
     ...

     // Check continue, if true, then continue with another async task.
     if (_continue) await ContinueToGetResultsAsync();
}

private bool _continue = false;
private void buttonContinue_Click(object sender, RoutedEventArgs e)
{
    _continue = true;
}

private async Task GetResults()
{ 
     // Do lot of complex stuff that takes a long time
     // (e.g. contact some web services)
  ...
}

ContinueToGetResultsAsync es el método que continúa obteniendo los resultados en caso de que se presione el botón. Si el botón no está pulsado, entonces el controlador de eventos no hace nada.

Aquí hay una clase de utilidad que uso:

public class AsyncEventListener
{
    private readonly Func<bool> _predicate;

    public AsyncEventListener() : this(() => true)
    {

    }

    public AsyncEventListener(Func<bool> predicate)
    {
        _predicate = predicate;
        Successfully = new Task(() => { });
    }

    public void Listen(object sender, EventArgs eventArgs)
    {
        if (!Successfully.IsCompleted && _predicate.Invoke())
        {
            Successfully.RunSynchronously();
        }
    }

    public Task Successfully { get; }
}

Y así es como lo uso:

var itChanged = new AsyncEventListener();
someObject.PropertyChanged += itChanged.Listen;

// ... make it change ...

await itChanged.Successfully;
someObject.PropertyChanged -= itChanged.Listen;

Clase Auxiliar Simple:

public class EventAwaiter<TEventArgs>
{
    private readonly TaskCompletionSource<TEventArgs> _eventArrived = new TaskCompletionSource<TEventArgs>();

    private readonly Action<EventHandler<TEventArgs>> _unsubscribe;

    public EventAwaiter(Action<EventHandler<TEventArgs>> subscribe, Action<EventHandler<TEventArgs>> unsubscribe)
    {
        subscribe(Subscription);
        _unsubscribe = unsubscribe;
    }

    public Task<TEventArgs> Task => _eventArrived.Task;

    private EventHandler<TEventArgs> Subscription => (s, e) =>
        {
            _eventArrived.TrySetResult(e);
            _unsubscribe(Subscription);
        };
}

Uso:

var valueChangedEventAwaiter = new EventAwaiter<YourEventArgs>(
                            h => example.YourEvent += h,
                            h => example.YourEvent -= h);
await valueChangedEventAwaiter.Task;

Stephen Toub publicó esta clase AsyncManualResetEvent en su blog .

public class AsyncManualResetEvent 
{ 
    private volatile TaskCompletionSource<bool> m_tcs = new TaskCompletionSource<bool>();

    public Task WaitAsync() { return m_tcs.Task; } 

    public void Set() 
    { 
        var tcs = m_tcs; 
        Task.Factory.StartNew(s => ((TaskCompletionSource<bool>)s).TrySetResult(true), 
            tcs, CancellationToken.None, TaskCreationOptions.PreferFairness, TaskScheduler.Default); 
        tcs.Task.Wait(); 
    }

    public void Reset() 
    { 
        while (true) 
        { 
            var tcs = m_tcs; 
            if (!tcs.Task.IsCompleted || 
                Interlocked.CompareExchange(ref m_tcs, new TaskCompletionSource<bool>(), tcs) == tcs) 
                return; 
        } 
    } 
}

Con Extensiones reactivas (Rx.Net)

var eventObservable = Observable
            .FromEventPattern<EventArgs>(
                h => example.YourEvent += h,
                h => example.YourEvent -= h);

var res = await eventObservable.FirstAsync();

Puede agregar Rx con el Sistema de paquetes Nuget.Reactivo