在F＃中同時等待多個事件中的任何事件

Question

在F＃我知道如何異步等待一個事件中使用Async.AwaitEvent爲：

let test = async { 
    let! move = Async.AwaitEvent(form.MouseMove) 
    ...handle move... } 

假設我要等待要麼MouseMove或KeyDown事件。我想有這樣的事情：

let! moveOrKeyDown = Async.AwaitEvent(form.MouseMove, form.KeyDown) 

此功能不存在，但有另一種方法來做到這一點？

Answer 1

let ignoreEvent e = Event.map ignore e 

let merged = Event.merge (ignoreEvent f.KeyDown) (ignoreEvent f.MouseMove) 
Async.AwaitEvent merged 

編輯：另一個，可以保留原始類型

​​

編輯2版本：根據托馬斯Petricek的評論

let e1 = f.KeyDown |> Observable.map Choice1Of2 
let e2 = f.MouseMove |> Observable.map Choice2Of2 
let! evt = Observable.merge e1 e2 |> Async.AwaitObservable 

AwaitObservable primitiv e可以從here（Tomas Petricek的'Silverlight中的反應式演示'）中獲得。

Answer 2

您可以使用Event.map和Event.merge組合：

let eventOccurs e = e |> Event.map ignore 
let mouseOrKey = Event.merge (eventOccurs frm.MouseMove) (eventOccurs frm.KeyDown) 

然後你可以使用Async.AwaitEvent這一新的事件。如果MouseMove和KeyDown的類型相同，則可以跳過Event.map步驟，直接將其合併。

編輯

但在托馬斯指出，你應該使用偏好Observable組合子到Event的。

Answer 3

爲了理解發生了什麼，我查了一下Event.map，Event.merge和Choice的源代碼。

type Choice<'T1,'T2> = 
    | Choice1Of2 of 'T1 
    | Choice2Of2 of 'T2 

[<CompiledName("Map")>] 
let map f (w: IEvent<'Delegate,'T>) = 
    let ev = new Event<_>() 
    w.Add(fun x -> ev.Trigger(f x)); 
    ev.Publish 

[<CompiledName("Merge")>] 
let merge (w1: IEvent<'Del1,'T>) (w2: IEvent<'Del2,'T>) = 
    let ev = new Event<_>() 
    w1.Add(fun x -> ev.Trigger(x)); 
    w2.Add(fun x -> ev.Trigger(x)); 
    ev.Publish 

這意味着我們的解決方案正在創建3個新事件。

async { 
    let merged = Event.merge 
        (f.KeyDown |> Event.map Choice1Of2) 
        (f.MouseMove |> Event.map Choice2Of2) 
    let! move = Async.AwaitEvent merged 
} 

通過製作此庫代碼的緊密耦合版本，我們可以將其減少爲一個事件。

type EventChoice<'T1, 'T2> = 
    | EventChoice1Of2 of 'T1 
    | EventChoice2Of2 of 'T2 
    with 
    static member CreateChoice (w1: IEvent<_,'T1>) (w2: IEvent<_,'T2>) = 
     let ev = new Event<_>() 
     w1.Add(fun x -> ev.Trigger(EventChoice1Of2 x)) 
     w2.Add(fun x -> ev.Trigger(EventChoice2Of2 x)) 
     ev.Publish 

這裏是我們的新代碼。

async { 
    let merged = EventChoice.CreateChoice form.MouseMove form.KeyDown 
    let! move = Async.AwaitEvent merged 
} 

Answer 4

我用你的樣品在talk about reactive programming，我在倫敦使用方法的實現（沒有在頁面底部的下載鏈接）。如果你對這個話題感興趣，你可能會覺得這個講話很有用:-)。

我使用的版本採用IObservable而不是IEvent（所以方法的名稱是AwaitObservable）。有一些嚴重的內存泄露使用時Event.merge（從Event模塊等組合子）與AwaitEvent在一起，所以你應該使用Observable.merge等和AwaitObservable代替。

該問題更詳細地描述here（有關清晰示例，請參閱第3節）。簡而言之 - 當您使用Event.merge時，它將源處理程序附加到源事件（例如MouseDown），但在您使用AwaitEvent完成等待後，它不會刪除處理程序，因此事件永遠不會被刪除 - 如果您繼續等待循環編碼異步工作流程，您不斷添加新的處理程序（運行時不會執行任何操作）。

一個簡單的正確的解決方案（基於什麼德斯科公佈）應該是這樣的：

let rec loop() = async { 
    let e1 = f.KeyDown |> Observable.map Choice1Of2 
    let e2 = f.MouseMove |> Observable.map Choice2Of2 
    let! evt = Observable.merge e1 e2 |> Async.AwaitObservable 
    // ... 
    return! loop() } // Continue looping 

BTW：你可能也想看看this article（基於我的書第16章）。