Creating a WPF Application Using Prism

1. Add a new class file named Bootstrapper.cs to the "simpleprismapplication" project.
   
2. Add the following using statements at the top of the file. You will use them to refer to elements referenced in the UnityBootstrapper class.
   
   1. using System.Windows;
   2. using Microsoft.Practices.Prism.Modularity;
   3. using Microsoft.Practices.Prism.UnityExtensions;
   4. using Microsoft.Practices.Unity;

3. Update the Bootstrapper class's signature to inherit from the UnityBootstrapper class.
   

   1. class Bootstrapper : UnityBootstrapper
   2. {
   3. }

4. Override the Create Shell method in the Bootstrapper class. In this method, create an instance of the shell window and return it, as shown in the following code.
   

   1. protected override DependencyObject CreateShell()
   2. {
   3. return new Shell();
   4. }

5. You can turn the shell object to have the UnityBootstrapper base class attach an instance of the region manager service to it. The regionmanager service is a service included in the Prism Library that manages regions in the application. By having a region manager instance attached to the shell window, you can declaratively register regions from XAML code that will exist in the scope of the shell window and child views.
   

6. Override the InitializeShell method in the Bootstrapper class. In this method, display the shell to the user.
   

   1. protected override void InitializeShell()
   2. {
   3. base.InitializeShell();
   4. App.Current.MainWindow = (Window)this.Shell;
   5. App.Current.MainWindow.Show();
   6. }

7. Override the ConfigureModuleCatalog method. In this template method, you populate the module catalog with modules. The module catalog interface is "Microsoft.Practices.Prism.Modularity.IModuleCatalog" and it contains metadata for all the modules in the application. Because the application contains no modules at this point, the implementation of the ConfigureModuleCatalog method should simply call the base implementation and return. You can paste the following code in your Bootstrapper class to implement the method.
   

   1. protected override void ConfigureModuleCatalog()
   2. {
   3. base.ConfigureModuleCatalog();
   4. }

8. Open the file App.xaml.cs and initialize the Bootstrapper in the handler for the Startup event of the application, as shown in the following code. By doing this, the bootstrapper code will we executed when the application starts.
   

   1. public partial class App : Application
   2. {
   3. protected override void OnStartup(StartupEventArgs e)
   4. {
   5. base.OnStartup(e);
   6. Bootstrapper bootstrapper = new Bootstrapper();
   7. bootstrapper.Run();
   8. }
   9. }

9. Open the App.xaml file and remove the attribute StartupUri. Because you're manually instantiating the shell window in your bootstrapper, this attribute is not required. The code in the App.xaml file should look like the following.
   

   1. <Applicationx:ClassApplicationx:Class="simpleprismapplication.App"
   2. xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
   3. xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
   4. <Application.Resources>
   5. </Application.Resources>
   6. </Application>

10. Build and run the application. You should see an empty Simple Prism Application window, as shown in the following illustration.

4. Adding Module to Project

1. Add a new class library project to your solution. To do this, right-click the simple Prism application solution node in Solution Explorer, point to Add, and then click "New Project". In the Project types list, select "Windows" in the Visual C# node. In the Templates box, click "Class Library". Finally, set the project's name to simple Prism applicationModule, and then click "OK". The following illustration shows your solution. Solution with a module named simpleprismapplicationmodule.
   
   
   
2. Add references to your module to the following WPF assemblies. To do that, right-click the "simpleprismapplicationmodule" project in Solution Explorer and then click "Add Reference". In the Add Reference dialog box, click the .NET tab, click the following assemblies and then click "OK":
   
   
   • PresentationCore.dll
   
   
   • PresentationFramework.dll
   
   
   • WindowsBase.dll
   
   
   • System.Xaml.dll
3. Add references in your module to the Microsoft.Practices.Prism.dll Prism Library assemblies. To do this, right-click the HelloWorldModule project in Solution Explorer, and then click "AddReference". In the Add Reference dialog box, click the Browse tab, click the following assemblies, and then click "OK":
   
4. Rename the Class1.cs file to "simpleprismapplicationmodule.cs". Open the file "simpleprismapplicationmodule.cs" and impliment the Microsoft.Practices.Prism.Modularity namespace in the class.
   
5. Implement the IModuleinterface in the simpleprismapplicationmodule class and create the constructure of this class.
   
6. Add a Views folder having name View to store the views of your application to the simple Prism application module project. Again add one more folder and rename it to "ViewModel" to store the view models.
   
   Note: The folders mentioned above can be created in the simple Prism application project also, but it is a good practice to create a separate module to manage the code.
   
7. In your shell project, add a reference to the simple Prism application module project. Open theBootstrapper.cs file and explore the ConfigureModuleCatalog method. The method implementation is shown in the following code.
   
   1. protected override void ConfigureModuleCatalog()
   2. {
   3. base.ConfigureModuleCatalog();
   4. }

8. Update theConfigureModuleCatalog method to register the "simpleprismapplicationmodule" module with the module catalog instance. To do this, you can add the following codes in theConfigureModuleCatalog below the
   "base.ConfigureModuleCatalog();" code.
   
   ModuleCatalog moduleCatalog= (ModuleCatalog)this.ModuleCatalog;
   
   moduleCatalog.AddModule (typeof (simpleprismapplication.simpleprismapplicationmodule));
   
9. Now add the module and register the module application with the shell. That is done in the next steps in the adding of the view to the application.

5. Adding a View

Add a new WPF user control to your module by right-clicking the Views folder in Solution Explorer, point to "Add" and then click "New Item". In the Add New Item dialog box, select the User Control (WPF) template, set the name to simple Prism application view.xaml and then click "Add". Add a text block to the view and set the text to "Hello Friends" and save the file.

6. Add a region to the shell

1. Open the "simpleprismapplicationmodule.cs" file. Add the followingusing statement to the top of the file. You will use it to refer to the region elements in the Prism Library.
   

   1. using Microsoft.Practices.Prism.Regions;

2. Create a private read-only instance variable to hold a reference to the region manager and paste the following code inside the class body.
   

   1. using Microsoft.Practices.Prism.Regions;

3. Add the constructor of the "simpleprismapplicationmodule" class to obtain a region manager instance through the constructor dependency injection and store it in the regionManager instance variable. The constructor has to take a parameter of type "Microsoft.Practices.Prism.Regions.IRegionManager". You can paste the following code inside the class body to implement the constructor.
   

   1. public simpleprismapplicationmodule(IRegionManager regionManager)
   2. {
   3. this.regionManager = regionManager;
   4. }

4. In the Initialize method, invoke the RegisterViewWithRegion method on the RegionManager instance. This method registers a region name with its associated view type in the region view registry; the registry is responsible for registering and retrieving these mappings.The RegisterViewWithRegion method has two overloads. When you want to register a view directly, you use the first overload that requires two parameters, the region name and the type of the view.
   

   1. public void Initialize()
   2. {
   3. regionManager.RegisterViewWithRegion("MainRegion",typeof(View.simpleprismapplicationview));
   4. }

5. The UI composition approach used in the preceding code is known as view discovery. When using this approach, you specify the views and the region where the views will be loaded. When a region is created, it asks for its associated views and automatically loads them.
   
   Note:
   
   The region's name must match the name defined in the RegionName attribute of the region.
   
   Output
   
   
   

Summary

In this explanation we have seen how to create a new application in WPF using Prism library.