- Understanding the Threading Model for Universal Apps
- Displaying Multiple Windows
- Navigating Between Pages
- Summary
This chapter is from the book
This chapter is from the book
This chapter is from the book
Displaying Multiple Windows
Universal apps, even when running on Windows 8.1, are hosted in a window. Not only that, but an app running on a PC can use multiple windows simultaneously. Although they are called windows in XAML-specific APIs, windows are often called views in Windows Runtime APIs. In Windows Runtime terminology, a view is the union of a window and its UI thread.
Apps show a primary window when activated, but you can create and show any number of secondary windows on a PC. You create a secondary window by calling CoreApplicationView.CreateNewView. This returns a CoreApplicationView instance representing the new window and its UI thread, but you can’t interact with it yet. You must wait for Application.OnWindowCreated to be called, which occurs on the new UI thread. On this thread, you can initialize the window much like you would initialize your primary window. Once it is initialized, you can show it with a PC-only ApplicationViewSwitcher class—back on the original UI thread.
Because of the convoluted control flow, this is a perfect opportunity to use the TaskCompletionSource type mentioned earlier in this chapter. Listing 7.1 adds an await-friendly CreateWindowAsync method to App.xaml.cs, inspired by the Multiple Views Sample project provided by the Windows SDK. This portion of the code compiles for both PC and phone.
LISTING 7.1 App.xaml.cs: Providing an await-Friendly CreateWindowAsync Method
usingSystem;usingSystem.Collections.Concurrent;usingSystem.Threading.Tasks;usingWindows.ApplicationModel;usingWindows.ApplicationModel.Activation;usingWindows.ApplicationModel.Core;usingWindows.UI.Xaml;usingWindows.UI.Xaml.Controls;namespaceMultipleWindows {sealed partial class{App:Application{// The pending tasks created by CreateWindowAsyncConcurrentQueue<TaskCompletionSource<Window>> taskWrappers =newConcurrentQueue<TaskCompletionSource<Window>>();// Create a new window.// This wrapper method enables awaiting.publicTask<Window> CreateWindowAsync()// Create a Task that the caller can awaitTaskCompletionSource<Window> taskWrapper =newTaskCompletionSource<Window>();this.taskWrappers.Enqueue(taskWrapper);// Create the secondary window, which calls Application.OnWindowCreated// on its own UI threadCoreApplication.CreateNewView(null,null);// Return the TaskreturntaskWrapper.Task; }protected override voidOnWindowCreated(WindowCreatedEventArgsargs) {CoreApplicationViewview =CoreApplication.GetCurrentView();if(!view.IsMain) {// This is a secondary window, so mark the in-progress Task as complete// and "return" the relevant XAML-specific Window objectTaskCompletionSource<Window> taskWrapper;if(!taskWrappers.TryDequeue(outtaskWrapper) || !taskWrapper.TrySetResult(args.Window)) taskWrapper.SetException(newInvalidOperationException()); } } ... } }
The code inside OnWindowCreated can easily check whether it is being invoked for the main window or a secondary window by obtaining the current CoreApplicationView and examining its IsMain property.
Listing 7.2 shows the code-behind for the following MainPage.xaml that leverages CreateWindowAsync to show a new window every time its Button is clicked:
<Pagex:Class="MultipleWindows.MainPage"...><Viewbox><ButtonClick="Button_Click">Show a New Window</Button></Viewbox></Page>
LISTING 7.2 MainPage.xaml.cs: Using CreateWindowAsync to Create Then Show a New Window
usingSystem;usingWindows.UI.Core;usingWindows.UI.ViewManagement;usingWindows.UI.Xaml;usingWindows.UI.Xaml.Controls;namespaceMultipleWindows {public sealed partial classMainPage:Page{publicMainPage() { InitializeComponent(); }async voidButton_Click(objectsender,RoutedEventArgse) {intnewWindowId = 0;// Create the new window with our handy helper methodWindownewWindow =await(App.CurrentasApp).CreateWindowAsync();// Initialize the new window on its UI thread{awaitnewWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>// In this context, Window.Current is the new window.// Navigate its content to a different page.Frameframe =newFrame();frame.Navigate(typeof(SecondPage));Window.Current.Content = frame;// Set a different titleApplicationView.GetForCurrentView().Title ="NEW"; newWindowId =ApplicationView.GetApplicationViewIdForWindow( newWindow.CoreWindow); });// Back on the original UI thread, show the new window alongside this one// (PC only)boolsuccess =} } }awaitApplicationViewSwitcher.TryShowAsStandaloneAsync(newWindowId);
Once Button_Click retrieves the new Window instance, which actually came from App’s OnWindowCreated method, it can schedule its initialization on its UI thread. It awaits this work’s completion, because the next step requires a window ID that must be retrieved from that window’s UI thread. With the ID, the original code can then call ApplicationViewSwitcher.TryShowAsStandaloneAsync to show the new window.
Each new window is a top-level window to be managed by the user, just like the app’s main window. TryShowAsStandaloneAsync has overloads that enable you to specify a ViewSizePreference for the target window or for both windows, just like when launching an app. You can also swap one window with another in-place by calling SwitchAsync instead of TryShowAsStandaloneAsync.
For several Windows Runtime classes, you obtain an instance by calling their static GetForCurrentView methods. Such objects are designed to have a single instance per window. In other words, they are not agile. If you have multiple windows, you should make sure to use the appropriate instance from each UI thread.