OneCore.Net.WPF.Navigation 1.0.1

OneCore.Net.WPF.Navigation Library

Overview

OneCore.Net.WPF.Navigation is a library that provides helpers for seamless navigation, message box display, dialog management, and more within WPF applications.

Features

• INavigationService: The main interface which brings all together. Display dialogs, windows, user controls, calls the ILoader and IEditable. The single point of entry to do anything in regard of navigation.
• Use alltogether or stand alone: Objects like the IDialogProvider or IMessageBoxProvider or IWindowProvider can be used stand alone even when give into a INavigationService.
• Browse for files and folders: Using the IDialogProvider any system dialog, browse folder, save file, open file, can be used out of ViewModels.
• Show message boxes: Using the IMessageBoxProvider any kind of message boxes can be used out of ViewModels.
• Maintain windows: Using the IWindowProvider you can create new and get existing windows (and user controls).
• Host single user controls: Using the SingleNavigationPresenter out of ViewModels UserControls can be displayed and replaced on the UI.
• Host stacked user controls: Using the StackedNavigationPresenter out of ViewModels UserControls can be added and removed on the UI.
• Async ctor: Using the INavigationService each ViewModel can implement the ILoader to have an async constructor in the ViewModel, called each time its UI element gets shown.
• Leave prevention: Using the INavigationService each ViewModel can implement the IEditable to get informed if the user tries to close a window and it can be prevented like user have to save changes first and stuff like that.

Getting Started

1. Installation:

   • Install the OneCore.Net.WPF.Navigation library via NuGet Package Manager:

   dotnet add package OneCore.Net.WPF.Navigation
   

2. INavigationService:

   public void Bootstrapper
   {
       IUnityContainer _unityContainer;
   
       public Bootstrapper()
       {
           _unityContainer = new UnityContainer();
           _unityContainer.RegisterSingleton<IWindowProvider, WindowProvider>();
           _unityContainer.RegisterSingleton<INavigationPresenterProvider, NavigationPresenterProvider>();
           _unityContainer.RegisterType<IDialogProvider, DialogProvider>();
           _unityContainer.RegisterType<IMessageBoxProvider, MessageBoxProvider>();
           _unityContainer.RegisterType<INavigationService, NavigationService>();
   
           RegisterViews();
       }
   
       public void RegisterViews()
       {
           var windowProvider = (WindowProvider)_unityContainer.Resolve<IWindowProvider>();
   
           windowProvider.RegisterWindow<MainView>("MainView");
           windowProvider.RegisterWindow<SubView>("SubView");
   
           windowProvider.RegisterControl<DialogsView>("DialogsView");
           windowProvider.RegisterControl<DisplayControlView>("DisplayControlView");
       }
   }
   

   public class WindowViewModel : ObservableObject, ILoader
   {
       public async Task Load()
       {
           // Loads the data as soon the window got shown.
           await Task.CompletedTask;
       }
   }
   

   public void ViewModel : ObservableObject
   {
       private INavigationService _navigationService;
   
       public ViewModel(INavigationService navigationService)
       {
           _navigationService = navigationService;
       }
   
       public async Task ShowWindow()
       {
           var vm = new WindowViewModel();
           await _navigationService.ShowModalWindow("MainView", vm);
       }
   }
   

   [TestFixture]
   public class ViewModelTests
   {
       private Mock<INavigationService> _navigationService;
       private ViewModel _target;
   
       [SetUp]
       public void Setup()
       {
           _navigationService = new Mock<INavigationService>();
           _target = new ViewModel(_navigationService.Object);
       }
   
       [Test]
       public void ShowWindow_Called_ShowsTheWindow()
       {
           _target.ShowWindow();
   
           _navigationService.Verify(x => x.ShowModalWindow(Args.Any<string>(), Args.Any<object>()), Times.Once);
       }
   }
   

3. Browse for files and folders:

   public class ViewModel : ObservableObject
   {
       private IDialogProvider _dialogProvider;
   
       public ViewModel(IDialogProvider dialogProvider)
       {
           _dialogProvider = dialogProvider;
       }
   
       public string GetFile()
       {
           var data = new OpenFileData
           {
               CheckFileExists = true,
               MultiSelect = false
           };
   
           if (_dialogProvider.Show(data))
               return data.FileName;
   
           return null;
       }
   }
   

   [TestFixture]
   public class ViewModelTests
   {
       private Mock<IDialogProvider> _dialogProvider;
       private ViewModel _target;
   
       [SetUp]
       public void Setup()
       {
           _dialogProvider = new Mock<IDialogProvider>();
           _target = new ViewModel(_dialogProvider.Object);
       }
   
       [Test]
       public void GetFile_Called_ReturnsTheUserSelectedFile()
       {
           _dialogProvider.Setup(x => x.Show(Arg.Any<IOpenFileData>())
               .Callback(e => e.FileName = "filename")
               .Returns(true);
   
           var result = _target.GetFile();
   
           Assert.That(result, Is.EqualTo("filename"));
       }
   }
   

4. Show message boxes:

   public class ViewModel : ObservableObject
   {
       private IMessageBoxProvider _messageBoxProvider;
   
       public ViewModel(IMessageBoxProvider messageBoxProvider)
       {
           _messageBoxProvider = messageBoxProvider;
       }
   
       public bool ShallDeleteFile()
       {
           var result = _messageBoxProvider.Show("Do you want to delete the file?", "Question", MessageBoxButton.YesNo);
           return result == MessageBoxResult.Yes;
       }
   }
   

   public class ViewModelTests
   {
       private Mock<IMessageBoxProvider> _messageBoxProvider;
       private ViewModel _target;
   
       [SetUp]
       public void Setup()
       {
           _messageBoxProvider = new Mock<IMessageBoxProvider>();
           _target = new ViewModel(_messageBoxProvider.Object);
       }
   
       [Test]
       public void ShallDeleteFile_UserConfirmed_ReturnsTrue()
       {
           _messageBoxProvider.Setup(x => x.Show(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<MessageBoxButton>())
               .Returns(MessageBoxResult.Yes);
   
           var result = _target.ShallDeleteFile();
   
           Assert.That(result, Is.True);
       }
   
       [Test]
       public void ShallDeleteFile_UserRejected_ReturnsTrue()
       {
           _messageBoxProvider.Setup(x => x.Show(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<MessageBoxButton>())
               .Returns(MessageBoxResult.No);
   
           var result = _target.ShallDeleteFile();
   
           Assert.That(result, Is.False);
       }
   }
   

5. Maintain windows:

   public class Bootstrapper
   {
       public Bootstrapper()
       {
           _container = new UnityContainer();
           _container.RegisterSingleton<IWindowProvider, WindowProvider>();
       }
   
       public void Startup()
       {
           var provider = (WindowProvider)_container.Resolve<IWindowProvider>();
           provider.Register<MainView>("MainView");
       }
   }
   

   public class ViewModel : ObservableObject
   {
       private IWindowProvider _windowProvider;
   
       public ViewModel(IWindowProvider windowProvider)
       {
           _windowProvider = windowProvider;
       }
   
       public void Show(object viewModel)
       {
           var window = _windowProvider.GetNewWindow("MainView");
           window.DataContext = viewModel;
           window.ShowDialog();
       }
   }
   

6. Host single user controls:

   <Window>
       <onecore:SingleNavigationPresenter ID="MainSpot" />
   </Window>
   

   public class ViewModel : ObservableObject
   {
       private INavigationService _navigationService;
   
       public ViewModel(INavigationService navigationService)
       {
           _navigationService = navigationService;
       }
   
       public async Task SwitchAsync()
       {
           var vm = new ControlViewModel();
           // "Control" is the user control registered in the IWindowService for the INavigationService.
           await _navigationService.ShowControl("MainSpot", "Control", vm);
       }
   }
   

7. Host stacked user controls:

   <Window>
       <onecore:StackedNavigationPresenter Strategy="Overlapping" ID="MainSpot" />
   </Window>
   

   public class ViewModel : ObservableObject
   {
       private INavigationService _navigationService;
   
       public ViewModel(INavigationService navigationService)
       {
           _navigationService = navigationService;
       }
   
       public async Task SwitchAsync()
       {
           var vm = new ControlViewModel();
           // "Control" is the user control registered in the IWindowService for the INavigationService.
           await _navigationService.ShowControl("MainSpot", "Control", vm);
       }
   }
   

8. Async ctor:

   public class WindowViewModel : ObservableObject, ILoader
   {
       public async Task Load()
       {
           // Loads the data as soon the window got shown.
           await Task.CompletedTask;
       }
   }
   

9. Leave prevention:

   public class WindowViewModel : ObservableObject, IEditable
   {
       public async Task<bool> TryLeave()
       {
           // Check for data be saved.
           await Task.CompletedTask;
           return true;
       }
   }
   

Links

• NuGet
• GitHub

License

Copyright (c) David Wendland. All rights reserved. Licensed under the MIT License. See LICENSE file in the project root for full license information.