Erwin van der Valk's blog: Practicing patterns : Prism

writing applications that target both wpf and silverlight with a single codebase

erwinvandervalk — Thu, 03 Sep 2009 23:09:50 GMT

A while back, I wrote an MSDN article on writing multi-targeted programs with Prism.

http://msdn.microsoft.com/en-us/magazine/ee321573.aspx

Hope you like it!

what do you think of prism?

erwinvandervalk — Wed, 01 Apr 2009 20:40:01 GMT

Prism has been out for quite a while now. I hope you had some time to play with it, read the docs, look at the code and build apps with it. So, what do YOU think of prism? Did you like it? Did it help solve your composite application problems? Was it easy to use or very hard? Please let us know by filling out this survey:

http://www.zoomerang.com/Survey/survey-intro.zgi?p=WEB228YSYYRK4A

Of course, you don’t have to.. but this is your chance. If you really liked prism, then tell us. That way, we know we have to invest more in future versions of Prism ;)

Test if classes are registered in unity

erwinvandervalk — Sat, 14 Feb 2009 01:45:37 GMT

While writing some sample applications for the upcoming release of Prism (Composite Application Guidance for WPF and Silverlight) I ran into a small challenge.

“How do you verify (with unit tests) that the right classes are registered in your DI-container?”

In my case, the container is Unity, but Unity does not have any ‘IsTypeRegistered’ methods (Apparently there are good reasons for it not to have these methods). So that posses an interesting challenge. At first I thought of 2 solutions:

Manually create a mock of your container.
Certainly possible but a lot of work for my small demo app. A mocking framework can help with this, but i don’t want to rely on a mocking framework for a small demo app.
See if the components are registered by resolving the type.
This will work initially, but it will actually instantiate the object. So if the object can’t be created for some reason, your test will fail. Now if the type you have just registered has a lot of dependencies, you will need to satisfy all those dependencies in the container before you can even begin to create the object.

But neither of these options were really satisfying. Then I asked Chris Tavarez, and he mentioned: Why don’t you build a Unity Extension. So I did and that solved the problem quite nicely:

So this is the Extension I’ve created:

        1: public class QueryableContainerExtension : UnityContainerExtension

       2: {

       3:     public List<RegisterEventArgs> Registrations = new List<RegisterEventArgs>();

       4:  

       5:     protected override void Initialize()

       6:     {

       7:         this.Context.Registering += new EventHandler<RegisterEventArgs>(Context_Registering);

       8:     }

       9:  

      10:     void Context_Registering(object sender, RegisterEventArgs e)

      11:     {

      12:         this.Registrations.Add(e);

      13:     }

      14:  

      15:     public bool IsTypeRegistered<TFrom, TTo>()

      16:     {

      17:         return this.Registrations.FirstOrDefault((e) => e.TypeFrom == typeof(TFrom) && e.TypeTo == typeof(TTo)) != null;

      18:     }

      19:  

      20:     public bool IsTypeRegisteredAsSingleton<TFrom, TTo>()

      21:     {

      22:         return this.Registrations.FirstOrDefault(

      23:             (e) => e.TypeFrom == typeof(TFrom)

      24:                 && e.TypeTo == typeof(TTo)

      25:                 && typeof(ContainerControlledLifetimeManager).IsInstanceOfType(e.LifetimeManager)) != null;

      26:     }

      27: }

And this is how you’d use it:

       1: [TestMethod]

       2: public void TestRegistration()

       3: {

       4:     // Create the container and add the extension method

       5:     var container = new UnityContainer();

       6:     var registeredTypes = new QueryableContainerExtension();

       7:     container.AddExtension(registeredTypes);

       8:  

       9:     // Register the classes to the container

      10:     container.Register<IMyInterface, MyClass>();

      11:  

      12:     // See if the type is registered

      13:     Assert.IsTrue(registeredTypes.IsTypeRegistered<IMyInterface, MyClass>());

      14: }

Hope you find this as useful as I did :)

prism v2 – drop 10 (composite application guidance)

erwinvandervalk — Sat, 31 Jan 2009 02:41:41 GMT

Today, we have released what’s likely going to be the last drop of Prism before the final release. You can get the release from:

http://www.codeplex.com/CompositeWPF/Release/ProjectReleases.aspx?ReleaseId=22566

During this iteration, we have mostly worked on documentation, implementing a new UI for the Stock Trader Reference Implementation and fixing some last important bugs.

The most important changes are:

Removed .Silverlight and .Desktop extensions from the Assembly names, both in the Library and in all the Quickstarts.

Renamed RegionExtensions class to RegionContext and RegionExtensions.GetRegionContext() method to RegionContext.GetObservableContext()

Moved RegionExtensions.GetObservableRegion() method from RegionExtensions class to RegionManager class.

Integrated new UI design for Stock Trader Reference Implementation.

Many updates to Documentation

Included API CHM file

Added shortcut .Bat files to make it easier to open the solutions.

Bug fixes

Added missing XML comments to the code of the Composite Application Library.

New UI for Stock Trader Reference Implementation

We felt that the original UI of the Stocktrader RI didn’t give a good impression of the capabilities of WPF and Silverlight. Most of the things we were showing before were also possible with Windows Forms. So for this release, we’ve decided to hire a graphical design company to give our RI a complete makeover, complete with some cool animations.

Before:

After:

Looks a lot better huh?

prism v2 – drop 9 (composite application guidance for wpf and silverlight)

erwinvandervalk — Mon, 19 Jan 2009 22:32:29 GMT

It’s been a while since my last post. Not that the Prism team has been sitting idle though.

Last Friday, we’ve released drop 9 of Prism. As we are approaching the end of the Prism v2 project, there are a lot less API changes, as we are mostly focussing on finishing the docs and resolving bugs. We have also spent some time trying to build different application styles (for example, an outlook style app, or a master-detail style app) on top of our library. The results of this exercise was very useful. Unfortunately, they were nothing more than spikes, so we can’t deliver them as part Prism, but we are thinking of doing a bunch of blog posts or webcasts, that describe how to build different application styles on top of Prism.

You can get drop 9 of Prism here:

http://www.codeplex.com/CompositeWPF/Release/ProjectReleases.aspx?ReleaseId=21912

What’s in Prism drop 9

New skin for the Stocktrader reference implementation.
We wanted to show a bit more of the power of the WPF and Silverlight platform in our RI, so we have hired an external design bureau to create a new design. It has taken a bit longer to implement than we had hoped. In this drop, we have some of the basic styling in place. Hopefully, we can get the next styling
Desktop only solutions
Not everybody is interested in developing on both WPF and Silverlight. So that’s why we’ve added ‘WPF’ only solutions. We can’t really add Silverlight only solutions as easily, because the Silverlight projects are linking all the files from the WPF projects.
New SingleActiveWindowRegionAdapter in the RI
We are demonstrating how to create an adapter in the RI, in this case how to create a popup window and use that as a region.
Several bugs fixed
Lots of testing, prioritizing, bugfixing, retesting, etc..
Exception stack compression in combination with Unity
Unity is an awesome DI container, but it doesn’t give really clear exception messages if something goes wrong.

The last weeks of a project are always interesting. There are _so_ many ‘little’ things we would have wanted do do, or add to the library. but what seems like a small dev effort, can quickly add up if you also count the test and doc effort. So, we are constantly keeping a critical eye on our prioritized backlog of tasks. Unfortunately, this means there are a bunch of really interesting stuff we would have loved to tackle, but we can’t.

Exception stack compression

While building different application styles on top of Prism, we found an interesting problem.

Suppose the following example: You are creating a simple view. In the Module.Initialize(), you are registering the type of the view against a region that’s displayed in the shell. In the constructor of the view, you have made a small programming error, which causes an exception.

So what’s the result?

A module initialize error. Ok, that makes sense. But what was the exception message inside that? “Exception occurred at target of invocation.”. And inside that? A bunch of ServiceLocator, Unity and Objectbuilder errors. Only somewhere at the bottom of the inner exception list you find the exception that caused the problem.

All these exceptions are perfectly valid from a technical point of view, but not very useful in understanding what’s going wrong. Ideally, Unity should return a very clear exception message: “Tried to create object X, but could not because of this error message: ‘xyz’”. Unfortunately, Unity does not do this. (After a discussion with the enterprise library team, it turns out that it’s really hard to build this in Unity). I think that developers who are building applications on top of Prism are rarely interested how exactly the DI container builds up it’s objects. So all the technical inner exceptions are just clutter to them, that’s obscuring what’s really going wrong.

So we have built some logic to try and find the error in the stack trace that actually points developers in the right direction. The goal was to be able to get the following exception message: “An exception occurred while initializing module X, in the constructor of View X, with exception message “XYZ”.

So now in Prism, you can use the extension method exception.GetRootException() to try and find the exception that’s actually causing the problem. It won’t be 100% accurate, but it looks like it really helps in getting to the root of the problem more quickly.

Hopefully you will find this useful to!