A concise way to define properties for MVVM data binding in C# WPF

Question

Is there a concise way to define properties in a ViewModel for data binding in C# WPF? The following property definition is very verbose, especially when there are lots of properties:

private bool mSomeProperty;

public bool SomeProperty
{
    get { return this.mSomeProperty; }
    set
    {
        if (value != this.mSomeProperty)
        {
            this.mSomeProperty = value;
            OnPropertyChanged(new PropertyChangedEventArgs("SomeProperty"));
        }
    }
}

Answer 1

If you're using the Delphi Prism language (Pascal-based .NET language), you just add the notify keyword, and the compiler automatically implements INotifyPropertyChanged and writes all the boilerplate code for you:

property SomeProperty: bool; notify;

Answer 2

I think you won't get the property declaration much smaller than that, at least not with "normal" ways. You could use an castle interceptor to take care of the event raisal.

public class MyViewModel : INotifyPropertyChanged
{
    public event PropertyChanged;
    public void FirePropertyChanged(string propertyName)
    {
        if (PropertyChanged != null) PropertyChanged(propertyName);
    }

    public virtual string MyProperty { get; set; }
    public virtual string MyProperty2 { get; set; }
}

The interceptor would need to fire the property changed event:

public class PropertyChangedInterceptor : IInterceptor
{
    public void Intercept(IInvocation invocation)
    {
        //Pseudo code
        if (invocation.Method is Property Setter)
        {
            Call FirePropertyChanged of invocation.InvocationTarget ;
        }
    }
}

You just need to make sure that your view model's properties are virtual and your view model is always an proxy and not the view model itself.

Best Regards

Answer 3

In C#, I like to make a base class and put some helper methods on it. Then I make my ViewModels descend from it. This is from memory, but it's something like this:

public class Observable : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    protected void SetProperty<T>(ref T backingField, T newValue,
        string propertyName)
    {
        if (Equals(backingField, newValue))
            return;
        backingField = newValue;
        if (PropertyChanged != null)
        {
            PropertyChanged(this,
                new PropertyChangedEventArgs(propertyName));
        }
    }
}

And, in usage:

public class MyClass : Observable
{
    private bool m_someProperty;

    public bool SomeProperty
    {
        get { return m_someProperty; }
        set { SetProperty(ref m_someProperty, value, "SomeProperty"); }
    }
}

Answer 4

You could always use DependencyProperties and propdp your heart out...

Answer 5

You can consider PostSharp which will allow you to decorate the property (which you could then redefine as an auto property) and inject into the setter the line that fires the NotifyPropertyChanged event. An added benefit is you get rid of the string that is the same as the property name.

It's not ideal because you need that tool and it won't be immediately obvious if you are looking at the code later, but it definitely makes it neater.

I was hoping MSFT would add such an attribute to C# 4 but I guess we'll have to wait for C#5 if at all.

Answer 6

You might find some ideas here:

Best Practices: How to implement INotifyPropertyChanged right? http://compositeextensions.codeplex.com/Thread/View.aspx?ThreadId=53731