Update 2017/10/15: This walk through is now available as a Visual Studio Template! More details here: https://marketplace.visualstudio.com/items?itemName=BryanBCook.XamarinFormsCaliburnMicroStarterKit
This is the fourth post in this series where we’re configuring a Xamarin.Forms application to use my favourite MVVM framework, Caliburn.Micro. Today’s post will focus on configuring a Universal Windows Application (UWP).
Here’s links to the previous posts:
- Getting Started with Xamarin.Forms and Caliburn.Micro
- Configuring Xamarin.Forms.Droid to use Caliburn.Micro
- Configuring Xamarin.Forms.iOS to use Caliburn.Micro
If you’ve ever built a WPF application, it may seem strange that we’re not going to build XAML pages for our app. Instead, we’re going to leverage the XAML defined in our PCL so that we can reuse as much of the user-interface logic as possible. The pages that we’re adding here act purely as an entry point into our Xamarin.Forms application.
Change App.xaml
Caliburn provides a base application class that we’re going to extend. In our App.xaml, we’ll change the root element to CaliburnApplication, like so:
<cm:CaliburnApplication
x:Class="XF.CaliburnMicro1.UWP.App"
xmlns:cm="using:Caliburn.Micro"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
RequestedTheme="Light">
</cm:CaliburnApplication>
Configure IoC Container
Next we’ll add the plumbing logic that we’ve added to the other applications to initialize our platform-specific IoC container. Caliburn.Micro has a customized container for UWP, called WinRTContainer, that contains a few helpful registration methods.
I’ve replaced the default App.xaml.cs with this simplified version:
namespace XF.CaliburnMicro1.UWP
{
using System;
using System.Collections.Generic;
using System.Reflection;
using Windows.ApplicationModel.Activation;
using Caliburn.Micro;
using XF.CaliburnMicro1.ViewModels;
sealed partial class App
{
private WinRTContainer _container;
public App()
{
InitializeComponent();
}
protected override void Configure()
{
_container = new WinRTContainer();
_container.RegisterWinRTServices();
_container.Singleton<XF.CaliburnMicro1.App>();
}
protected override void OnLaunched(LaunchActivatedEventArgs args)
{
if (args.PreviousExecutionState == ApplicationExecutionState.Running)
return;
Xamarin.Forms.Forms.Init(args);
// loads our MainPage as the root frame
DisplayRootView<MainPage>();
}
#region IoC Overrides
protected override void BuildUp(object instance)
{
_container.BuildUp(instance);
}
protected override IEnumerable<object> GetAllInstances(Type service)
{
return _container.GetAllInstances(service);
}
protected override object GetInstance(Type service, string key)
{
return _container.GetInstance(service, key);
}
protected override IEnumerable<Assembly> SelectAssemblies()
{
return new[]
{
GetType().GetTypeInfo().Assembly,
typeof(MainViewModel).GetTypeInfo().Assembly
};
}
#endregion
}
}
Eventually, you’ll want to provide additional logic for initialization and suspension specific to UWP, but for now OnLaunched simply launches MainPage as the root window for our Xamarin.Forms app.
Customize MainPage
The Xamarin.Forms template includes a MainPage that is optimized for Xamarin.Forms, we simply need to load our App from the Singleton defined in Caliburn’s IoC Container.
namespace XF.CaliburnMicro1.UWP
{
using Caliburn.Micro;
public sealed partial class MainPage
{
public MainPage()
{
this.InitializeComponent();
LoadApplication(IoC.Get<XF.CaliburnMicro1.App>());
}
}
}
Build and Run
Finally, before we give our UWP a spin, we need to make a minor change the deployment to the Solution.
- Change the start-up application to XF.CaliburnMicro.UWP (Universal Windows) and set the target platform to Any CPU
- Open the Configuration Manager for the solution
- Specify that the solution should Deploy for Debug configuration
- Specify Local machine as the target Device
- Compile and Run (F5)
You should now see our familiar View / ViewModel from the PCL should be displayed.
Windows 10:
Windows 10 Mobile:
Next Steps
We’re now set to handle iOS, Android and Universal Windows Apps using Caliburn.Micro, so that’s all for this series. Follow my Xamarin.Forms label to see more posts in this space.
Until then… Happy Coding.
