4 Elements of Professional WPF Applications

Composite Application Guidance for WPF: Prism Goes Prime Time

The WPF answer to CAB is the Composite Application Guidance for WPF, formerly codename Prism.

NOTE:Since the full name is too formal, too long and I can’t with a straight face refer to a development platform as "CAG", we’ll just continue to refer to this technology herein by its code name: Prism. Cool? :)

In this podcast we speak with Brain Noyes of IDesign. Brian is not only an original advisor and consultant to the Patterns and Practices group for Prism, but he is also a prolific writer, an INETA member, Microsoft MVP, ASP Insider and Microsoft Regional Director for the Mid-Atlantic region. With a guy as decorated as Brian, you’d think he was in the military!

What is Prism?

Prism is a set of guidance from the Patterns and Practices group that aids in building composite WPF applications. To be clear though:

  • Prism is not a new application block
  • Prism is not a new framework
  • Prism is not a new software factory (Prism does not feature automation)

Well now that we’ve gotten that out of the way, what is Prism?

Prism is:

  • A set of libraries - named the Composite Application Library or CAL
  • Patterns, documentation and sample code
  • A reference application which mimics a real-world line-of-business application
  • A series of quick starts that demonstrate Prism’s discrete features

What is a composite application?

Large applications whose user interface layer is not modularized end up with a monolithic code base that becomes very difficult to extend and maintain. Without breaking apart the user interface layer maintenance is hampered and working with large or distributed development teams proves difficult.

Often in WPF developers try to modularize by breaking the UI into user controls. Unfortunately, user controls end up needing intimate knowledge of each other so the maintenance problem is displaced rather than assuaged.

A composite application (in the UI sense) breaks the user interface into smaller, independent pieces where testing and development proceed in isolation.

Where Did Prism Come From?

The Patterns and Practices group did something very different before coding began for Prism. Rather than host early looks inside what the group had cooking under the covers, the team at Microsoft reached out to several industry professionals asking them, "What do you want us to build?" After digesting the feedback the team started first by building a real-world application – using the program to drive the development of the guidance.

Further back on the timeline, many of the techniques found in the Prism guidance came from the lessons learned and techniques that emerged from building the first large-scale WPF application, Expression Blend. Blend not only demonstrates what is possible in WPF, but also proves the hypothesis that a substantial application can be built using a composable user interface.

What Are the Basic Elements of Prism?

The four natural breaking points of Prism are:

  1. Modularity*: A class library with single provides the lone entry point for a feature. Modules act as logical wrappers for portions of your application.

    Prism features module enumerators for creating and locating modules at run-time, and a module loader which instantiates modules for the application.
  2. Regions: In the same way that ASP.NE T master pages host content placeholders, a Prism region is a placeholder for modules. This approach gives the application the flexibility it needs to load in the appropriate features and associated UI elements as needed.
  3. Composite Commands: Extends WPF routed commands to be loosely-coupled from the visual tree and dispatch commands to multiple handlers.
  4. Loosely Coupled Events*: This new eventing mechanism features:
    • The definition of the publisher and subscriber to exist at any layer of the application
    • Type and lifetime decoupling between the publisher and subscriber, but with a strongly-typed communication model
    • One line of code on the sender and receiver side
    • Dispatch threads on the UI thread, publisher’s thread or a thread from the pool
    • Provide filter criteria using lambdas or delegate methods to decide whether or not to notify the subscriber when the publisher’s event fires

* The modularity and eventing mechanisms are independent of WPF and may be used to support other UI technologies.

What About Performance?

Any layer of abstraction will affect performance. Load testing revealed the performance impact is realized upon instantiation of the forms. Using dependency injection (which relies heavily on reflection) increased the load time a measurable amount. When testing a form with hundreds of controls the test reported a 15% to 20% in load time. While this latency is not trivial, there are ways to improve the user experience in light of the extra load time. The built-in modular loading supports deferred and on-demand loading.

NOTE: Remember the 20% increase was on a form with 100's of controls. If you are building screens with over a hundred controls on them, perhaps the load time is the least of your worries?

How Does Prism Serve the Developer/Designer Workflow?

The patterns found in the Prism guidance truly separate the natural layers of the application by even aiming to have zero code in the code-behind! The presentation layer is decoupled for testing, but has the added benefit of being able to easily hand to a designer.

How Steep is the Learning Curve?

Some developers are facing an uphill battle when approaching Prism. If you are new to test driven development, the principals of separation-of-concerns, dependency injection and any other cool-kid buzzword that radiates from the ALT.NET movement, then Prism may seem like a huge undertaking.

If you do have exposure to the ALT.NET culture then you are most likely beginning to fold these practices into your development regimen already.


kick it on DotNetKicks.com