[#MVU] Unexpected custom control property value when bound to IListState model

[kucint]

Let's create a custom control that exposes two properties:

• MyValue of type int
• MyCollection of type IEnumerable. I use here IEnumerable rather than IList<string> due to following issue:
  [MVUX][C# Markup] Unable to bind Custom Control's Collection Dependency Property to consumer IListState<> #2311

All works fine, I am able to bind both properties in the consumer Frame, and both properties are working as expected:

public sealed partial class MainPage : Page
{
    public MainPage() => this
        .DataContext(new BindableMainPageModel(), (page, vm) => page
            .Background(ThemeResource.Get<Brush>("ApplicationPageBackgroundThemeBrush"))
            .Content(new StackPanel()
            .VerticalAlignment(VerticalAlignment.Center)
            .HorizontalAlignment(HorizontalAlignment.Center)
            .Children(
                new TextBlock()
                .Text("Hello Uno Platform!")
                .Margin(0, 0, 0, 20)
                .HorizontalAlignment(HorizontalAlignment.Center),
                new MyControl()
                .MyValue(() => vm.MyValue)
                .MyCollection(() => vm.MyCollection)
            ))
        );
}

internal partial record MainPageModel
{
    // value type property
    public IState<int> MyValue => State<int>.Value(this, () => 5);

    // reference type property
    public IListState<object> MyCollection => ListState<object>.Value(this, () =>
    [
        "Model Item 1",
        "Model Item 2",
        "Model Item 3",
        "Model Item 4",
        "Model Item 5",
    ]);
}

All good:

But,
Please have a closer look on content of both properties MyValue and MyCollection. Their behavior is inconsistent.

MyValue

Declared type of MyValue is int; so, it is expected that the type of value behind the property and the type of e.NewValue in OnMyValueChanged is int. The type should never be State<int>. Right?
And indeed, it is so:
The content of MyValue property is of type int, so it is e.NewValue.
The behavior is correct.

MyCollection
Declared type of MyCollection is IEnumerable; so, it is expected that the type of value behind the property and the type of e.NewValue in OnMyCollectionChanged is some kind of IEnumerable. The type should never be ListState<object>. Right?
Unfortunately, it is not so:

The content of MyCollection property is of type List<int> when it is initialized from within a control, but
it is set to IListState<object> when it comes from the MainPageModel

This is not expected behavior IMO....
have a look on code:

public sealed class MyControl : Control
{
    private static readonly MyStyle _defaultStyle = new MyStyle();

    public MyControl()
    {
        DefaultStyleKey = typeof(MyControl);
        Style = _defaultStyle;

        // initializing local instance of dependency property
        SetValue(MyCollectionProperty, new List<object>() { "initial a", "initial b" });
    }

    #region MyValue
    public int MyValue
    {
        get { return (int)GetValue(MyValueProperty); }
        set { SetValue(MyValueProperty, value); }
    }

    public static readonly DependencyProperty MyValueProperty =
        DependencyProperty.Register(
            nameof(MyValue),
            typeof(int),
            typeof(MyControl),
            new PropertyMetadata(
                -1,
                (s, e) => ((MyControl)s)?.OnMyValueChanged(e)));

    private void OnMyValueChanged(DependencyPropertyChangedEventArgs e)
    {
        // Declared type of MyValue is int,
        // so it is expected that the type of property and the type of e.NewValue is int
        // the type should never be State<int>
        //
        // Current behavior is correct:
        // The MyValue property is of type int, so it is e.NewValue

        Debug.WriteLine($"MyValue Changed              : from [{e.OldValue}] to [{e.NewValue}]");
        Debug.WriteLine($"MyValue Property actual type : {this.MyValue}");
        Debug.WriteLine($"NewValue actual type         : {e.NewValue.GetType()}");
        Debug.WriteLine("");
    }
    #endregion

    #region MyCollection
    public IEnumerable MyCollection
    {
        get { return (IEnumerable)GetValue(MyCollectionProperty); }
        set { SetValue(MyCollectionProperty, value); }
    }

    public static readonly DependencyProperty MyCollectionProperty =
        DependencyProperty.Register(
            nameof(MyCollection),
            typeof(IEnumerable),
            typeof(MyControl),
            new PropertyMetadata(
                new List<object>() { "default" }, // initializing static instance of dependency property
                (s, e) => ((MyControl)s)?.OnMyCollectionChanged(e)));

    private void OnMyCollectionChanged(DependencyPropertyChangedEventArgs e)
    {
        // Declared type of MyCollection is IEnumerable,
        // so it is expected that the type of property and the type of e.NewValue is "some" IEnumerable<object>
        // the type should never be ListState<object>
        //
        // Current behavior is not as expected:
        // The MyCollection property is of type List<int> when it is initialized from within a control, but
        // it is set to IListState<object> when it comes from the MainPageModel

        Debug.WriteLine($"MyCollection Changed              : from [{e.OldValue}] to [{e.NewValue}]");
        Debug.WriteLine($"MyCollection Property actual type : {this.MyCollection}");
        Debug.WriteLine($"NewValue actual type              : {e.NewValue.GetType()}");
        Debug.WriteLine("");
    }
    #endregion
}

Here you have Debug output that presents how values of MyValue changed:

MyValue Changed              : from [-1] to [0]
MyValue Property actual type : System.Int32
NewValue actual type         : System.Int32

MyValue Changed              : from [0] to [5]
MyValue Property actual type : System.Int32
NewValue actual type         : System.Int32

Here you have Debug output that presents how values of MyCollection changed:

MyCollection Changed              : from [System.Collections.Generic.List`1[System.Object]] to [System.Collections.Generic.List`1[System.Object]]
MyCollection Property actual type : System.Collections.Generic.List`1[System.Object]
NewValue actual type              : System.Collections.Generic.List`1[System.Object]

MyCollection Changed              : from [System.Collections.Generic.List`1[System.Object]] to [System.Collections.Generic.List`1[System.Object]]
MyCollection Property actual type : System.Collections.Generic.List`1[System.Object]
NewValue actual type              : System.Collections.Generic.List`1[System.Object]

MyCollection Changed              : from [System.Collections.Generic.List`1[System.Object]] to [Uno.Extensions.Reactive.Bindings.BindableListFeed`1[System.Object]]
MyCollection Property actual type : Uno.Extensions.Reactive.Bindings.BindableListFeed`1[System.Object]
NewValue actual type              : Uno.Extensions.Reactive.Bindings.BindableListFeed`1[System.Object]

You can see that MyCollection and e.NewValue have a type ListState while MyValue is always int

Question: Is is expected behavior?
I would expect that MyCollection is always of type IEnumerable...

repro: UnoInconsistentValueAndReferencePropertiesApp.zip

[kucint]

After further investigation, I think all is ok.
I will think about it again, and most probably I will delete this discussion completely
Sorry for the confusion.