MVVM - RaisePropertyChanged turning code into a mess

New to MVVM so please excuse my ignorance.

I THINK i'm using it right but I find my ViewModel has too many of these:

RaisePropertyChanged("SomeProperty")

Every time I set a property I have to raise that damned property changed.

I miss the days where I could just go:

public int SomeInteger { get; private set;}

These days I have to stick the "RaisePropertyChanged" in everywhere or my UI does not reflect the changes :(

Am I doing it wrong or are other people getting annoyed with the excessive number of magic strings and old开发者_运维百科 school property setters?

Should I be using dependency properties instead? (I doubt that would help the code bloat anyway)

Despite these problems I still think MVVM is the way to go so I guess that's something.

Take a look at this What is the best or most interesting use of Extension Methods you've seen?.

It describes an extension method and a helper method that my Model and ViewModel classes use to enable the following strongly typed (no magic string) properties.

private string _name;
public string Name
{
    get { return _name; }
    set { this.NotifySetProperty(ref _name, value, () => this.Name); }
}

This is about as simple as I think it can get. Hope it helps.

You could use PostSharp's NotifyPropertyChanged attribute. Then all you have to do is to put an attribute on the class and that's it. E.g.:

[NotifyPropertyChanged]
public class MyClass 
{
    public string MyProperty { get; set; }
}

It helps to look at things from a different perspective: those are not complicated .NET properties, but simplified dependency properties.

Bindable properties of a view model in WPF are not identical to .NET properties, instead it is a kind of key-value store. If you want light-weight alternative to DependencyObject, you have an ability to implement this key-value store just buy calling certain function in setters - not bad, actually. Far from ideal too, of course, but your point of view is certainly unfair.

It does not get you back to the clean code, but I use a simple extension method to get the property name to avoid problems with magic strings. It also maintains the readability of the code, i.e. it is explicit what is happening.

The extension method is simply as follows:

public static string GetPropertyName(this MethodBase methodBase)
{
    return methodBase.Name.Substring(4);
}

With this it means that you property sets are resilient against name changes and look like the following:

private string _name;
public string Name
{
    get { return _name; }
    set 
    {
            name = value;
            RaisePropertyChanged(MethodBase.GetCurrentMethod().GetPropertyName()); 
    }
}

I've written more about this extension method here and I've published a matching code snippet here.

This will help: "Kind Of Magic" Effortless INotifyPropertyChanged

[http://visualstudiogallery.msdn.microsoft.com/d5cd6aa1-57a5-4aaa-a2be-969c6db7f88a][1]

as an example for adding it to one property:

[Magic] 
public string Name { get { return _name; } set { _name = value; } } 
string _name;

Another example for adding it to all the class properties:

[Magic] 
public class MyViewModel: INotifyPropertyChanged 
{ 
  public string Name { get; set; } 
  public string LastName { get; set; } 
  ..... 
}