How to Build Composite Applications with PRISM
•
1 like•979 views
Created by Emil Stoychev (The Silverlight Show) from Bulgaria at my Microsoft "Pre-MIX!!" ROCK! event. Topics covered include design & technical concepts in PRISM, composite apps vs. monolithic apps, prism is a set of guidelines not a framework. Technical Concepts: 1. Bootstrapper is responsible for app initialization 2. CAL includes UnityBootstrapper 3. XAML 4. Configure RegionAdapter Mappings 5. Creating the Shell 6. Initializing Modules 7. Windows Presentation Foundation (WPF) 8. Module Options 1. Design Concepts: modularity, dependency injection container, multi-targeting 2. UI Composition: commanding, eventing 3. View Composition = View Injection = View Discovery
Recommended
Recommended
More Related Content
What's hot
What's hot (12)
Similar to How to Build Composite Applications with PRISM
Similar to How to Build Composite Applications with PRISM (20)
More from DataLeader.io
More from DataLeader.io (11)
Recently uploaded
Recently uploaded (20)
How to Build Composite Applications with PRISM
- 1. HOW TO BUILD COMPOSITE APPLICATIONS WITH PRISM EMIL STOYCHEV, SILVERLIGHT MVP
- 2. Bio • CTO, CompletIT • Co-founder, SilverlightShow • Silverlight MVP • Silverlight Bulgaria UG Lead • Blog – http://emil.silverlightshow.net • Twitter - @estoychev – do you follow me? 2
- 3. Content • What are Composite Applications? • Design and Technical Concepts in Prism • Quick Starts
- 4. What are Composite Applications? Feature multiple Rich, flexible user Role-determined screens interaction behavior Built to last and Start small, evolve Quickly response built for change over time to changes Use loosely coupled, independently evolvable pieces
- 5. What are Composite Applications? Composite Applications tightly-coupled with no loosely-coupled clear separation of modules Monolithic Applications concerns hard to extend common shell hard to maintain common services hard to test separated hard to deploy presentation patterns easy to introduce new mockability/testability bugs when fixing others
- 6. What is Prism? • Set of guidance (not a framework) • Design and build flexible client applications • Will help you if: You must be able to You are developing, Your application will add change the application testing, and deploying more views and more quickly and safely to meet modules independently of functionality over the emergent business the other modules. coming years. requirements. Your application targets Your application is being both WPF and Silverlight, developed by multiple and you want to share as collaborating teams. much code as possible.
- 7. Prism Assets • Found at http://prism.codeplex.com • Composite Application Library (CAL) source code • Stock Trader Reference Implementation • Quick Starts • Documentation
- 8. Design Concepts: UI Composition
- 9. UI Composition: View Composition • Display views from different modules on named locations within your app’s UI • View creation – Programmatically – View Injection – Automatically – View Discovery
- 10. View Composition: View Injection • Views are programmatically added/ removed from a named location by the modules
- 11. View Composition: View Discovery • Modules register views for a named location
- 12. UI Composition: Commanding • Decouple the view from the presentation logic • Move handling logic away from the code behind
- 13. UI Composition: Eventing • Enable communication between components • Event Aggregator – holds event objects
- 14. Design Concepts: Modularity • Modularity is designing a system that is divided into a set of functional units (named modules) that can be composed into a larger application
- 15. Design Concepts: Container • Tie modules together using a dependency injection container • Reduce dependency coupling • Instantiate instances • Manages lifetime – singleton, instance • Usage – register type/instance/service; resolve container.RegisterType<ILogger, DBLogger>(); ILogger logger = container.Resolve<ILogger>();
- 16. Design Concepts: Multi-targeting • Write once, use on both WPF and Silverlight • Silverlight and WPF – not binary compatible • The goal is reuse of source code – ViewModels, Models, Controllers, Services, Unit Tests • Harder to reuse – Complex views (xaml), controls, styling, animations
- 18. Bootstrapper • Responsible for application initialization • CAL includes UnityBootstrapper from Unity
- 19. Configure the Container • Register core services – IModuleInitializer – IModuleManager – IRegionManager – IEventAggregator –…
- 20. Configuring the RegionAdapter Mappings • Used by region manager to associate the correct adapters for XAML-defined regions • Default mappings – TabControl (Silverlight-only) – Selector – ItemsControl – ContentControl
- 21. Creating the Shell • Allows greater testability • Shell gets displayed
- 22. Initializing the Modules • ModuleManager service is resolved • Creates and loads the ModuleCatalog • Initializes any available modules
- 24. Module • Module is packaged in an assembly • Must contain an IModule class
- 25. Discover Modules • Defining modules in code • Defining modules in XAML • Reading module information from a configuration file • Loading all modules in a directory (only in WPF)
- 26. Load Modules • Retrieve module from web (or get from disk) • Transfer into memory
- 27. Initialize Modules • Call the module IModule class Initialize method • Register types with the container • Register views for a region • Integrate with application – Subscribe to events – Add view to app navigation
- 28. Module Options • ModuleA can depend on ModuleB • Loading – WhenAvailable – referenced by the shell – OnDemand – download from Web when needed
- 29. Discover MODULES
- 30. Shell • Application’s main window • Contains multiple views • May contain regions • May define top UI elements – toolbar, menu
- 31. Shell
- 32. Regions • Named locations in a Shell • Think of a Placeholder • May contain a single or multiple views • RegionManager – Holds regions – Creates regions • RegionContext – Share context between parent and child view
- 33. View • Collection of UI elements contained in a Shell • Main unit of UI construction • Maight be a UserControl, DataTemplate or a Custom Control • Composite Views – contain a view in itself – most commonly by defining a region
- 35. Questions? 35
- 36. Thank you! 36
Editor's Notes
- To compose your user interface, you need an architecture that allows you to create a layout composed of loosely coupled visual elements at run time and that provides strategies for these visual elements to communicate in a loosely coupled fashion.
- application contains a registry of named locations in the UI and a module can look up one of the locations using the registry and then programmatically inject views into it.
- When that location is displayed at run time, any views that have been registered for that location will be automatically created and displayed within it.
- Enable testability
- Applications based on the Composite Application Library are composites that potentially consist of many loosely coupled modules. They need to interact with the shell to contribute content and receive notifications based on user actions. Because they are loosely coupled, they need a way to interact and communicate with one another to deliver the required business functionality.
- The bootstrapper is responsible for the initialization of an application built using the Composite Application Library. By using a bootstrapper, you have more control of how the Composite Application Library components are wired up to your application.
- During this phase, the shell will be displayed if it exists. Having the creation of the shell in the bootstrapper allows greater testability of the application because the shell can be mocked in a unit test.
- During this phase, module loading occurs. First, the module manager service is resolved from the container. After that, the Run method of the module manager service is invoked. This method validates the module catalog and initializes the available modules.
- The ModuleCatalog holds information about the modules that can be used by the application. Each module is described in a ModuleInfo class that records the name, type, and location, among other attributes of the module.
- After the ModuleCatalog is populated, the modules are ready to be loaded and initialized. Module loading means that the module assembly is transferred from disk into memory. If the assembly is not present on disk, it might have to be retrieved first. An example of this is downloading assemblies from the Web using Silverlight XAP files. The ModuleManager is responsible for coordinating the whole loading and initialization process.
- Finally, the modules have to be initialized. This means, an instance of the module classes must be created and their Initialize() method must be called