Question: When should I use dependency properties in WPF?

They are static, so we save a lot on memory, compared to using .NET properties.
Other gains of using dependency properties over .NET properties are:
1) no need to check thread access
2) prompt a containing element to be rendered
etc...

So it seems I should ALWAYS use dependency properties in my projects where I use WPF?

Maybe for some trivial properties of helper classes here and there I could
get away with .NET properties...

Answer: 
![enter image description here](https://i.stack.imgur.com/wWrC7.jpg)

**CLR Property vs. Dependency Property**

A CLR property reads directly from the private member of the class. The Get() and Set() methods of the class retrieve and store the values of the property. 
Whereas when you set a value of a Dependency Property it is not stored in a field of your object, but in a dictionary of keys and values provided by the base class DependencyObject. The key of an entry is the name of the property and the value is the value you want to set.

**Advantages of a Dependency Property
Less memory consumption**

The Dependency Property stores the property only when it is altered or modified. Hence a huge amount of memory for fields are free.

**Property value inheritance**
It means that if no value is set for the property then it will return to the inheritance tree up to where it gets the value.

**Change notification and Data Bindings**
Whenever a property changes its value it provides notification in the Dependency Property using INotifyPropertyChange and also helps in data binding.

**Participation in animation, styles and templates**
A Dependency Property can animate, set styles using style setters and even provide templates for the control.

**CallBacks**
Whenever a property is changed you can have a callback invoked.

**Resources**
You can define a Resource for the definition of a Dependency Property in XAML.

**Overriding Metadata**
You can define certain behaviours of a Dependency Property using PropertyMetaData. Thus, overriding a metadata from a derived property will not require you to redefine or re-implement the entire property definition.
Dependency properties are used when you want data binding in a `UserControl`, and is the standard method of data binding for the WPF Framework controls. DPs have [slightly better binding performance](https://stackoverflow.com/questions/570684/inotifypropertychanged-vs-dependencyproperty), and everything is provided to you when inside a `UserControl` to implement them.

Otherwise, you typically use `INotifyPropertyChanged` for binding elsewhere, since it's easier to implement in stand-alone classes and has less overhead. As far as your original assumptions:

1. There is a local instance of your variable, you definitely do not save any overhead over a property since there is significant data binding logic built-in.
2. [They must be accessed on the main thread](https://stackoverflow.com/a/783154/93306).