Monolithic application are (or should be) a thing of the past. We want to create applications which are composable from various parts, preferably with a loose coupling to allow them to be added to or reconfigured with minimal effort.

There are various composable libraries for WPF, for this post I’m going to concentrate on Prism. Prism uses regions to allow us to partition your application by creating areas within a view for each UI element. These areas are known as regions.

Assuming we have a minimal Prism application as per my post Initial steps to setup a Prism application, then let’s begin by creating a “MainRegion” a region/view which takes up the whole of the Shell window.

• In the Shell.xaml, add the name space

  xmlns:cal="http://www.codeplex.com/prism"
  

• Replace any content you have in the shell with the following

  <ItemsControl cal:RegionManager.RegionName="MainRegion" />
  

  here we’ve created an ItemsControl and given it a region name of “MainRegion”. An ItemsControl allows us to display multiple items, equally we could have used a ContentControl for a single item.

• We’re going to create a new class library for our view(s), so add a class library project to your solution, mine’s named Module1
• To keep our views together create a View folder within the project
• Add a WPF UserControl (mine’s named MyView) to the View folder, mine has a TextBlock within it, thus

  <TextBlock Text="My View" />   
  

  just to give us something to see when the view is loaded.

• Add a class. I’ve named it Module1Module and add the following code

  public class Module1Module : IModule
  {
     private readonly IRegionViewRegistry regionViewRegistry;
  
     public Module1Module(IRegionViewRegistry registry)
     {
        regionViewRegistry = registry;   
     }
  
     public void Initialize()
     {
        regionViewRegistry.RegisterViewWithRegion("MainRegion", 
                 typeof(Views.MyView));
     }
  }
  

  Here we’re setting up an IModule implementation which associates a view with a region name.

• Reference the class library project in the shell project

Using Unity

• Now with our Unity bootstrapper, we need to add the module to the module catalog, as per the following

  protected override void ConfigureModuleCatalog()
  {
     base.ConfigureModuleCatalog();
     ModuleCatalog moduleCatalog = (ModuleCatalog)this.ModuleCatalog;
     moduleCatalog.AddModule(typeof(Module1.Module1Module));
  }
  

Using MEF

• Now with our MEF bootstrapper, we need to add the module to the module catalog, as per the following

  protected override void ConfigureAggregateCatalog()
  {
     base.ConfigureAggregateCatalog();
     AggregateCatalog.Catalogs.Add(new AssemblyCatalog(GetType().Assembly));
     AggregateCatalog.Catalogs.Add(new AssemblyCatalog(
             typeof(Module1.Module1Module).Assembly));
  }
  

• In our view, we need to mark the class with the ExportAttribute, thus

  [Export]
  public partial class MyView : UserControl
  {
     public MyView()
     {
        InitializeComponent();
     }
  }
  

• Now we need to change the module code to the following

  [ModuleExport(typeof(Module1Module), 
     InitializationMode=InitializationMode.WhenAvailable)]
  public class Module1Module : IModule
  {
     private readonly IRegionViewRegistry regionViewRegistry;
  
     [ImportingConstructor]
     public Module1Module(IRegionViewRegistry registry)
     {
        regionViewRegistry = registry;
     }
  
     public void Initialize()
     {
        regionViewRegistry.RegisterViewWithRegion("MainRegion", 
             typeof(Views.MyView));
     }
  }
  

Obviously in this sample we created a single region and embedded a single view, but we can easily create multiple named regions to truly “compose” our application from multiple views.

I haven’t touched Prism in a while as I’ve been using Caliburn.Micro a lot, but decided to reaquaint myself with PRISM recently, so this give me the oppurtunity to create some posts on the basics of PRISM.

Creating the bare bones application

• Create a new WPF Application
• Open App.xaml and delete the StartupUri=”MainWindow.xaml” code as we’ll be creating the “shell” window in code
• Either delete MainWindlow.xaml and then add a new WPF Window or rename the MainWindow to Shell (by convention the main window of the application is named Shell)
• Add the following code to the XAML, inside the Shell’s grid (just so we have something to view when the application start’s up)

  <TextBlock Text="Shell Application" />
  

• Using NuGet Install the PRISM package (mine’s version 5.0.0)
• Create a new class named Bootstrapper, the contents depend upon the IoC container we want to use (discussed below). For now, change the Bootstrapper code to look like this, which is shared by both standard Prism IoC containers.

  public class Bootstrapper
  {
     protected override void InitializeShell()
     {
        base.InitializeShell();
        App.Current.MainWindow = (Window)Shell;
        App.Current.MainWindow.Show();
     }
  
     protected override DependencyObject CreateShell()
     {
        return null;
     }
  }
  

  Obviously we’ve not got a base class at this point so this will not compile, but these two methods are overidden for both Unity and Mef implementation.

• Finally, for the shared code, open App.xaml.cs and add the following

  protected override void OnStartup(StartupEventArgs e)
  {
     base.OnStartup(e);
  
     Bootstrapper bootstrapper = new Bootstrapper();
     bootstrapper.Run();
  }
  

Okay, at this point we’ve got the basics in place but we need to create the bootstrapper which is used to create the shell via the IoC container, whether that be Unity, Mef or any other container setup to work with PRISM.

Using Unity

The Unity container requires the least work to get up and running.

• Using NuGet add the package Prism.UnityExtensions (mine’s version 5.0.1) to the solution
• Change the Bootstrapper code to derive from UnityBoostrapper
• Change the CreateShell code to look like the following

  protected override DependencyObject CreateShell()
  {
     return Container.TryResolve<Shell>();
  }
  

Using MEF

Using MEF requires a little more work than Unity.

• Using NuGet add the package Prism.MEFExtensions (mine’s version 5.0.0) to the solution
• Change the Bootstrapper code to derive from MefBoostrapper
• Add a reference to System.ComponentModel.Composition
• Change the CreateShell code to look like the following

  protected override DependencyObject CreateShell()
  {
     return Container.GetExportedValue<Shell>();
  }
  

• We now need to add our assembly to the MEF catalog, so add the following to the Bootstrapper class

  protected override void ConfigureAggregateCatalog()
  {
     base.ConfigureAggregateCatalog();
     AggregateCatalog.Catalogs.Add(new AssemblyCatalog(GetType().Assembly));
  }
  

• Finally, we need to mark to Shell with the ExportAttribute so that MEF can locate it via Container.GetExportedValue. So open Shell.xaml.cs and place Export able the class thus

  [Export]
  public partial class Shell : Window
  {
      // code
  }