поэтому мое требование состоит в том, чтобы моя функция ждала первого экземпляра event Action<T> приходит из другого класса и другого потока и обрабатывает его в моем потоке, позволяя ожиданию прерываться либо таймаутом, либо CancellationToken.

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

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

просто быть ясно, пример использования этой функции будет выглядеть следующим образом, где serialDevice выплевывает события в отдельный поток:

var eventOccurred = Helper.WaitForSingleEvent<StatusPacket>(
    cancellationToken,
    statusPacket => OnStatusPacketReceived(statusPacket),
    a => serialDevice.StatusPacketReceived += a,
    a => serialDevice.StatusPacketReceived -= a,
    5000,
    () => serialDevice.RequestStatusPacket());

Вариант 1-ManualResetEventSlim

этот вариант не плох, но Dispose обработка ManualResetEventSlim - это сложнее, чем кажется, что это должно быть. Это дает ReSharper fits, что я получаю доступ к измененным / размещенным вещам в закрытии, и действительно трудно следовать, поэтому я даже не уверен, что это правильно. Может быть, я что-то отсутствие этого может очистить это, что было бы моим предпочтением, но я не вижу этого сразу. Вот код.

public static bool WaitForSingleEvent<TEvent>(this CancellationToken token, Action<TEvent> handler, Action<Action<TEvent>> subscribe, Action<Action<TEvent>> unsubscribe, int msTimeout, Action initializer = null)
{
    var eventOccurred = false;
    var eventResult = default(TEvent);
    var o = new object();
    var slim = new ManualResetEventSlim();
    Action<TEvent> setResult = result => 
    {
        lock (o) // ensures we get the first event only
        {
            if (!eventOccurred)
            {
                eventResult = result;
                eventOccurred = true;
                // ReSharper disable AccessToModifiedClosure
                // ReSharper disable AccessToDisposedClosure
                if (slim != null)
                {
                    slim.Set();
                }
                // ReSharper restore AccessToDisposedClosure
                // ReSharper restore AccessToModifiedClosure
            }
        }
    };
    subscribe(setResult);
    try
    {
        if (initializer != null)
        {
            initializer();
        }
        slim.Wait(msTimeout, token);
    }
    finally // ensures unsubscription in case of exception
    {
        unsubscribe(setResult);
        lock(o) // ensure we don't access slim
        {
            slim.Dispose();
            slim = null;
        }
    }
    lock (o) // ensures our variables don't get changed in middle of things
    {
        if (eventOccurred)
        {
            handler(eventResult);
        }
        return eventOccurred;
    }
}

Вариант 2-опрос без WaitHandle

на WaitForSingleEvent функция здесь намного чище. Я могу использовать ConcurrentQueue и при этом даже не нужен замок. Но мне просто не нравится функция опроса Sleep, и я не вижу никакого способа обойти это с помощью этого подхода. Я хотел бы пройти в WaitHandle вместо Func<bool> очистить Sleep, но во-вторых, у меня есть все Dispose бардак разгребать.

public static bool WaitForSingleEvent<TEvent>(this CancellationToken token, Action<TEvent> handler, Action<Action<TEvent>> subscribe, Action<Action<TEvent>> unsubscribe, int msTimeout, Action initializer = null)
{
    var q = new ConcurrentQueue<TEvent>();
    subscribe(q.Enqueue);
    try
    {
        if (initializer != null)
        {
            initializer();
        }
        token.Sleep(msTimeout, () => !q.IsEmpty);
    }
    finally // ensures unsubscription in case of exception
    {
        unsubscribe(q.Enqueue);
    }
    TEvent eventResult;
    var eventOccurred = q.TryDequeue(out eventResult);
    if (eventOccurred)
    {
        handler(eventResult);
    }
    return eventOccurred;
}

public static void Sleep(this CancellationToken token, int ms, Func<bool> exitCondition)
{
    var start = DateTime.Now;
    while ((DateTime.Now - start).TotalMilliseconds < ms && !exitCondition())
    {
        token.ThrowIfCancellationRequested();
        Thread.Sleep(1);
    }
}

вопрос

я не особенно забочусь о любом из этих решений, и я не уверен на 100%, что любой из них на 100% правильный. Является ли одно из этих решений лучше другого (идиоматичность, эффективность и т. д.), Или есть более простой способ или встроенная функция для удовлетворения того, что мне нужно сделать здесь?

Update: лучший ответ до сих пор

модификация TaskCompletionSource Решение ниже. Никаких затворов, замков или чего-либо еще. Выглядит довольно просто. Есть ошибки?

public static bool WaitForSingleEvent<TEvent>(this CancellationToken token, Action<TEvent> onEvent, Action<Action<TEvent>> subscribe, Action<Action<TEvent>> unsubscribe, int msTimeout, Action initializer = null)
{
    var tcs = new TaskCompletionSource<TEvent>();
    Action<TEvent> handler = result => tcs.TrySetResult(result);
    var task = tcs.Task;
    subscribe(handler);
    try
    {
        if (initializer != null)
        {
            initializer();
        }
        task.Wait(msTimeout, token);
    }
    finally
    {
        unsubscribe(handler);
        // Do not dispose task http://blogs.msdn.com/b/pfxteam/archive/2012/03/25/10287435.aspx
    }
    if (task.Status == TaskStatus.RanToCompletion)
    {
        onEvent(task.Result);
        return true;
    }
    return false;
}

Update 2: Еще одно отличное решение

получается, что BlockingCollection работает так же, как ConcurrentQueue но также имеет методы принятия тайм-аут и токен отмены. Одна хорошая вещь об этом решении заключается в том, что его можно обновить, чтобы сделать WaitForNEvents довольно легко:

public static bool WaitForSingleEvent<TEvent>(this CancellationToken token, Action<TEvent> handler, Action<Action<TEvent>> subscribe, Action<Action<TEvent>> unsubscribe, int msTimeout, Action initializer = null)
{
    var q = new BlockingCollection<TEvent>();
    Action<TEvent> add = item => q.TryAdd(item);
    subscribe(add);
    try
    {
        if (initializer != null)
        {
            initializer();
        }
        TEvent eventResult;
        if (q.TryTake(out eventResult, msTimeout, token))
        {
            handler(eventResult);
            return true;
        }   
        return false;
    }
    finally
    {
        unsubscribe(add);
        q.Dispose();
    }
}