如何弱地订阅事件/可观察对象

Question

我有一个类似静态的(发布者生命周期=应用程序生命周期)事件,我需要从视图中订阅.我无法可靠地确定何时导航视图(在Xamarin.Forms NavigationPage中按下导航栏后退按钮是一个示例),因此我无法确定视图何时应取消订阅observable.(我知道可以在OnAppearing/OnDisappearing中订阅/取消订阅,但是这会带来一系列问题,我不会在这里详细介绍.)

因此,我发现自己需要让视图对事件进行弱订阅,即允许视图被垃圾收集而不必取消订阅事件.理想情况下,我想要的东西可以沿着myObj.myEvent |> Observable.AsWeak |> Observable.Subscribe ...,或myObj.myEvent |> Observable.SubscribeWeakly ...,或简单地使用myObj.myEvent.SubscribeWeakly ....

不幸的是我不知道如何实现这一点.我听说过System.WeakReference类,但这对我来说都是新的,我不知道如何正确使用它 - 我见过的大多数例子对于我正在尝试做的事情似乎过于复杂,这意味着或者我想要一些不同的东西,或者表面下面还有比我怀疑的更多的陷阱.

如何在允许订阅者进行垃圾收集而不取消订阅的情况下订阅F#中的事件/可观察对象？

类似但不重复的问题:

• F#可观察事件是否消除,调解或与弱引用的需要无关？该问题询问F#中是否需要弱引用,而不是如何实现上述功能.在这方面,问题的唯一答案也没有帮助.

Answer 1

我已经得到了一个相对简单的函数，似乎可以正常工作，尽管我真的不知道我在做什么，所以我把它放在Code Review SE上。它基于 Samuel Jack 的Weak Events in .Net、简单方法以及 CodeProject 的Weak Events in C#中的解决方案 4 中的信息。

执行

module Observable =
    open System

    // ('a -> 'b -> unit) -> 'a -> IObservable<'b>
    let subscribeWeakly callback target source = 

        let mutable sub:IDisposable = null
        let mutable disposed = false
        let wr = new WeakReference<_>(target)

        let dispose() =
            lock (sub) (fun () -> 
                if not disposed then sub.Dispose(); disposed <- true)

        let callback' x =
            let isAlive, target = wr.TryGetTarget()
            if isAlive then callback target x else dispose()

        sub <- Observable.subscribe callback' source
        sub

使用示例

请参阅WeakSubscriber下面的类型。

重要的

您必须使用回调的me参数来调用相关方法。如果您this在回调内部使用，由于上述文章中描述的原因，您仍然会得到一个强有力的参考。出于同样的原因（我猜？），您无法在使用 定义的类中调用“普通”函数let。（但是，您可以将该方法定义为private。）

测试

辅助类：

type Publisher() =
    let myEvent = new Event<_>()
    [<CLIEvent>] member this.MyEvent = myEvent.Publish
    member this.Trigger(x) = myEvent.Trigger(x)


type StrongSubscriber() =

    member this.MyMethod x = 
        printfn "Strong: method received %A" x

    member this.Subscribe(publisher:Publisher) =
        publisher.MyEvent |> Observable.subscribe this.MyMethod
        publisher.MyEvent |> Observable.subscribe 
                             (fun x -> printfn "Strong: lambda received %A" x)


type WeakSubscriber() =

    member this.MyMethod x = 
        printfn "Weak: method received %A" x

    member this.Subscribe(publisher:Publisher) =
        publisher.MyEvent |> Observable.subscribeWeakly
                             (fun (me:WeakSubscriber) x -> me.MyMethod x) this
        publisher.MyEvent |> Observable.subscribeWeakly
                             (fun _ x -> printfn "Weak: lambda received %A" x) this

实际测试：

[<EntryPoint>]
let main argv = 

    let pub = Publisher()

    let doGc() =
        System.GC.Collect()
        System.GC.WaitForPendingFinalizers()
        System.GC.Collect()
        printfn "\nGC completed\n"

    let someScope() =
        let strong = StrongSubscriber()
        let weak = WeakSubscriber()
        strong.Subscribe(pub)
        weak.Subscribe(pub)

        doGc() // should not remove weak subscription since it's still in scope
        printfn "All subscribers should still be triggered:"
        pub.Trigger(1)

    someScope()

    doGc() // should remove weak subscriptions
    printfn "Weak subscribers should not be triggered:"
    pub.Trigger(2)

    System.Console.ReadKey() |> ignore

    0

输出：

GC completed

All subscribers should still be triggered:
Strong: method received 1
Strong: lambda received 1
Weak: method received 1
Weak: lambda received 1

GC completed

Weak subscribers should not be triggered:
Strong: method received 2
Strong: lambda received 2