Disposal of views

[penenkel]

Does Avalonia provide a concept for disposing views? That is, is there any point where I can actively call view.Dispose() (assuming of cause the view implements IDisposable)?

Consider the following scenario: A ParentView with a nested ChildView. The resolution/creation of the ChildView is done via the usual Avalonia ViewLocator: IDataTemplate. That means that the ViewLocator is the creator of the ChildView, as such it should also be responsible for its disposal. Unfortunately it seems that this is not supported, as IDataTemplate.Build is only called for the new content. I'm not even sure if it would make much sense, as the DataTemplate does not consider or track individual instances of view and view-models but instead operates on their types, of which there could potentially may instances.

Or is my entire idea of explicitly controlling the lifecycle of views flawed? Should I instead consider each view a Singelton and use ReactivUIs WhenActivated to control the lifecycle of dependencies?

[kekekeks]

Controls are .NET objects and don't hold any native resources. Therefore, there is nothing to dispose. If your control needs to manage some native resource, either handle AttachedTo/DetachedFromVisualTree callbacks (or WhenActivated if you use ReactiveUI) or implement your own lifetime management.

[penenkel]

Thank you for your insight. And even more for your outstanding work on this framework.

I have been trying to implement my own lifetime management for my views, but I have trouble envisioning how to integrate it with the IDataTemplate approach of creating sub-views. I do not see a way to intercept the decommissioning process for a view. I'm not even sure there is one. Do you have a suggestion how to approach this?

[kekekeks]

Since there is no disposal, you can only track view visual tree attachment and its data context. i. e.:
View is attached to visual tree and has DataContext: view is active
View is not attached to visual tree or has no DataContext: view is not active

So if you need to take action on view deactivation, wait for it to become inactive.
Note that visual tree detachment might be temporary in case of view recycling during virtualization or view hierarchy reparenting

[workgroupengineering]

You can implemet code like this:

changed the code according to @kekekeks suggestions

     public interface IView
    {

    }

    public interface IViewModelLifetime
    {
        bool IsLoaded { get; }
        void Loaded(IView view);
        void Unlaoded(IView view);
    }

    class BaseView : UserControl, IView
    {

        protected override void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e)
        {
            base.OnAttachedToVisualTree(e);
            if (DataContext is IViewModelLifetime lifetime && !lifetime.IsLoaded)
            {
                lifetime.Loaded(this);
            }
        }

        protected override void OnDetachedFromVisualTree(VisualTreeAttachmentEventArgs e)
        {
            if (DataContext is IViewModelLifetime lifetime && lifetime.IsLoaded)
            {
                lifetime.Unlaoded(this);
            }
            base.OnDetachedFromVisualTree(e);
        }

        protected override void OnPropertyChanged<T>(AvaloniaPropertyChangedEventArgs<T> change)
        {
            if (change.Property == DataContextProperty)
            {
                if (change.OldValue is IViewModelLifetime oldvm && oldvm.IsLoaded)
                {
                    oldvm.Unlaoded(this);
                }
                if (change.NewValue is IViewModelLifetime newvm && !newvm.IsLoaded)
                {
                    newvm.Loaded(this);
                }
            }
            base.OnPropertyChanged(change);
        }
    }

[kekekeks]

@workgroupengineering this code doesn't take view recycling into account. One need to handle DataContext changes too.

[penenkel]

If I understand you correctly @kekekeks then there simply is no way for me to know if a view will never be used again. All I can do is track if it is attached or not and react accordingly. For final cleanup I have to rely on the garbage collector to do its thing. As such I will never be able to implement IDisposable directly on a view because I cannot know when to call Dispose. As such I should forget about controlling the lifecycle of views and simply consider them transient with no clean end or singleton and potentially living forever. And if I have to manage resources like observable subscriptions I have to add/terminate those on attachment/detatchemnt to the visual tree.

@workgroupengineering Thank you, this looks like a fine alternative to the ReactiveUI-WhenActivated approach. To be honest I find myself trying to avoid ReactiveUI where I can, because it seems so ... opinionated.