Skip to content
The Chat Archive
claude-opus-4-20250514· Anthropic LMArena Human Preference 140K

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

  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. Assistant

    Yes, you can convert events to observables in Avalonia! For events like PointerMoved, you'll want to use Observable.FromEventPattern from Reactive Extensions. Here's how to do it in F# with FuncUI:

    open System
    open System.Reactive.Linq
    open Avalonia.Controls
    open Avalonia.Input
    
    // For a Canvas control
    let canvas = Canvas()
    
    // Convert PointerMoved event to an observable
    let pointerMovedObservable = 
        Observable.FromEventPattern<PointerEventArgs>(
            (fun handler -> canvas.PointerMoved.AddHandler(handler)),
            (fun handler -> canvas.PointerMoved.RemoveHandler(handler))
        )
    
    // Subscribe to the observable
    let subscription = 
        pointerMovedObservable
        |> Observable.subscribe (fun eventPattern ->
            let args = eventPattern.EventArgs
            let position = args.GetPosition(canvas)
            printfn "Pointer moved to: X=%f, Y=%f" position.X position.Y
        )
    

    In FuncUI, you might want to create this within your view function. Here's a more complete example:

    open Avalonia.FuncUI
    open Avalonia.FuncUI.DSL
    open Avalonia.FuncUI.Types
    
    let view =
        Component(fun ctx ->
            let pointerPosition = ctx.useState (0.0, 0.0)
            
            Canvas.create [
                Canvas.width 500.0
                Canvas.height 300.0
                Canvas.background "LightGray"
                
                Canvas.onPointerMoved (fun args ->
                    let pos = args.GetPosition(args.Source :?> Canvas)
                    pointerPosition.Set((pos.X, pos.Y))
                )
                
                Canvas.children [
                    TextBlock.create [
                        let x, y = pointerPosition.Current
                        TextBlock.text (sprintf "Position: %.1f, %.1f" x y)
                        Canvas.left 10.0
                        Canvas.top 10.0
                    ]
                ]
            ]
        )
    

    If you specifically need an observable for more complex reactive scenarios, you can create a custom hook:

    let usePointerMovedObservable (canvas: Canvas) =
        let observable = 
            Observable.FromEventPattern<PointerEventArgs>(
                (fun h -> canvas.PointerMoved.AddHandler(h)),
                (fun h -> canvas.PointerMoved.RemoveHandler(h))
            )
            |> Observable.map (fun e -> e.EventArgs.GetPosition(canvas))
        
        observable
    

    For FuncUI, the built-in event handlers like Canvas.onPointerMoved are usually the most straightforward approach, but observables give you access to all the powerful Rx operators for filtering, throttling, combining streams, etc.

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