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
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.
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
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
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)
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
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
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