Блокировка и ожидание события

Question

Иногда хочется заблокировать мой поток в ожидании события.

Обычно я делаю что-то вроде этого:

private AutoResetEvent _autoResetEvent = new AutoResetEvent(false);

private void OnEvent(object sender, EventArgs e){
  _autoResetEvent.Set();
}

// ...
button.Click += OnEvent;
try{
  _autoResetEvent.WaitOne();
}
finally{
  button.Click -= OnEvent;
}

Однако, похоже, это должно быть что-то, что я мог бы извлечь из общего класса (или, может быть, даже из того, что уже существует в фреймворке).

Я хотел бы иметь возможность сделать что-то вроде этого:

EventWaiter ew = new EventWaiter(button.Click);
ew.WaitOne();
EventWaiter ew2 = new EventWaiter(form.Closing);
ew2.WaitOne();

Но я не могу найти способ создать такой класс (я не могу найти хороший действительный способ передать событие в качестве аргумента). Кто-нибудь может помочь?

Чтобы привести пример того, почему это может быть полезно, рассмотрим что-то вроде этого:

var status = ShowStatusForm();
status.ShowInsertUsbStick();
bool cancelled = WaitForUsbStickOrCancel();
if(!cancelled){
  status.ShowWritingOnUsbStick();
  WriteOnUsbStick();
  status.AskUserToRemoveUsbStick();
  WaitForUsbStickToBeRemoved();
  status.ShowFinished();
}else{
  status.ShowCancelled();
}
status.WaitUntilUserPressesDone();

Это гораздо более кратко и читабельно, чем эквивалентный код, написанный с логикой, распределенной между многими методами. Но чтобы реализовать WaitForUsbStickOrCancel (), WaitForUsbStickToBeRemoved и WaitUntilUserPressesDone () (предположим, что мы получаем событие, когда USB-флешки вставляются или удаляются), мне нужно каждый раз переопределять «EventWaiter». Конечно, вы должны быть осторожны, чтобы никогда не запускать это в GUI-потоке, но иногда это стоит компромисса с более простым кодом.

Альтернатива будет выглядеть примерно так:

var status = ShowStatusForm();
status.ShowInsertUsbStick();
usbHandler.Inserted += OnInserted;
status.Cancel += OnCancel;
//...
void OnInserted(/*..*/){
  usbHandler.Inserted -= OnInserted;
  status.ShowWritingOnUsbStick();
  MethodInvoker mi = () => WriteOnUsbStick();
  mi.BeginInvoke(WritingDone, null);
}
void WritingDone(/*..*/){
  /* EndInvoke */
  status.AskUserToRemoveUsbStick();
  usbHandler.Removed += OnRemoved;
}
void OnRemoved(/*..*/){
  usbHandler.Removed -= OnRemoved;
  status.ShowFinished();
  status.Done += OnDone;
}
/* etc */

Мне гораздо труднее читать. Следует признать, что далеко не всегда поток будет таким линейным, но когда это так, мне нравится первый стиль.

Это сравнимо с использованием ShowMessage () и Form.ShowDialog () - они также блокируются, пока не произойдет какое-либо «событие» (хотя они будут запускать цикл сообщений, если они вызваны в потоке GUI).

Answer 1

Я изменил класс EventWaiter Dead.Rabit для обработки EventHandler<T>. Таким образом, вы можете использовать для ожидания всех событий тип EventHandler<T>, это означает, что ваш делегат выглядит как delegate void SomeDelegate(object sender, T EventsArgs).

 public class EventWaiter<T>
{

    private AutoResetEvent _autoResetEvent = new AutoResetEvent(false);
    private EventInfo _event = null;
    private object _eventContainer = null;

    public EventWaiter(object eventContainer, string eventName)
    {
        _eventContainer = eventContainer;
        _event = eventContainer.GetType().GetEvent(eventName);
    }

    public void WaitForEvent(TimeSpan timeout)
    {
        EventHandler<T> eventHandler = new EventHandler<T>((sender, args) => { _autoResetEvent.Set(); });
        _event.AddEventHandler(_eventContainer, eventHandler);
        _autoResetEvent.WaitOne(timeout);
        _event.RemoveEventHandler(_eventContainer, eventHandler);
    }
}

И, например, я использую его для ожидания получения URL-адреса из HttpNotificationChannel при регистрации в службе push-уведомлений Windows.

            HttpNotificationChannel pushChannel = new HttpNotificationChannel(channelName);
            //ChannelUriUpdated is event 
            EventWaiter<NotificationChannelUriEventArgs> ew = new EventWaiter<NotificationChannelUriEventArgs>(pushChannel, "ChannelUriUpdated");
            pushChannel.Open();
            ew.WaitForEvent(TimeSpan.FromSeconds(30));

Answer 2

Не передавайте событие, передайте делегата, который соответствует подписи обработчика события. На самом деле это звучит хакерски, так что помните о возможных проблемах с блокировкой.

Answer 3

Вы также можете попробовать это:

class EventWaiter<TEventArgs> where TEventArgs : EventArgs
{
    private readonly Action<EventHandler<TEventArgs>> _unsubHandler;
    private readonly Action<EventHandler<TEventArgs>> _subHandler;

    public EventWaiter(Action<EventHandler<TEventArgs>> subHandler, Action<EventHandler<TEventArgs>> unsubHandler)
    {
        _unsubHandler = unsubHandler;
        _subHandler = subHandler;
    }

    protected void Handler(object sender, TEventArgs args)
    {
        _unsubHandler.Invoke(Handler);
        TaskCompletionSource.SetResult(args);
    }

    public  TEventArgs WaitOnce()
    {
        TaskCompletionSource = new TaskCompletionSource<TEventArgs>();
        _subHandler.Invoke(Handler);
        return TaskCompletionSource.Task.Result;
    }

    protected TaskCompletionSource<TEventArgs> TaskCompletionSource { get; set; } 

}

Использование:

EventArgs eventArgs = new EventWaiter<EventArgs>((h) => { button.Click += new EventHandler(h); }, (h) => { button.Click -= new EventHandler(h); }).WaitOnce();

Answer 4

Я собрал рабочий образец в LinqPad, используя отражение, получая ссылку на объект EventInfo со строкой (будьте осторожны, поскольку вы теряете проверку времени компиляции). Очевидная проблема заключается в том, что нет никакой гарантии, что событие когда-либо будет запущено, или что событие, которое вы ожидаете, может быть запущено до того, как класс EventWaiter готов начать блокировку, поэтому я не уверен, что буду спать спокойно, если я вставлю это производственное приложение.

void Main()
{
    Console.WriteLine( "main thread started" );

    var workerClass = new WorkerClassWithEvent();
    workerClass.PerformWork();

    var waiter = new EventWaiter( workerClass, "WorkCompletedEvent" );
    waiter.WaitForEvent( TimeSpan.FromSeconds( 10 ) );

    Console.WriteLine( "main thread continues after waiting" );
}

public class WorkerClassWithEvent
{
    public void PerformWork()
    {
        var worker = new BackgroundWorker();
        worker.DoWork += ( s, e ) =>
        {
            Console.WriteLine( "threaded work started" );
            Thread.Sleep( 1000 ); // <= the work
            Console.WriteLine( "threaded work complete" );
        };
        worker.RunWorkerCompleted += ( s, e ) =>
        {
            FireWorkCompletedEvent();
            Console.WriteLine( "work complete event fired" );
        };

        worker.RunWorkerAsync();
    }

    public event Action WorkCompletedEvent;
    private void FireWorkCompletedEvent()
    {
        if ( WorkCompletedEvent != null ) WorkCompletedEvent();
    }
}

public class EventWaiter
{
    private AutoResetEvent _autoResetEvent = new AutoResetEvent( false );
    private EventInfo _event               = null;
    private object _eventContainer         = null;

    public EventWaiter( object eventContainer, string eventName )
    {
        _eventContainer = eventContainer;
        _event = eventContainer.GetType().GetEvent( eventName );
    }

    public void WaitForEvent( TimeSpan timeout )
    {
        _event.AddEventHandler( _eventContainer, (Action)delegate { _autoResetEvent.Set(); } );
        _autoResetEvent.WaitOne( timeout );
    }
}

выход

// main thread started
// threaded work started
// threaded work complete
// work complete event fired
// main thread continues after waiting

Answer 5

Я думаю, что это должно работать, не пытался просто закодировать.

public class EventWaiter<T> where T : EventArgs
{
    private System.Threading.ManualResetEvent manualEvent;

    public EventWaiter(T e)
    {
        manualEvent = new System.Threading.ManualResetEvent(false);
        e += this.OnEvent;
    }

    public void OnEvent(object sender, EventArgs e)
    {
        manualEvent.Set();
    }

    public void WaitOne()
    {
        manualEvent.WaitOne();
    }

    public void Reset()
    {
        manualEvent.Reset();
    }
}

Не слишком много думал, но не могу понять, как сделать его изолированным от EventArgs.

Взгляните на MSDN ManualResetEvent , и вы обнаружите, что можете как-то связывать ожидания и некоторые странные вещи.