A better way to write MVVM boilerplate code?

Question

I have found myself recently writing a lot of boilerplate MVVM code and wonder if there is a fancy way to get around writing it all? I already use a ViewModelBase class that implements INotifyPropertyChanged but that doesnt solve the problem of having to write all the accessor code etc. Perhaps by writing a custom attribute that does this, or via a templating system?

public MyClass : ViewModelBase
{
    private int someVariable;

    public int SomeVariable
    {
        get
        {
            return this.someVariable;
        }

        set
        {
            this.someVariable = value;
            this.NotifyPropertyChanged("SomeVariable");
        }
    }
}

[This answer](http://stackoverflow.com/a/16619858/389966) should help. — Adi Lester, Nov 18 '13 at 15:25
**Small improvement:** get rid of `this.` - as per ReSharper, that's redundant. **Small improvement #2:** use `Expression` based strongly typed `NotifyPropertyChange()` and avoid magic strings. — Federico Berasategui, Nov 18 '13 at 15:28
`this.` is redundant but we use `StyleCop` to ensure code legibility which states it is required (it does make maintenance & readability easier) — Chris, Nov 18 '13 at 15:29
Following the link in @AdiLester's comment (http://danrigby.com/2012/03/01/inotifypropertychanged-the-net-4-5-way/), I think it could be made even shorter by using a decorator to point to the backing field. — rikkit, Nov 18 '13 at 15:30
You could also look at [This answer](http://stackoverflow.com/a/15636406/1834662) in particular [PropertyChanged.Fody](https://github.com/Fody/PropertyChanged) which automates the implementation of INPC — Viv, Nov 18 '13 at 15:32
Another way to avoid magic strings is to use the [CallMemberNameAttribute](http://msdn.microsoft.com/en-us/library/system.runtime.compilerservices.callermembernameattribute(v=vs.110).aspx). However, this can only be used inside the setter of a property, and if some properties depend on each other you still have to use magic strings to express these dependencies. — Martin Liversage, Nov 18 '13 at 15:35
@rikkit I love the way thats done but we only use .NET 4 so cannot use it. Will this decorator method you talk about work with .NET 4? — Chris, Nov 18 '13 at 15:35
Just in case you aren't aware of it, [MVVM Light](http://mvvmlight.codeplex.com/) helps with this. — JMK, Nov 18 '13 at 15:45
@Chris Looks like the property changed plugin for Fody (https://github.com/Fody/PropertyChanged) does support .Net 4. Seems to resolve dependencies between properties too, not sure if you can disable on a property-by-property basis though. — rikkit, Nov 18 '13 at 15:46

Gusdor · Accepted Answer · 2013-11-18T16:27:43.463

I have a snippet that i use to create my view model properties. This particular snippet uses the Expression<Func<T>> notation that other commenters have hinted upon.

<?xml version="1.0" encoding="utf-8"?>
<CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
  <CodeSnippet Format="1.0.0">
    <Header>
      <SnippetTypes>
        <SnippetType>Expansion</SnippetType>
      </SnippetTypes>
      <Title>View Model Property</Title>
      <Description>
          Declares a property and member suitable for Viewmodel implementation.
      </Description>
      <HelpUrl>
      </HelpUrl>
      <Shortcut>propvm</Shortcut>
    </Header>
    <Snippet>
      <Declarations>
        <Literal Editable="true">
          <ID>propname</ID>
          <ToolTip>Property Name</ToolTip>
          <Default>Name</Default>
          <Function>
          </Function>
        </Literal>
        <Literal Editable="true">
          <ID>type</ID>
          <ToolTip>Property type.</ToolTip>
          <Default>Type</Default>
          <Function>
          </Function>
        </Literal>
        <Literal Editable="true">
          <ID>init</ID>
          <ToolTip>Member initialisation</ToolTip>
          <Default>null</Default>
          <Function>
          </Function>
        </Literal>
      </Declarations>
      <Code Language="csharp" Kind="type decl"><![CDATA[public $type$ $propname$
{
    get { return m_$propname$; }
    set 
    { 
        m_$propname$ = value;
        base.OnPropertyChanged(() => $propname$);
    }
} $type$ m_$propname$ = default($type$);$end$]]></Code>
    </Snippet>
  </CodeSnippet>
</CodeSnippets>

Note the call to base.PropertyChanged(). I have a ViewModelBase class to do the heavy lifting of property notification and validation for me.

Usage is this:

Type propvm
Hit TAB twice
Fill in the highlighted field and press tab to flip to the next one!

Walkthrough : Creating a code snippet

I agree with this. I have been using similar snippet for the past 3 years. — Eugene S., Nov 18 '13 at 16:28

Markus · Answer 2 · 2013-11-18T16:30:49.273

Aspect oriented programming (AOP) is a way to reduce the amount of such boilerplate code. A framework that is widely known is PostSharp. There also is a free Express edition.
You use attributes (either on the classes directly or as a multicast to all points in code that satisfy a specific set of conditions) to mark the spots where the code should be integrated and PostSharp weaves in the implementations during build. You can find an example for the implementation of INotifyPropertyChanged here.
An AOP based approach (no matter which framework you use) has the advantage that you can change the implementation afterwards and that these changes are reflected in the existing code base. It is also possible to apply the aspects to a big number of already existing classes.

score 0 · Answer 3 · answered Nov 18 '13 at 16:15

Wow... that's a lot of answering in the comments and not so much in the answers. As an alternative to the lovely new CallerMemberNameAttribute attribute, how about Visual Studio Macros? I have a number of these that fully implement all of my interfaces (both custom and .NET) for me at the click of a mouse button.

Downside to using Macros:

You write them using Visual Basic
It can take a while to write a long one
They can contain errors like any code

Upside to using Macros:

You can 'record' simple Macros as you type
You can build up complex Macros that can work with current context
They can write thousands of words at the click of a mouse button

For example, I can create a class file, defining just the class name, base class and/or interfaces. After declaring the private member variables, I can run my custom Macro and it will read the names and types of the variables and generate constructors, properties and all methods required by the base classes and/or interfaces used. However, this particular Macro is almost 600 lines long.

stijn · Answer 4 · 2013-11-18T16:54:17.150

First of all and as mentioned already, use a snippet to create the code for you. Then there are a couple of libraries that can help you with it, or AOP.

And here's something I've been using for a while in applications where raw ui performance on simple controls is irrelevant: a helper class with a Dictionary<string,object> to hold the actual property backends, and methods to get/set properties of any type, taking an expression as argument in order to avoid using string literals. When using this, a property comes down to

public int SomeProperty
{
  get { return properties.Get( model => model.SomeProperty ); }
  set { properties.Set( model => model.SomeProperty, value ); }
}

also that Set call returns true when the value really changed as that is often useful.

Here's some code, with the usual 'use at own risk' etc warning. You just need a NotifyPropertyChangedHelper implementation but that can be found easily (search the net for 'propertychanged helper' for instance, pretty sure it was posted on SO as well)

public class NotifyPropertyChangedMap<T> where T : INotifyPropertyChanged
{
  #region Fields
  private readonly T propertyContainer;
  private readonly Dictionary<string, object> properties;
  #endregion

  #region Constructors
  public NotifyPropertyChangedMap( T propertyContainer )
  {
    Contract.Requires<ArgumentNullException>( propertyContainer != null, "propertyContainer" );

    this.propertyContainer = propertyContainer;
    this.properties = new Dictionary<string, object>();
  }
  #endregion

  #region Get and Set
  public Property Get<Property>( Expression<Func<T, Property>> expression )
  {
    var propName = NotifyPropertyChangedHelper.GetPropertyName( expression );
    if( !properties.ContainsKey( propName ) )
      properties.Add( propName, GetDefault<Property>() );
    return (Property) properties[ propName ];
  }

  public bool Set<Property>( Expression<Func<T, Property>> expression, Property newValue )
  {
    var propName = NotifyPropertyChangedHelper.GetPropertyName( expression );
    if( !properties.ContainsKey( propName ) )
    {
      properties.Add( propName, newValue );
      propertyContainer.RaisePropertyChangedEvent( propName );
    }
    else
    {
      if( EqualityComparer<Property>.Default.Equals( (Property) properties[ propName ], newValue ) )
        return false;
      properties[ propName ] = newValue;
      propertyContainer.RaisePropertyChangedEvent( propName );
    }
    return true;
  }
  #endregion

  #region Implementation
  private static Property GetDefault<Property>()
  {
    var type = typeof( Property );
    return (Property) ( type.IsValueType ? Activator.CreateInstance( type ) : null );
  }
  #endregion
}

score 0 · Answer 5 · answered Nov 19 '13 at 13:35

0

Use a snippet like "mvvmprop" There are many out there that are available already written just for this purpose, including MVVM Lite's implementation.

answered Nov 19 '13 at 13:35

Greg Gum

33,478
39
162
233

A better way to write MVVM boilerplate code?

5 Answers5

Linked