Because the image of the diagram is pretty big, I decided to use Silverlight DeepZoom and the result is just below this text You can download the full image resolution here. Please use the full screen button in the upper right corner of the viewer for the best browsing experience.

Here are general remarks that might help you get information from those diagrams.

The top level Control class:

• Defines general UI properties such as Background, Foreground, BorderBrush and BorderThickness
• Defines a set of properties to control font rendering: FontFamily, FontSize, FontStyle…
• Has a DoubleClick event (other mouse events such as MouseUp/MouseDown comes from the UIElement class)

Below the Control class, we have (this list is not complete):

• The ContentControl class: those controls have… a single Content
• The ItemsControls class which handles a collection of child controls
• The TextBoxBase class which is the parent of TextBox and RichTextBox
• The RangerBase class which handles a range (minimum, maximum) and which is the parent of the ScrollBar, Slider and ProgressBar classes
• The Thumb class which has the ability to be dragged over a surface

Below the ContentControl class we can find many existing WPF controls:

• ButtonBase and its child: Button, ToggleButton and RepeatButton
• Label (see this post for an explanation of the differences between a Label and a TextBlock)
• ListBoxItem and its children: ListViewItem, ComboBoxItem
• ScrollViewer
• HeaderedContentControl, a ContentControl that has both a Content and a Header. This is the case of the Expander, GroupBox and TabItem controls
• Tooltip
• Window
• UserControl

General other remarks:

• It’s funny to see that both Window and UserControl inherits from ContentControl. Before doing the diagram I though that Window came from somewhere else
• Having those diagrams in mind (or on a screen !) is very useful when you need to create your own custom control
• We can see the differences between creating a custom control (inherit from Control or derived class) and a UserControl (inherit from UserControl)
• .Net4 will introduce new controls (not in this diagram) in the WPF framework such: DataGrid, Calendar, TimePicker

January

• XAML guidelines: interviews of WPF masters
• photoSuru: a WPF application with spectacular user experience
• Model-View-ViewModel, Commands and InputBindings
• Filtering with or without ICollectionView ?
• Why do I love Extension Methods in System.Linq ?
• Using extension methods to raise an event

February

• Very simple MVVM demo application
• VS2010 UI

March

• French article about MVVM posted !
• Thinking with MVVM: Data Templates + ContentControl
• MIX09 starts today !
• First look at Expression Blend 3 !
• The future of WPF at Mix09

April

• Adding transitions to a MVVM based dialog

May

• Browse your codebase like a pro with ReSharper
• Visual Studio 2010: Beta1 available with .Net4 and WPF4 included
• .Net4, WPF4 and VS2010 interesting links

July

• BezierSegment demo application

August

• Learn how .Net manages memory in 15min
• WPF possible memory leak with EventManager.RegisterClassHandler

September

• How to close a View from a ViewModel ?

October

• A quick tour of existing MVVM frameworks
• The cost of building Visual Trees
• Announcing the “WPF internals” series
• Analyzing events usage using a R# plugin
• WPF internals part 1 : what are the core WPF classes ?
• VS2010 Beta 2 coming today !
• How to measure rendering time in a WPF application ?

November

• Using Snoop to take a look at VS2010 !
• PDC09: some announcements
• PDC09: some WPF sessions are available !
• PDC09: Advanced WPF Application Performance Tuning
• PDC09 : How VS2010 was built with WPF ?
• Discover and compare existing MVVM frameworks !

The first approach is to measure the elapsed time needed to instantiate and populate the control from C# code. We can use the StopWatch class to have a precise and easy to use measuring tool.

1
2
3
4
5
6
7
8
9
10
11

Stopwatch sw = new Stopwatch();
sw.Start();
 
for (int i = 0; i < 5000; i++)
{
  // here is the operation that fills the control
  this.canvas.Children.Add(new Rectangle());
}
 
sw.Stop();
MessageBox.Show("Took " + sw.ElapsedMilliseconds + " ms");

However this approach will not give good results because we’re not taking into account the time needed to render elements in the visual tree. This is because elements are not rendered when you call the Add methods (for example in a Canvas) but when the visual tree is fully loaded.

A much better approach is to use the Dispatcher and request it to process an action at a priority right bellow the Render priority which is the Loaded priority:

Using this trick, we ensure that all rendering actions have been completed. We can use the following code to do that:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Stopwatch sw = new Stopwatch();
sw.Start();
 
for (int i = 0; i < 5000; i++)
{
  // here is the operation that fills the control
  this.canvas.Children.Add(new Rectangle());
}
 
this.Dispatcher.BeginInvoke(
  DispatcherPriority.Loaded,
  new Action(() =>
  {
    sw.Stop();
    MessageBox.Show("Took " + sw.ElapsedMilliseconds + " ms");
  }));

Hope this helps !

Knowing the organization of WPF classes is important when we create a new control because we have to determine which base class we’re going to use. It is also interesting to know how the framework has been designed. That’s the goal of this first article.

Here is an image of the core WPF classes and how they are related (click for larger resolution):

The diagram is voluntary simple above the Control classes because that will be targeted by another article.

The most common way to create a leak is to register to an event handler on a object that has a longer lifetime than the object where the handler is defined. The problem can also occurs by using static class such as EventManager (for more information see this blog post). Some .Net developers have been working on a way to go round the problem using Reflection, Weak Reference and other cool stuff. You can check out for example this excellent article on Code Project.

However, if you cannot change the way your declare events (because of internal policies in the company or because you don’t have the source code), you must be very carefull about the way you manage your events.

I’ve been working lately on a Resharper plugin that helps detecting events that are never unsubscribed. Basically, what is does is the following:

I’d like to have feedback from you .Net developpers, about whether you find such a plugin useful or not.

• How do you deal with the event memory leak problem ?
• Would you like to use my plugin ?
• Would you like me to release it on a open source platform ?
• What other kind of possible leaks are you thinking about to enhance the plugin ?

Please write a comment to let my know what you think. Thank you for your feedback !

One year ago MVVM wasn’t very famous. I remember the first article I read about it, about using MVVM to simplify the management of treeview controls. In the last six months, MVVM has been quickly promoted to THE methodology to use when developing WPF applications. During this amount of time, famous WPF developers started to merge their existing MVVM classes into libraries. Those libraries are now known as MVVM frameworks and contain classes designed to help developers to use MVVM in their projects.

In this article, I’m going to make a quick tour of the available MVVM frameworks.

If your own framework is not in this list or if I made a mistake while describing your work, please let me know using the contact form (available at the top of this page).

Common features:

• ViewModelBase class (for the implementation of the INotifyPropertyChanged interface)
• RelayCommand like class to link UI command to ViewModel’s handlers
• Unit tests comes with the framework

Cinch

• Author: Sacha Barber
• Silverlight support: no
• Documentation: excellent, 6 articles published on CodeProject
• Hosting : CodePlex
• License:  Code Project Open License
• Features:
  • attached behaviors
  • validation suing IDataErrorInfo
  • support for IEditableObject
  • weak events creation and subscription
  • mediator messaging using weak events
  • IOC/DI support (using Unity)
  • services: event logger, message box, open save dialog, popup
  • threading helpers
  • support for menu items
  • closeable viewmodels
  • MVVM code generator

MVVM Light Toolkit

• Author: Laurent Bugnion
• Silverlight support: yes
• Documentation: many articles available on Laurent’s blog + other developers as well
• Hosting: CodePlex
• License: MIT license
• Features:
  • MSI installer
  • VS project and item template
  • VS code snippets
  • Messenger system for inter-viewmodel communication

MVVM Helpers

• Author: Mark Smith
• Silverlight support: no
• Documentation: some articles on Mark’s blog
• Hosting: personal website
• License: not defined
• Features:
  • attached behaviors
  • viewmodel creation using markup extension
  • attributes based validation
  • IOC/DI using ServiceProvider approach
  • closeable viewmodel
  • wait cursor (using new WaitCursor() { // your code here })

MVVM Foundation

• Author: Josh Smith
• Silverlight support: no
• Documentation: articles about the Messenger implementation on Josh or Marlon Grech’s blog
• Hosting: CodePlex
• License: MS-PL
• Features:
  • Messenger system for inter-viewmodel communication
  • PropertyChanged event monitor

Caliburn

• Author: Rob Eisenberg
• Silverlight support: yes
• Documentation: complete online documentation available
• Hosting: CodePlex http://www.codeplex.com/caliburn
• License: MIT license
• Features:
  • commands are built on top of Actions and thus share many of the same features, including multiple input parameters, filters and automatic asynchronous execution
  • presenters that handles UI lifecycle issue such as handling activation, deactivation and shutdown semantics for various UI components
  • Caliburn applications are fully testable
  • various utilities such as a background task manager
  • supports various UI pattern (not MVVM only)
  • dependency injection container

Onyx

• Author: William e Kempf
• Silverlight support: no
• Documentation: basic introduction available on CodePlex
• Hosting: CodePlex
• License: not specified
• Features:
  • ServiceLocator pattern
  • ViewModel creation using a custom markup extension
  • UI related services such as IDisplayMessage

Calcium

• Author: Daniel Vaughan
• Silverlight support: no
• Documentation: 2 very detailed articles on CodeProject (part1 and part2)
• Hosting: CodePlex
• License: use, copy, modify, and/or distribute and keep the copyright!
• Features:
  • Module Manager for enabling or disabling of modules at runtime
  • messaging services for interacting with the user from the client or server using the same API
  • Command Service to associate WPF ICommands with content interfaces that only become active when an active view or viewmodel implements the interface
  • Region Adapters for ToolBars and Menus
  • Client-server logging ready to work out-of-the-box
  • Includes modules, such as a Web Browser, Text Editor, Output Window, and many more
  • Tabbed interface with dirty file indication (reusable across modules)

nRoute

• Author: Rishi
• Silverlight support: yes
• Documentation: many articles available on author’s blog (see CodePlex project home page for the links)
• Hosting: CodePlex
• License: MS-PL
• Features:
  • support Blend3 behaviors and triggers models
  • resource locator framework
  • view services: OpenFileDialog, ShowMessage…
  • uses attributes to map View and ViewModel together

Nito MVVM

• Author: Shammah
• Silverlight support: no
• Documentation: no
• Hosting: CodePlex
• License: not specified
• Features:
  • various MVVM friendly implementations of the ICommand interface

Ocean

• Author: Karl Shifflet
• Silverlight support: no
• Documentation: articles available on Karl’s blog
• Hosting: personal website
• License: not specified
• Features:
  • written in VB.Net
  • attribute based validation
  • viewmodel base classes: relaycommand, closeableviewmodel…
  • SQL server data access layer

Basic MVVM framework

• Author: Lester Lobo
• Silverlight support: no
• Documentation: sample application available with the library
• Hosting: CodePlex
• License: MS-PL
• Features:
  • delegating Commands\Keybinding
  • messaging between VM’s
  • handling events as commands with attached behaviors
  • handling dialogs (and more) as services
  • VS code snippets

GoodLight

• Author: Peter O’Hanlon
• Silverlight support: yes
• Documentation: sample application available with the library
• Hosting: CodePlex
• License: MS-PL
• Features:
  • “workspace” management (set of document that can be closed)
  • skin support
  • messaging between VM’s

As you can see, each frameworks has its pros and cons. If you want a light Silverlight-compatible framework, Laurent’s framework is very nice. If you want a very rich framework, Sacha’s one is excellent. Whatever what your requirements are, each framework is very interesting and browsing the source code is a good way to understrand how stuff works and find cool ideas for your own needs.

To conclude, I’d like to thanks all those people who work very hard for the community ! An interesting discussion started a couple of days ago on the WPF disciples Google group about the creation of a common framework. Have a look here.

If you want to learn how .Net manages memory in details, understand how the garbage collector works,  what is the next object pointer, how finalizers are managed (and much more !), you should check it out this cool video made by the guys of ANTS Profiler:

source video

Since monday it is available to all MSDN subscribers, and will be avaible to the rest of the world on wednesday. Documentation has also been updated to show the new features of this release.

The download is on its way and I’ll try to post feedback as soon as I can, stay tuned !

Here are the results… If I want:

• to find a Type I hit Ctrl+T
• to find a File I hit Ctrl+Shift+T
• to find a Member (in a file) I hit Ctrl+Alt+T (Note: I setup this one on my own using Tools/Options/Keyboard)

A search box opens and I can start searching instantaneously.

Here are the basic scenarios :

• I want to open the ViewModelBase class, I hit Ctrl+T and then VMB (R# is able to search using capital letters)
• I want to go to the OnPropertyChanged, I hit Ctrl+Alt+T and then OPC (same as previous example)
• Finally, to open the file in the Solution Explorer I hit Shift+Alt+L

It’s simply amazing the time we can save using those simple shorcuts. Of course, you need to be quite familiar with your codebase (if you just arrive on a project it will be harder :p)

MIX09 is now over and the good news is that we can watch all sessions that have been recorded online !

I didn’t have time yet to watch all sessions I’m interested in, but I already saw “What”s new in WPF 4″ video (available here).

Here are the important points of this session regarding the future of WPF:

• Lot of new things are coming in WPF4: Text clarity improved, Multi-touch, Windows7 integration, Ribbon control, Focus management improvements, Visual State Manager, Client profile, Themes, Chart controls and a lot of bug fixes…
• WPF4 will come together with .Net4 which brings its own set of cool new stuff: Dynamic Language, MEF, F#, parallel library
• WPF will be the best choise for RAD under Windows7: Multi-touch, Taskbar integration, Ribbon, Common dialogs, File explorer customization…
• Multi-touch support: UIElement changes to manage touch related events, touch support is added for some controls (ScrollViewer)
• New composition API: developers can control graphical elements cached in video memory
• Controls that are currently available in the WPF toolkit will be integrated into the platform (DataGrid, DatePicker…) – moreover an update of the toolkit has just been released
• Developers tools are improved: VS2010 and Blend3 helps the usage of WPF (databinding support…)
• .Net4 will come with a new XAML parser: faster, extensible, public API to manage BAML format
• .Net4 XAML language has new XAML features: support for generics, better references by name

I hope will see a CTP soon so that we’ll start playing with those new features