Make OnPropertyChanged events safe for refactoring

Be aware: expressions take a LOT of time to evaluate (relative to a constant string), and will make writing values to properties slow.

I think that the solution is to a problem that has limited risk. What I mean is if you need to rename a property, then the call to the OnPropertyChange is nearby in the setter, so it is simple, and obvious to change both at the same time. Also, if you have a backing field, then it should be renamed as well. Of course you can avoid this by using a Dictionary, but that slows down reads as well. One more thing, you will need to make sure the target of the OnPropertyChange (which expects a string propertyName) gets modified as well.

If you feel that you must use expressions, create a separate field for them, and set them once in the constructor, instead of evaluating them each time in the property setter, or use a lazy instantiator.

Alternately:

Refactoring solutions (i.e. Resharper) will look in constant strings and suggest them (to rename) if they match solving both the source and target problems mentioned above.

Example of property:

public string MyProp {get{return _MyProp;}set{Set("MyProp", ref _MyProp, value);}} string _MyProp;

You could just create a "snippet" of the above.

BTW, the Set methods signature is...

protected void Set<t>(string propertyName, ref T property, T newValue) {...}</t>

...which allows you to check to see if the OnPropertyChanged needs to be called, or even OnPropertyChanging (argh, <rant> useless, it needs to be cancellable )