Began porting my MultiPageViewModel from the Windows Forms library to the Avalonia library; updated copyright statement for the year 2026

Source/ViewModels/MultiPageViewModel.cs

@@ -0,0 +1,164 @@
+#region Apache License 2.0
+/*
+Nuclex Foundation libraries for .NET
+Copyright (C) 2002-2026 Markus Ewald / Nuclex Development Labs
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+#endregion // Apache License 2.0
+
+using System;
+using System.Collections.Concurrent;
+using System.Threading.Tasks;
+
+using Nuclex.Avalonia.Commands;
+using Nuclex.Support;
+
+namespace Nuclex.Avalonia.ViewModels {
+
+  /// <summary>Base class for view models that have multiple child view models</summary>
+  /// <typeparam name="TPageEnumeration">Enum type by which pages can be indicated</typeparam>
+  public abstract class MultiPageViewModel<TPageEnumeration> :
+    Observable, IMultiPageViewModel<TPageEnumeration>, IDisposable {
+
+    /// <summary>Initializes a new multi-page view model</summary>
+    /// <param name="windowManager">
+    ///   Window manager the view model uses to create child views
+    /// </param>
+    /// <param name="cachePageViewModels">
+    ///   Whether child view models will be kept alive and reused
+    /// </param>
+    public MultiPageViewModel(IWindowManager windowManager, bool cachePageViewModels = false) {
+      this.windowManager = windowManager;
+      this.createViewModelForPageDelegate = (
+        new Func<TPageEnumeration, object>(CreateViewModelForPage)
+      );
+
+      if(cachePageViewModels) {
+        this.cachedViewModels = new ConcurrentDictionary<TPageEnumeration, object>();
+      }
+
+      SwitchPageCommand = new AsyncRelayCommand<TPageEnumeration>(switchPageAsync);
+    }
+
+    /// <summary>Command to switch the active view</summary>
+    public IAsyncCommand<TPageEnumeration> SwitchPageCommand { get; }
+
+    /// <summary>Immediately releases all resources owned by the instance</summary>
+    public virtual void Dispose() {
+
+      // If view models are being cached, simply dispose anything in the cache that
+      // implements IDisposable, the active view will be part of the cache.
+      if(this.cachedViewModels != null) {
+        foreach(object cacheViewModel in this.cachedViewModels.Values) {
+          disposeIfSupported(cacheViewModel);
+        }
+        this.activePageViewModel = null;
+
+        this.cachedViewModels.Clear();
+      } else if(this.activePageViewModel != null) { // No cache? Dispose active view.
+        disposeIfSupported(this.activePageViewModel);
+        this.activePageViewModel = null;
+      }
+
+    }
+
+    /// <summary>Child page that is currently being displayed by the view model</summary>
+    public TPageEnumeration? ActivePage {
+      get { return this.activePage; }
+    }
+
+    /// <summary>Retrieves (and, if needed, creates) the view model for the active page</summary>
+    /// <returns>A view model for the active page on the multi-page view model</returns>
+    public object? ActivePageViewModel {
+      get { return this.activePageViewModel; }
+    }
+
+
+    /// <summary>Windowmanager that can create view models and display other views</summary>
+    protected IWindowManager WindowManager {
+      get { return this.windowManager; }
+    }
+
+    /// <summary>Creates a view model for the specified page</summary>
+    /// <param name="page">Page for which a view model will be created</param>
+    /// <returns>The view model for the specified page</returns>
+    protected abstract object CreateViewModelForPage(TPageEnumeration page);
+
+    /// <summary>Switches to another page</summary>
+    /// <param name="newPage">New page to switch to</param>
+    /// <returns>A task that will finish when the new page has been switched to</returns>
+    private Task switchPageAsync(TPageEnumeration? newPage) {
+      if(newPage.Equals(this.activePage)) {
+        return Task.CompletedTask;
+      }
+
+      object? viewModelToDispose;
+      if(this.cachedViewModels == null) {
+        viewModelToDispose = this.activePageViewModel;
+
+        object? newPageViewModel = CreateViewModelForPage(newPage);
+
+        this.activePage = newPage;
+        this.activePageViewModel = newPageViewModel;
+      } else {
+        viewModelToDispose = null;
+
+        // Double-checked locking to avoid creating a view model for the same page
+        // multiple times if the construction takes time
+        object newPageViewModel;
+        if(!this.cachedViewModels.TryGetValue(newPage, out newPageViewModel)) {
+          lock(this.cachedViewModels) {
+            if(!this.cachedViewModels.TryGetValue(newPage, out newPageViewModel)) {
+              newPageViewModel = CreateViewModelForPage(newPage);
+              this.cachedViewModels.TryAdd(newPage, newPageViewModel);
+            }
+          }
+        }
+
+        this.activePage = newPage;
+        this.activePageViewModel = newPageViewModel;
+      }
+
+      OnPropertyChanged(nameof(ActivePage));
+      OnPropertyChanged(nameof(ActivePageViewModel));
+
+      disposeIfSupported(viewModelToDispose);
+
+      return Task.CompletedTask;
+    }
+
+    /// <summary>Disposes the specified object if it is disposable</summary>
+    /// <param name="potentiallyDisposable">Object that will be disposed if supported</param>
+    private static void disposeIfSupported(object? potentiallyDisposable) {
+      var disposable = potentiallyDisposable as IDisposable;
+      if(disposable != null) {
+        disposable.Dispose();
+      }
+    }
+
+    /// <summary>Window manager that can be used to display other views</summary>
+    private readonly IWindowManager windowManager;
+    /// <summary>Delegate for the CreateViewModelForPage() method</summary>
+    private readonly Func<TPageEnumeration, object> createViewModelForPageDelegate;
+    /// <summary>Cached page view models, if caching is enabled</summary>
+    private readonly ConcurrentDictionary<TPageEnumeration, object>? cachedViewModels;
+
+    /// <summary>Page that is currently active in the multi-page view model</summary>
+    private TPageEnumeration activePage;
+    /// <summary>View model for the active page</summary>
+    private object? activePageViewModel;
+
+  }
+
+} // namespace Nuclex.Avalonia.ViewModels