Showing posts with label Prism. Show all posts
Showing posts with label Prism. Show all posts

Monday, April 21, 2014

Prism continues its Windows Desktop/WPF/MVVM Love with v5

Francis K. Cheung - Prism 5.0 for WPF just shipped.

Prism version 5.0 for WPF is now available. This version of Prism includes updates to existing and several new NuGet packages:

  1. Prism
  2. Prism.Composition (New)
  3. Prism.Interactivity (New)
  4. Prism.Mvvm (New)
  5. Prism.MefExtensions
  6. Prism.UnityExtensions

We’ve updated Prism 4.1 with bug fixes and a few new features. ...

Developer's Guide to Microsoft Prism Library 5.0 for WPF

April 2014

Prism provides guidance in the form of samples and documentation that help you easily design and build rich, flexible, and easily maintained Windows Presentation Foundation (WPF) desktop applications. Using design patterns that embody important architectural design principles, such as separation of concerns and loose coupling, Prism helps you to design and build applications using loosely coupled components that can evolve independently but which can be easily and seamlessly integrated into the overall application. In short, these applications are "built to last" and "built for change." These types of applications are known as composite applications.

This topic provides a brief overview of the Prism concepts with links to associated source code and documentation. If you are considering upgrading from Prism 4.1 to Prism 5.0 we include a "What’s New" and "Upgrading from Prism 4.1" topic that you should read.




What's New in Prism Library 5.0 for WPF

Prism 5.0 includes guidance in several new areas, resulting in new code in the Prism Library for WPF, new and updated QuickStarts, and updated documentation. Parts of the Prism Library changed between Prism 4.1 and Prism 5.0 to support the new guidance, fix existing issues, and respond to community requests.


New Guidance

Prism 5.0 contains several areas of new guidance as follows:

  • Prism.Mvvm is a portable class library that encapsulates Prism’s MVVM support. This library includes ViewModelLocationProvider. Views and view models can be wired up together using the new ViewModelLocationProvider’s convention-based approach as explained in Implementing the MVVM Pattern. View model construction can be accomplished using a dependency injection container. The ViewModel Locator’s extensibility points are discussed in Extending the Prism Library. DelegateCommands are now extendable and provide Async support. A new implementation of the INotifyPropertyChanged interface, the BindabaleBase class, was added.
  • The PopupWindowAction class was added to the Prism.Interactivity assembly to open a custom window in response to an interaction request being raised.
    The InvokeCommandAction action provided by Prism now passes trigger parameters to the associated command.
    For more information see Advanced MVVM Scenarios.
  • The EventAggregator classes have been moved to the Prism.PubSubEvents portable class library.
  • The NavigationParameters class can now be used to pass object parameters during navigation, using the overloads of the RequestNavigate method of a Region or RegionManager instance.

Changes in the Prism Library

Prism Library 5.0 includes changes related to new functionality, code organization, and APIs.

Code Organization


API Changes


Additions to the Prism Library Core API

The following namespaces were added to the Prism Library to support the new areas of guidance added in Prism 5.0:

  • Microsoft.Practices.Prism.PubSubEvents was added to help you send loosely coupled message using a portable class library.
  • Microsoft.Practices.Prism.Mvvm was added to assist you in implementing MVVM using a portable class library and several platform specific libraries.
  • Microsoft.Practices.Prism.SharedInterfaces has been added to share the IActiveAware interface between Prism and Prism.Mvvm assemblies, therefore the IActiveAware interface has been moved to this assembly. It is also intended for future use.

CodePlex Issues Resolved

  • ...

Example Code Changes

Prism 5.0 contains eleven separate code samples that demonstrate portions of the provided guidance. Several samples from Prism 4.1 were removed or replaced, and new samples added.

The following samples were added for Prism 5.0:

  • Basic MVVM QuickStart. This QuickStart shows a very simple MVVM application that uses the ViewModel Locator and show a parent and child ViewModels. For more information, see the MVVM QuickStart.
  • MVVM QuickStart. This QuickStart was removed for this version.
  • MVVM Reference Implementation. This reference implementation was removed for this version.
  • View-Switching Navigation QuickStart. This QuickStart now supports WPF. It demonstrates how to use the Prism region navigation API. For more information, see View-Switching Navigation QuickStart.
  • State-Based Navigation QuickStart. This QuickStart now supports WPF. It shows an approach that uses the Visual State Manager to define the views (states) and the allowed transitions. For more information, see State-Based Navigation QuickStart.
  • UI Composition QuickStart. This QuickStart now supports WPF. It replaced the View Injection QuickStart and the View Discovery QuickStart from Prism 2.0. In the current versions, both concepts are shown in one example application. For more information, see UI Composition QuickStart.
  • Interactivity QuickStart. This new QuickStart demonstrates how to exposes an interaction request to the view through the view model. The interactions can be a popup, confirmation, custom popup, and a more complex case where the popup needs a custom view model. It also shows Prism’s InvokeCommandAction action that passes the EventArgs from the trigger, as a command parameter. For more infromation, see Interactivity QuickStart.

NuGet Packages Now Available

In your application, you can now use NuGet to add references to the Prism assemblies. These packages include:


Microsoft Downloads - Prism 5.0 for WPF – April 2014

Prism provides guidance designed to help you more easily design and build rich, flexible, and easy to maintain Windows Presentation Foundation (WPF) desktop applications.


MSDN Code Gallery - Getting Started Code Sample Using the Prism Library 5.0 for WPF

In this lab and associated sample, you will learn the basic concepts of modular application development using the Prism Library, and apply them to create a solution that you can use as the starting point for building a composite Windows Presentation Foundation (WPF) application. After completing this lab, you will be able to do the following:

  • You will create a new solution based on the Prism Library.
  • You will create and load a module.
  • You will create a view and show it in the shell window. 

This lab includes the following tasks:


MSDN Code Gallery - MVVM Code Sample using the Prism Library 5.0 for WPF

The Model-View-ViewModel (MVVM) QuickStart provides sample code that demonstrates how to separate the state and logic that support a view into a separate class named ViewModel using the Prism Library. The view model sits on top of the application data model to provide the state or data needed to support the view, insulating the view from needing to know about the full complexity of the application. The view model also encapsulates the interaction logic for the view that does not directly depend on the view elements themselves. This QuickStart provides a tutorial on implementing the MVVM pattern.

A common approach to designing the views and view models in an MVVM application is the first sketch out or storyboard for what a view looks like on the screen. Then you analyze that screen to identify what properties the view model needs to expose to support the view, without worrying about how that data will get into the view model. After you define what the view model needs to expose to the view and implement that, you can then dive into how to get the data into the view model. Often, this involves the view model calling to a service to retrieve the data, and sometimes data can be pushed into a view model from some other code such as an application controller.

This QuickStart leads you through the following steps:

  • Analyzing the view to decide what state is needed from a view model to support it
  • Defining the view model class with the minimum implementation to support the view
  • Defining the bindings in the view that point to view model properties
  • Attaching the view to the view model



That should be enough Prism for WPF to get you started at least...

Wednesday, August 07, 2013

Brian brings some Unity to using Prism and dynamically discovering and loading Modules at runtime

brian lagunas - Prism: Dynamically Discover and Load Modules at Runtime

If you develop WPF applications with Prism, then you are probably already aware of the many ways in which you can load a module.  Loading a module starts with what is called a ModuleCatalog.  You can’t load a module unless it has been added to a ModuleCatalog.  Once the module has been added to a ModuleCatalog, Prism will then take care of loading the module assembly for you.  Prism even comes with a handful of module catalogs to give you flexibility in how you register your modules with your Prism application.  You can populate a module catalog from code, from XAML, with XML in an app.config, or from a directory.  Heck, you can even use a combination of all these options to populate your module catalog.

When I am giving a Prism talk at a public event or an internal lunch and learn at a company, I am sure to explain all the different ways of loading your modules and which catalog to use.  This is about the time where the questions really start getting interesting.  Of these questions, the most common is about the DirectoryModuleCatalog.  This particular catalog allows you to specify a folder path to load your modules from.  Now the interesting question… “but, what happens when a new module assembly is dropped into the folder?  Will it automatically be loaded into the app while it is running?”  That is a great question, and the answer is NO.  The DirectoryModuleCatalog does a one time scan of the directory and then loads all the modules that it finds.  If you drop a new module assembly into the directory, it will not be loaded until the application is restarted.  Now the follow-up question… “well, is it possible to dynamically discover the modules and load them from the directory as well?”  Answer; well of course it is.  If you’re using MEF, it’s easy.  If you’re using a container such as Unity, you will need to write the code to handle it yourself.  “Well, we don’t use MEF, so can you show us how?”  This is where my reply is always the same, “a simple web search (Google or Bing) should help you find what you are looking for”.

Well, it turns out, that’s not the case.  It seems that no one has blogged about or shared any code that handles the dynamic discovery and loading of modules using a DI container such as Unity.  Not that I could find, nor anyone who is asking me to show them could find.  Which leads me to this post.  I am going to show you an approach that I have used to support such a scenario.  I am actually going to give you two approaches.  One is the “Quick and Dirty” way.  Basically, I will throw together the simplest sample to achieve the goal.  Then I will show you “A Better Way” in which we will encapsulate this functionality into a custom ModuleCatalog that will handle everything for us.


My name is Greg and I pretend to write LOB Prism apps...

Well I am in the middle of using Prism & Unity to build a LOB app I and I ran into exactly what Brian is blogging about. I wanted to do a runtime discovery of modules and just couldn't figure out how to do it quickly enough, so gave up and just did it the hard way. Now that Brian has shown the way, I'm going to have to revisit that... :)

Friday, April 19, 2013

Bye bye Kona code name... Hello "Prism for Windows Runtime"

Brian Noyes Blog - Kona is Dead, Long Live Prism!

If you have read my blog, seen me speak at conferences or user groups, or read some of my articles lately you might know I have been working with the Microsoft patterns & practices team on guidance for Windows Store Business apps. This guidance has been code named “Kona” up until recently, and I’ve posted and written articles on that in various places.

As the team was getting the guidance ready for release, they decided to rename it to “Prism for Windows Runtime”. The names have not all been updated on the Codeplex site or in the downloads yet, but the code has been refactored to the final namespaces and project names that it will ship with.

Specifically the guidance is called “Prism for Windows Runtime”, and it is guidance on building loosely coupled, maintainable, testable applications based on the MVVM pattern for WinRT, especially Line of Business or Business to Consumer applications.

The guidance contains:


If you want to learn more, be sure to check out my article series here, and keep an eye out for my Pluralsight Course that will be out in a month or so titled “Building Windows Store Business apps with Prism”.


Prism for Windows RT (fka Kona) - Prism for Windows Store apps Drop April 10, 2013


I'm happy about this name change... And glad to see Prism, even in a Windows Runtime world, continue to get some attention. Also, as Brian notes, the "Kona" code name is still there on the project. These things can take a bit to change


Related Past Post XRef:
Windows 8 + Kona + Steve = Itinerary Hunter
Kona, Kona, Kona! [Think P&P dev guidance for composite application WinStore Apps {Yes, like Prism, but not}]

Monday, March 18, 2013

Prism? Infragistics? Dock and Ribbon? Oh my...

<xaml:Blog x:Name="Brian Lagunas" /> - XamDockManager–An Updated Prism Region Adapter

Last September, I wrote what has become a very popular Prism region adapter for the Infragistics XamDockManager control.  As pointed out in the post, this original XamDockManager Prism region adapter didn’t support all scenarios.  Frankly, it’s difficult to write a custom region adapter without knowing every usage of the control.  After receiving tons of requests for features and questions on how to implement certain scenarios, I have updated and refactored the XamDockManager Prism region adapter to support the most common requests.

So what was added?

  • Support for Activation – Before, there region adaptor supported IActiveAware from the View and ViewModel perspective.  Whenever a View or ViewModel was activated, the IActiveAware interface members would be invoked.  Unfortunately, the activated View would not become the active docking tab.  Now when you use the Region.Activate method within your code, the view being activated will now become the active docking tab.
  • Support for Remove – Before, when you would call the Region.Remove method, the view would be removed from the region, but the docking pane would still be visible.  The view would not be removed from the XamDockManager control itself.  This was because initially the requirements specifically didn’t support this.  I assumed closing of the panes would occur by the user clicking on the close button of the pane.  Now, whenever you invoke the Region.Remove method, the view will be removed from the region as well as the XamDockManager.  This was a highly request feature.
  • Support for floating panes – Before, the adapter didn’t have any support for floating panes.  Basically everything would work fine until you started tearing off panes and placing them in a floating state, or started to create complex nesting and stacking of panes.  Now, no matter how you have your panes organized, Region.Activate and Region.Remove will properly activate or remove the View form the region as well as the XamDockManager control.  This was by far the most requested feature.


CodePlex - WPF PRISM 4.0 and Ribbons

Project Description
Using Infragistics XamRibbon with WPF PRISM for building rich UI

Prism is the great Framework and sometimes some of the default .NET UI components doesn't quite work for certain scenarios (like RibbonBar and DockManager).
This project is about using Infragistics RibbonBar and later on if time permits Microsoft's Ribbon for WPF (which is provided separately) with Prism. So that we can utilize RibbonBar functionality quite smoothly with PRISM (without breaking MVVM and PRISM Extensiblity).

See Documentation for more information about concept and step by step guide.

If you have a look at SourceCode, it is quite easy to adapt this into another Ribbon Control. - Building IG Outlook Part 7 – Adding the Contacts Module

This is the seventh video in a series that will take you step-by-step on building a Prism application that mimics Microsoft Outlook.  In this video, we added a new Contacts module to the application.  We went through the necessary steps to add this module to both the Silverlight and the WPF applications.  We created a new module, and added views, OutlookBar groups, and Ribbon tabs to the new module.  Along the way, we ran into some common issues that you may face when adding modules to a fully featured application framework and how you would resolve those issues

In the past week I've kicked off my first Prism project and have been climbing the learning curve bit by bit. We've also invested in Infragistics, so using the two together only seems smart.

Brian Lagunas (@BrianLagunas, has a number of cool examples and I found the WPF PRISM 4.0 and Ribbons project, which looks cool, as well.

What do I think about Prism? It's pretty cool and looks like its going to let me build my complex application without tight coupling and a nice separation of concerns. I've been describing it as Lego for WPF app building...

Monday, February 25, 2013

Windows 8 + Kona + Steve = Itinerary Hunter

#WINNING with C# - Windows Store App Example: Itinerary Hunter


Using KONA as a framework, you can think of KONA as the Windows 8 equivalent of PRISM, I have created a Windows Store App for Itinerary Hunter.

The solution features distinct projects for UI views, UI logic (view models, converters, etc), services and tests.  Interfaces are used throughout to enable mocking for unit tests.

Here’s some screenshots of the app



stevenh77 / ItineraryHunter-Win8


I've not seen to many examples yet of Kona based apps, so when I saw this I wanted to make sure to highlight it...


Related Past Post XRef:
Kona, Kona, Kona! [Think P&P dev guidance for composite application WinStore Apps {Yes, like Prism, but not}]

Monday, January 07, 2013

Kona, Kona, Kona! [Think P&P dev guidance for composite application WinStore Apps {Yes, like Prism, but not}]

Infragistics - Introducing Kona Guidance for Windows 8 Application Development (Think of it as Prism for Windows 8, but not really)

I am extremely excited to announce a new project from the smart people at Microsoft’s Patterns & Practices team called Kona.  What is Kona you ask?  Kona is the new developer guidance for developing line of business applications for Windows 8.  Initially this project was called Prism for WinRT, but as it turns out, it’s really not Prism running on Windows 8, but rather a new set of guidance for developing Windows 8 applications.

Wait… just... a... minute Brian.  What do you mean it’s not “Prism” running on Windows 8?  What do you mean “new guidance”?  Well, if you download Kona and expect to start adding regions and modules like you’re used to, then you might get a bit frustrated looking for the attached properties and IModule interface.  Why?  Well, because it’s not there!  Actually there is a lot of Prism code that you are used to having that is not there and will not be there.  Why do you ask?  The answer is simple; it’s Windows 8.  Huh!?  It’s a new platform, and it has changed significantly compared to WPF and Silverlight.  When they were looking at doing the “port” of Prism, they soon realized that a lot of capabilities just didn’t make sense to bring over to the new platform.  Hence, a new set of guidance using a new set of APIs that are specific to the new Windows 8 platform.

Now not everything was ditched.  Some things, not a lot, made sense to bring over.  DelegateCommand and DelegateCommand<T> is still there.  Guidance on MVVM (Model-View-ViewModel) is still there, but honestly I don’t agree with the implementation.  Keep in mind, this is the first initial drop of Kona, so we can always make improvements to the code base.  Everything is a learning experience.






Interesting. Brian's post is much more complete that you'll find yet on the codeplex page,, but as he said, this is just the first drop... Will be watching for this now though... :)

Wednesday, October 10, 2012

Navigation, MVVM, XAML and a little IG (Infragistics) in this "Building IG Outlook" video - Building IG Outlook Part 5–Implementing Navigation and MVVM


This is the fifth video in a series that will take you step-by-step on building a Prism application that mimics Microsoft Outlook.  In this video, we implemented our navigation using the Prism navigation APIs as well as some navigation objects we created to provide our navigation path.  We talked a little about INavigationAware interface, IConfirmNavigationRequest interface, and how the View and ViewModel can participate in the Prism navigation process.  DelegateCommand and CompositeCommand were also discussed.  We also implemented our own little MVVM framework which is made up of only two interfaces, IViewBase and IViewModel.  You saw the first glimpse of the EventAggregator and much more.  Wow, we really covered a lot in this video.  Of course we only had time to implement this functionality in the Silverlight version of the application.  So, I went ahead and implemented the same functionality in the WPF version as well.  ..."

I'm in a place now were I can really start working on modern applications (i.e. model based, WPF, MVVM, etc) so I'm now keeping an even sharper eye out for related materials, posts, etc, like this...

Wednesday, June 27, 2012

Looking through a prism for unity... "Creating Modularity with WPF, Prism and Unity"

Visual Studio Magazine - Creating Modularity with WPF, Prism and Unity

There's a better set of tools than using Windows Presentation Foundation (WPF) straight out of the box: WPF plus Prism (formerly "Composite Application Guidance for WPF and Silverlight") and Unity. Prism focuses on letting you turn your XAML file into a true view, supported by a completely separate ViewModel class.

Because your XAML view is built declaratively, you might have blunders in it (incorrect property settings, for instance), but you can't have logic errors. Instead, your bugs are limited to your procedural code (the validation code, the integration with your business objects, workflow management and so on), which is segregated into your ViewModel class. That ViewModel class can be developed in parallel to your view and, more importantly, built using test-driven development (TDD) to ensure it works correctly. Once your view model is built, it just needs to be wired up to your XAML to create your application.

Unity focuses on giving you runtime flexibility in that "wiring up" phase by providing the ability to create composable applications -- applications that choose their parts at runtime. Instead of hardcoding class names into your code, you specify the criteria for the classes you want to use. At runtime, your application looks for the class it needs and loads it. This gives you an easier way to swap in and out your views and view models from one site to another, from one scenario to another (premium customers versus ordinary customers) or from one state to another (test versus production; supporting a customer in default versus supporting a customer in good standing). Applications determine the criteria for the components they need by reading a configuration file or by making decisions based on information in the environment.

It's a different way of thinking: Using Prism and Unity with WPF is as much about adopting a way of creating your applications as it is about adopting new technology. And while I'm focusing on WPF in this article, Prism and Unity work equally well with Silverlight, throwing in the ability to dynamically search for the classes to download to the client as a bonus.

The easiest way to get the Prism/Unity combo is to use the Extensions Manager on the Visual Studio Tools menu to search for and install the NuGet Package Manager. Once you have NuGet installed, you can right-click on your project and select Manage NuGet Packages. A search in the online forums on Prism will bring you to the Prism.UnityExtensions package, which you can download and install into your project.



Been a while since I've highlighted a Prism/Unity post or article. I've been hearing Prism/Unity noises around me so wanted to grab this for future sharing/etc. Plus I thought it cool that we're seeing this a few days early (the article post date is 7/1/2012 and today is 6/27/2012). Finally I just liked the depth and detail...

Monday, May 09, 2011

JustDecompile - Free (well, reg-ware), for everyone, forever, stand-alone .Net Decompiler from Telerik

KodefuGuru - Losing Free Reflector? Try JustDecompile!

"... I wrote about the decompile feature in JustCode, which is an innovative method of decompiling your code directly within Visual Studio. However, a standalone product is desired. We don’t always want to navigate assemblies from within Visual Studio, and an interface specifically designed to navigate and decompile assemblies is valuable when taking a journey through the .NET framework, a new product, or mystery libraries.

Telerik recently announced a new product: JustDecompile. It is guaranteed to be free for everyone, free forever: there are no time bombs ..."

Telerik - JustDecompile

"Powerful, Free Decompiling. Forever.

JustDecompile is a new, free developer productivity tool designed to enable easy .NET assembly browsing and decompiling. Currently available as a BETA, JustDecompile builds on years of experience in code analysis and development productivity originally created for JustCode, Telerik's Visual Studio productivity add-in. JustDecompile lets you effortlessly explore and analyze compiled .NET assemblies, decompiling code with the simple click of a button. Download the BETA and provide feedback in the Forums to help shape the official version, targeted for the Q2 2011 release this summer.


Going to be an interesting summer with the releasing of ILSpy and JustDecompile, among other like solutions I'm sure...

Here's a snap of the app;


At first glance, I'd almost have to wonder if this were a Prism app?

Let's look at its install folder...


Yep, looks like Prism. Cool in seeing that in a commercial, released to the world, app.

Also interesting that Mono.Cecil is being used. I've been seeing a good bit about that recently and am going to have to give that a much closer look.

Monday, January 17, 2011

The Prism 4.0 Template Pack is now available (think “Boilerplate code to show off many of Prism’s features + Project Templates too!”)

David Hill's WebLog - Prism 4.0 Template Pack Now Available

“The updated version of the Prism Template Pack for Prism 4.0 is now available here!

The Prism 4.0 Template Pack contains Prism shell and module project templates and a quick-start solution template which creates a multi-project solution with a shell and two modules. All templates are available for both Silverlight and WPF and for C# or Visual Basic.NET..

A Quick Tour

The templates provide boiler-plate code that demonstrates many of the features provided by Prism, including:

  • The Model-View-ViewModel (MVVM) Pattern
  • Dependency Injection using Unity
  • Modularity
  • Commands
  • Interaction Requests
  • Regions
  • Navigation
  • Loosely coupled events using the Event Aggregator

The quick start solution templates creates a simple multi-module Prism solution that shows all of these features working together. You can use this template to create a simple but working end-to-end application which you can evolve to your own requirements …


This has been covered a bit already (i.e. I’m a day late and dollar short, yada, yada… ;) but I want to capture this for my own usage (since that’s what my blog really is, my remote, distributed, cloud based, full text searchable memory storage… ;)

Here’s a couple snaps of it in action;



(via The Morning Brew - The Morning Brew #771)


Related Past Post XRef:
Prism v4 - VB Style and Training Kit too
Stick a fork in it, Prism 4.0 is done…
How about some free MVVM training/hands on/walkthroughs right in the VS box? “In the Box – MVVM Training” from Karl Shifflett (Oh yeah, with some WPF, Test, Moc, and Prism too)

Saturday, November 20, 2010

Prism v4 - VB Style and Training Kit too

Microsoft Downloads - Visual Basic Prism 4 Reference Implementations, QuickStarts, and Hands-on Labs

“Prism provides guidance designed to help you more easily design and build rich, flexible, and easy to maintain WPF desktop applications and Silverlight Rich Internet Applications (RIAs).

File Name: PrismV4_VB.Exe

Size: 30.4MB

Version: 4.0

Date Published: 11/19/2010

Language: English

Prism provides guidance designed to help you more easily design and build rich, flexible, and easy to maintain Windows Presentation Foundation (WPF) desktop applications and Silverlight Rich Internet Applications (RIAs) and Windows Phone 7 applications.

This download is provided to help the Visual Basic developer use the Prism Library. It includes reference implementations, QuickStarts, the Prism Library binaries, and documentation. The documentation includes:

  • Visual Basic Content for Prism4.chm: The documentation for the reference implementations, QuickStarts, and Hands-On Labs in Visual Basic.
  • Prism4.chm: Documentation in C#.
  • Prism4APIReference-{platform}.chm: Library reference API.


Damian Schenkelman - Prism Training Kit 4.0 Released

“This past week with Diego, Ezequiel, Guido and Matias we worked on updating Prism training kit to Prism 4.0. Following the trend from the Prism team guys, we updated the version number to Prism Training Kit 4.0. Download the latest version from here.

I really recommend downloading this release, as we put a lot of effort in getting out there what we believed would be the most useful content. You can get a set of detailed updates and features in Guido’s blog, but to summarize the main changes are:

  1. Updated Modularity, Bootstrapper, Dependency Injection, Communication and UI Composition labs to Prism 4.0.
  2. Created new labs for MEF and Navigation.
  3. Fixed bugs from first version of the Training Kit.


Good to see VB get some Prism love and I always love training kits… ;)


Related Past Post XRef:
Stick a fork in it, Prism 4.0 is done…
How about some free MVVM training/hands on/walkthroughs right in the VS box? “In the Box – MVVM Training” from Karl Shifflett (Oh yeah, with some WPF, Test, Moc, and Prism too)

Saturday, November 13, 2010

Stick a fork in it, Prism 4.0 is done…

.NET Developer Guidance - Prism 4.0 For Visual Studio 2010, .NET Framework 4.0, WPF & Silverlight 4


Prism provides guidance designed to help you more easily design and build rich, flexible, and easy to maintain Windows Presentation Foundation (WPF) desktop applications, Silverlight Rich Internet Applications (RIAs) and Windows Phone 7 applications. Using design patterns that embody important architectural design principles, such as separation of concerns and loose coupling, Prism helps you to design and build applications using loosely coupled components that can evolve independently but which can be easily and seamlessly integrated into the overall application. Such applications are known as often referred to as composite applications.


[GD: Click through for the links]…


Prism is intended for software developers building WPF or Silverlight applications that typically feature multiple screens, rich user interaction and data visualization, and that embody significant presentation and business logic. These applications typically interact with a number of back-end systems and services and, using a layered architecture, may be physically deployed across multiple tiers. It is expected that the application will evolve significantly over its lifetime in response to new requirements and business opportunities. In short, these applications are "built to last" and "built for change." Applications that do not demand these characteristics may not benefit from using Prism.

Key Benefits

  • Provides guidance and a re-usable library to help you develop flexible, easy to maintain WPF and Silverlight composite applications
  • Helps you to understand, implement and use key design patterns, such as MVVM and Dependency Injection
  • Supports the development of modular applications, allowing parts of your application to be fully developed and tested by separate teams
  • Helps you re-use application code and components across WPF and Silverlight, allowing you to create multi-targeted client experiences
  • Allows you to build a designer-friendly, dynamically composed user interface for your application
  • Includes reference implementations, quick-starts, hands-on-labs, as well as a comprehensive developers guide to get you up to speed quickly
  • Includes full source code to support code re-use or customization or for reference and education

In this Release


Microsoft Downloads - Prism 4.0 - November 2010


File Name: Prismv4.exe
Size: 23.5MB

Quick Details

Version: 4.0
Date Published: 11/11/2010

Prism provides guidance designed to help you more easily design and build rich, flexible, and easy to maintain Windows Presentation Foundation (WPF) desktop applications and Silverlight Rich Internet Applications (RIAs) and Windows Phone 7 applications. Using design patterns that embody important architectural design principles, such as separation of concerns and loose coupling, Prism helps you to design and build applications using loosely coupled components that can evolve independently but which can be easily and seamlessly integrated into the overall application. Such applications are known as often referred to as composite applications.


patterns & practices: Prism  - Prism 4 Documentation (aka “Developer’s Guide to Microsoft Prism”)

“Released: Nov 12 2010'

Dev status: Stable


Prism 4 Documentation (CHM)
application, 15338K, uploaded Fri…

Prism 4 Documentation (PDF)
application, 14408K, uploaded Fri…


I dig that the full source code is included. Love that…

We’re using Prism 4 for the first time at work and so far it seems to be going well (at least Peter has attempted to kill me for suggesting we use it… ;)

Here’s a snap of the free 342 page Dev Guide;



Related Past Post XRef:
How about some free MVVM training/hands on/walkthroughs right in the VS box? “In the Box – MVVM Training” from Karl Shifflett (Oh yeah, with some WPF, Test, Moc, and Prism too)

Friday, November 12, 2010

How about some free MVVM training/hands on/walkthroughs right in the VS box? “In the Box – MVVM Training” from Karl Shifflett (Oh yeah, with some WPF, Test, Moc, and Prism too)

Karl on WPF - In the Box – MVVM Training


What is In the Box?

In the Box is a high quality, multi-media training that is consumed within Visual Studio 2010.  Content is navigated and delivered using a next generation computer based training (CBT) experience, the Visual Studio 2010 Feature Extension.

In the Box, is a brand name for a series of CBT Feature Extensions I’ll release that are listed in the Visual Studio 2010 Add New Project dialog; see below image.  This release is MVVM Training, the next will be Prism Training.

In the Box features:

  • Visual Studio 2010 Feature Extension
  • Content delivered as text, code, images, diagrams, video, or hyperlinks to the Internet
  • Hierarchical navigation tool window for content navigation
  • Content is viewed inside Visual Studio 2010 tool windows
  • No additional downloads or dependencies; all content is in the box.  (except online videos)
  • Installed and updated from the Visual Studio Gallery
  • Managed (disabled or uninstalled) using Visual Studio Extensions Manager (see bottom of this page)
  • Authored using Microsoft Word and the Instant Feature Builder

This installment of In the Box contains in-depth MVVM Training that includes an eleven assembly example solution with projects targeting developers at different levels of experience

Who is the target audience?

  • If you have never used MVVM before, this training is for you. 
  • If you have been using MVVM for a while and want to learn more, this training is for you. 
  • If you are an expert, you will enjoy the MVVM Technical Description and MVVM Scenarios content.


As you seen in a couple recent posts, I really like the idea of training that’s baked into the VS box/IDE/experience. So when I saw this (and that it was built using Instant Feature Builder that I also just blogged about) I had to check it out…

Here are some snaps of it in action.

In Extension Manager, search for “MVVM Training”;


New Project (only available for C#);


Check out the scope of the training. We’re  talking some serious content here…



And yeah, it’s free. Now that’s a deal that is hard to beat…



Related Past Post XRef:
Feature Builder power with drag and drop simplicity - Instant Feature Builder v1 (Think “Drag and Drop Map/Code files/Docs/Guidance in and vsix out”)