I liked Caliburn Micro.  The best thing was that it makes it easy to connect events and methods — where you would normally use a DelegateCommand/ICommand and binding, now you get simple by convention auto wireup.  The worst thing is that using convention to autowire VM to View doesn’t show mock data in Blend for my favorite mock data objects which are subclasses of the VM, so I ended up using explicit bindings in the Xaml and not using a big benefit of Caliburn.

In any case, I’m excited to try out Caliburn Micro and my experience so far has been positive, but more on that later.

1. MVVM is a way for code-addicted developers to deflect attention from the horrible designs they inflict on users
2. MVVM complicates development with little or no compensating benefit
3. There is too much strident, jargon-filled, punishing MVVM rhetoric that alienates the mass of developers

Here is Ward Bell’s post MVVM Backlash.

Here’s the example everyone points you to.

The all purpose EventToCommand class in the MVVM Light Toolkit looks like the most convenient way to get this job done.

For any type of click, retemplating a button and using a ViewModel ICommand for its Command is the way to go.

via Microsoft UK Application Development Consulting

There’s a consensus developing that says dependency properties are usually too heavyweight and people are using INotifyPropertyChanged instead.  I miss the snippet that creates a dependency property, so I made a similar snippet for INotifyPropertyChanged.  You can download the code here.

To make a snippet, just go to Tools / Code Snippets Manager and find a snippet to start with.  I started with the “Define a Dependency Property” snippet since I was doing almost the same thing.  The Snippets Manager will tell you where that file is:

Go to the file system and copy the file to your My Code Snippets folder.  If you highlight the folder in the Code Snippet Manager, it will tell you where it is — you can copy the path from the location field.  The file is an xml file, but needs to be named “.snippet”.

Editing the file is very straightforward and the snippet will be available immediately – no restart needed.

One interesting thing about the code is that I’m using a simple method to do all the work:

I basically combined this CodeProject work with Jeff Yates object.Equals idea from here in order to handle both reference and value types in a single call:

Here’s how the snippet comes out by default (the myNames and type are the replaceable fields):

int _myField;

public int MyProperty
{
    get { return _myField; }
    set
    {
        CheckPropertyChanged("MyProperty",
            ref _myField, ref value);
    }
}

This is the method that does a check and notify in the base class:

protected bool CheckPropertyChanged<T>
      (string propertyName, ref T oldValue, ref T newValue)
      {

            if (!Equals(oldValue, newValue))

            {

                oldValue = newValue;

                RaisePropertyChanged(propertyName);

                return true;

            }

            return false;

        }

MVVM is a proven design pattern in WFP/Silverlight world. Its use helps achieve separation of concerns, frees UI from any logic to enhance testing, and generally makes the code easier to understand and maintain. In many LOB multi-tier applications MVVM is extended to include a presenter class. Presenter usually controls the view model, receives necessary services from dependency injection container and has some logic to populate the view model with business entities and/or reference data and send any changes back. The resulting code is usually pretty clean, easy to maintain and test. This article argues though that most of the code in such presenters to populate the view models is also very mechanical, routine, boring and can be avoided all together by introducing small attribute-based view model framework to declaratively populate view models from service calls and avoid extra coding, and, thus, avoid writing extra mechanical, routine, and boring tests.

If you prefer the “code first” approach VS 2008 solution can be downloaded here: MVVMAttributes.zip

View complete article here…

Jason Dolinger made an excellent MVVM presentation last year.  It starts with a classic WinForms approach then upgrades it to a proper MVVM (Model-View ViewModel) pattern for WPF.  If you’ve ever created a WinForm app (even in VB6 – remember VB6?) and you’ve done your homework about WPF, this presentation will show you how to make a clean, properly separated and testable UI with MVVM.  I worked along with the presentation upgrading a small application I had written — that will take a bit more time, but it’s a great way to really learn.

More details here.

]]> http://goldmanalpha.wordpress.com/2009/11/22/mvvm90/feed 0