Skip to content
TheChatArchiveThe Chat Archive
Claudeclaude-sonnet-4-20250514· AnthropicHugging Face LMArena Human Preference 140K

Subscribing to Changes to a Property You can subscribe to changes on a property by…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Claudeclaude-opus-4-20250514’s answer.
  1. User

    Subscribing to Changes to a Property You can subscribe to changes on a property by calling the GetObservable method. This returns an IObservable which can be used to listen for changes to the property:

    var textBlock = new TextBlock(); var text = textBlock.GetObservable(TextBlock.TextProperty);

    Each property that can be subscribed to has a static readonly field called [PropertyName]Property which is passed to GetObservable in order to subscribe to the property's changes.

    IObservable (part of Reactive Extensions, or rx for short) is out of scope for this guide, but here's an example which uses the returned observable to print a message with the changing property values to the console:

    var textBlock = new TextBlock(); var text = textBlock.GetObservable(TextBlock.TextProperty); text.Subscribe(value => Console.WriteLine(value + " Changed"));

    this text is from avalonia documentation, but i want to do a similar thing and create an observable from the Canvas and and event PointerMoved. The example is just showing a normal text property of a control and not an event. Is there a way to convert an event into an observable? also, i am using funcUI and F# fsharp.

  2. Claude Assistant

    Yes, you can definitely convert events into observables! There are several ways to do this in F# with Reactive Extensions. Here are the main approaches:

    Using Observable.fromEvent

    The most straightforward way is using Observable.fromEvent from F#'s Observable module:

    open System.Reactive.Linq
    open Avalonia.Controls
    open Avalonia.Input
    
    let canvas = Canvas()
    
    // Convert PointerMoved event to observable
    let pointerMovedObservable = 
        Observable.fromEvent<PointerEventHandler, PointerEventArgs>
            (fun handler -> PointerEventHandler(handler))
            (fun handler -> canvas.PointerMoved.AddHandler(handler))
            (fun handler -> canvas.PointerMoved.RemoveHandler(handler))
    
    // Subscribe to the observable
    pointerMovedObservable
    |> Observable.subscribe (fun args -> 
        printfn "Pointer moved to: %f, %f" args.GetPosition(canvas).X args.GetPosition(canvas).Y)
    |> ignore
    

    Using Observable.FromEventPattern (System.Reactive)

    If you're using System.Reactive (Rx.NET), you can use FromEventPattern:

    open System.Reactive.Linq
    
    let canvas = Canvas()
    
    let pointerMovedObservable = 
        Observable.FromEventPattern<PointerEventHandler, PointerEventArgs>(
            (fun h -> canvas.PointerMoved.AddHandler(h)),
            (fun h -> canvas.PointerMoved.RemoveHandler(h))
        )
        |> Observable.map (fun eventPattern -> eventPattern.EventArgs)
    
    pointerMovedObservable
    |> Observable.subscribe (fun args -> 
        printfn "Pointer moved to: %f, %f" args.GetPosition(canvas).X args.GetPosition(canvas).Y)
    |> ignore
    

    In FuncUI Context

    Since you're using FuncUI, you might want to integrate this within your component. Here's how you could do it:

    open Avalonia.FuncUI.DSL
    open Avalonia.FuncUI.Types
    open System.Reactive.Linq
    
    let canvasWithPointerTracking () =
        Component(fun ctx ->
            let canvas = Canvas()
            
            // Create observable from PointerMoved event
            let pointerMovedObservable = 
                Observable.FromEventPattern<PointerEventHandler, PointerEventArgs>(
                    (fun h -> canvas.PointerMoved.AddHandler(h)),
                    (fun h -> canvas.PointerMoved.RemoveHandler(h))
                )
                |> Observable.map (fun ep -> ep.EventArgs)
            
            // Subscribe to handle pointer movements
            let subscription = 
                pointerMovedObservable
                |> Observable.subscribe (fun args -> 
                    let pos = args.GetPosition(canvas)
                    printfn "Mouse at: %f, %f" pos.X pos.Y)
            
            // Clean up subscription when component is disposed
            ctx.useEffect((fun () -> 
                { new System.IDisposable with 
                    member _.Dispose() = subscription.Dispose() }), [])
            
            Canvas.create [
                Canvas.background "LightBlue"
                Canvas.width 400
                Canvas.height 300
            ]
        )
    

    The key difference from the property observable example is that events need to be converted to observables first, while properties in Avalonia already have built-in observable support through GetObservable. The Observable.fromEvent or Observable.FromEventPattern functions handle the conversion from the event pattern to the observable pattern.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.