¿Es posible esperar un evento en lugar de otro método asíncrono?

En mi aplicación de metro C # / XAML, hay un botón que inicia un proceso de larga duración. Entonces, como se recomienda, estoy usando async / await para asegurarme de que el hilo de la interfaz de usuario no se bloquee:

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

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

Ocasionalmente, las cosas que suceden dentro de GetResults requerirían una entrada adicional del usuario antes de poder continuar. Para simplificar, digamos que el usuario solo tiene que hacer clic en el botón "continuar".

Mi pregunta es: ¿cómo puedo suspender la ejecución de GetResults de tal manera que aguarde un evento como el clic de otro botón?

Aquí hay una forma fea de lograr lo que estoy buscando: el controlador de eventos para el botón continuar "establece una bandera ...

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

... y GetResults lo sondea periódicamente:

 buttonContinue.Visibility = Visibility.Visible;
 while (!_continue) await Task.Delay(100);  // poll _continue every 100ms
 buttonContinue.Visibility = Visibility.Collapsed;

La encuesta es claramente terrible (espera ocupada / pérdida de ciclos) y estoy buscando algo basado en eventos.

¿Algunas ideas?

Por cierto, en este ejemplo simplificado, una solución sería dividir GetResults () en dos partes, invocar la primera parte desde el botón de inicio y la segunda parte desde el botón continuar. En realidad, las cosas que suceden en GetResults son más complejas y se pueden requerir diferentes tipos de entrada del usuario en diferentes puntos dentro de la ejecución. Por lo tanto, dividir la lógica en múltiples métodos no sería trivial.

Puede usar una instancia de la clase SemaphoreSlim como señal:

private SemaphoreSlim signal = new SemaphoreSlim(0, 1);

// set signal in event
signal.Release();

// wait for signal somewhere else
await signal.WaitAsync();

Alternativamente, puede usar una instancia de la clase TaskCompletionSource <T> para crear una Tarea <T> que represente el resultado del clic del botón:

private TaskCompletionSource<bool> tcs = new TaskCompletionSource<bool>();

// complete task in event
tcs.SetResult(true);

// wait for task somewhere else
await tcs.Task;

Cuando tiene algo inusual que necesita await, la respuesta más fácil es a menudo TaskCompletionSource(o alguna asyncprimitiva basada en TaskCompletionSource).

En este caso, su necesidad es bastante simple, por lo que puede usar TaskCompletionSourcedirectamente:

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, TaskCompletionSourcees como un async ManualResetEvent, excepto que solo puede "configurar" el evento una vez y el evento puede tener un "resultado" (en este caso, no lo estamos usando, así que simplemente configuramos el resultado en null).

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 de ayuda 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;

Idealmente, no lo haces . Si bien ciertamente puede bloquear el hilo asíncrono, eso es un desperdicio de recursos, y no es ideal.

Considere el ejemplo canónico en el que 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 asincrónica, establece el estado que necesita mantener hasta el punto donde el botón está habilitado y está "esperando" un clic. En ese punto, su GetResultsmétodo se detiene .

Luego, cuando se hace clic en el botón , según el estado que haya almacenado, comienza otra tarea asincrónica para continuar el trabajo.

Debido a SynchronizationContextque se capturará en el controlador de eventos que llama GetResults(el compilador lo hará como resultado del uso de la awaitpalabra clave que se usa y el hecho de que SynchronizationContext.Current no debe ser nulo, dado que está en una aplicación de interfaz de usuario), puede usar async/ meawait gusta 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)
  ...
}

ContinueToGetResultsAsynces el método que continúa obteniendo los resultados en caso de que se presione el botón. Si no se presiona su botón , su controlador de eventos no hace nada.

Stephen Toub publicó esta AsyncManualResetEventclase 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 Nuget Package System.

Muestra probada:

    private static event EventHandler<EventArgs> _testEvent;

    private static async Task Main()
    {
        var eventObservable = Observable
            .FromEventPattern<EventArgs>(
                h => _testEvent += h,
                h => _testEvent -= h);

        Task.Delay(5000).ContinueWith(_ => _testEvent?.Invoke(null, new EventArgs()));

        var res = await eventObservable.FirstAsync();

        Console.WriteLine("Event got fired");
    }

Estoy usando mi propia clase AsyncEvent para eventos pendientes.

public delegate Task AsyncEventHandler<T>(object sender, T args) where T : EventArgs;

public class AsyncEvent : AsyncEvent<EventArgs>
{
    public AsyncEvent() : base()
    {
    }
}

public class AsyncEvent<T> where T : EventArgs
{
    private readonly HashSet<AsyncEventHandler<T>> _handlers;

    public AsyncEvent()
    {
        _handlers = new HashSet<AsyncEventHandler<T>>();
    }

    public void Add(AsyncEventHandler<T> handler)
    {
        _handlers.Add(handler);
    }

    public void Remove(AsyncEventHandler<T> handler)
    {
        _handlers.Remove(handler);
    }

    public async Task InvokeAsync(object sender, T args)
    {
        foreach (var handler in _handlers)
        {
            await handler(sender, args);
        }
    }

    public static AsyncEvent<T> operator+(AsyncEvent<T> left, AsyncEventHandler<T> right)
    {
        var result = left ?? new AsyncEvent<T>();
        result.Add(right);
        return result;
    }

    public static AsyncEvent<T> operator-(AsyncEvent<T> left, AsyncEventHandler<T> right)
    {
        left.Remove(right);
        return left;
    }
}

Para declarar un evento en la clase que genera eventos:

public AsyncEvent MyNormalEvent;
public AsyncEvent<ProgressEventArgs> MyCustomEvent;

Para plantear los eventos:

if (MyNormalEvent != null) await MyNormalEvent.InvokeAsync(this, new EventArgs());
if (MyCustomEvent != null) await MyCustomEvent.InvokeAsync(this, new ProgressEventArgs());

Para suscribirse a los eventos:

MyControl.Click += async (sender, args) => {
    // await...
}

MyControl.Click += (sender, args) => {
    // synchronous code
    return Task.CompletedTask;
}