This guide provides everything you need to get started with Prism and to use it to create flexible, maintainable Windows® Presentation Foundation (WPF) and Microsoft Silverlight® 4.0 applications.

It can be challenging to design and build WPF or Silverlight client applications that are flexible, maintainable, and that can evolve over time based on changing requirements. These kinds of applications require a loosely coupled modular architecture that allows individual parts of the application to be independently developed and tested, allowing the application to be modified or extended later on. Additionally, the architecture should promote testability, code re-use, and flexibility.

Prism helps you to design and build flexible and maintainable WPF and Silverlight applications by using design patterns that support important architectural design principles, such as separation of concerns and loose coupling. This guide helps you understand these design patterns and describes how you can use Prism to implement them in your WPF or Silverlight applications.

This guide will show you how to use Prism to implement the Model-View-View-Model (MVVM) pattern in your application, and how to use it along with commands and interaction requests to encapsulate application logic and make it testable. It will show you how to split an application into separate functional modules that can communicate through loosely coupled events, and how to integrate those modules into the overall application. It will show you how to dynamically construct a flexible user interface by using regions, and how to implement rich navigation across a modular application. Prism allows you to use these design patterns together or in isolation, depending on your particular application requirements.

1. Chapter 1 Introduction

   1. Why Use Prism?

   2. Getting Started with Prism

   3. An Overview of Prism

   4. More Information

2. Chapter 2 Initializing Prism Applications

   1. What Is a Bootstrapper?

   2. Key Decisions

   3. Core Scenarios

   4. More Information

3. Chapter 3 Managing Dependencies Between Components

   1. Key Decision: Choosing a Dependency Injection Container

   2. Core Scenarios

   3. Using Dependency Injection Containers and Services in Prism

   4. Using IServiceLocator

   5. More Information

4. Chapter 4 Modular Application Development

   1. Benefits of Building Modular Applications

   2. Core Concepts

   3. Key Decisions

   4. Core Scenarios

   5. More Information

5. Chapter 5 Implementing the MVVM Pattern

   1. Class Responsibilities and Characteristics

   2. Class Interactions

   3. Construction and Configuration

   4. Key Decisions

   5. More Information

6. Chapter 6 Advanced MVVM Scenarios

   1. Commands

   2. Handling Asynchronous Interactions

   3. User Interaction Patterns

   4. Advanced Construction and Configuration

   5. Testing MVVM Applications

   6. More Information

7. Chapter 7 Composing the User Interface

   1. UI Layout Concepts

   2. UI Layout Scenarios

   3. UI Design Guidance

   4. UI Layout Key Decisions

   5. More Information

8. Chapter 8 Navigation

   1. Navigation in Prism

   2. More Information

9. Chapter 9 Communication Between Loosely Coupled Components

   1. Commanding

   2. Region Context

   3. Shared Services

   4. Event Aggregation

   5. More Information

10. Chapter 10 Sharing Code Between Silverlight and WPF

    1. Goal and Benefits

    2. Out of Scope

    3. Multi-Targeting Scenarios

    4. Multi-Targeted Considerations

    5. Multi-Targeted Elements

    6. A Solution to Multi-Targeting: Multiple Linked Projects

    7. Creating Multi-Targeted Applications

    8. More Information

11. Chapter 11 Deploying Prism Applications

    1. Deploying Silverlight Prism Applications

    2. Deploying WPF Prism Applications

    3. More Information

1. Appendix Glossary

2. Appendix Patterns in the Prism Library

   1. Adapter

   2. Application Controller Pattern

   3. Command Pattern

   4. Composite and Composite View

   5. Dependency Injection Pattern

   6. Event Aggregator Pattern

   7. Façade Pattern

   8. Inversion of Control Pattern

   9. Observer Pattern

   10. Presentation Model Pattern

   11. Registry Pattern

   12. Repository Pattern

   13. Separated Interface and Plug-In

   14. Service Locator Pattern

   15. More Information

3. Appendix Prism Library

   1. Registering with Visual Studio 2010

   2. Organization of the Prism Library

   3. The Prism Library Source

   4. Modifying the Library

   5. Running the Tests

   6. More Information