侦听依赖项属性的更改

If it's a DependencyProperty of a separate class, the easiest way is to bind a value to it, and listen to changes on that value.

If the DP is one you're implementing in your own class, then you can register a PropertyChangedCallback when you create the DependencyProperty. You can use this to listen to changes of the property.

If you're working with a subclass, you can use OverrideMetadata to add your own PropertyChangedCallback to the DP that will get called instead of any original one.

If that is the case, One hack. You could introduce a Static class with a DependencyProperty. You source class also binds to that dp and your destination class also binds to the DP.

This method is definitely missing here:

DependencyPropertyDescriptor
.FromProperty(RadioButton.IsCheckedProperty, typeof(RadioButton))
.AddValueChanged(radioButton, (s,e) => { /* ... */ });

Caution: Because DependencyPropertyDescriptor has a static list of all handlers in application every object referenced in those handlers will leak if the handler is not eventually removed. (It does not work like common events on instance objects.)

Always remove a handler again using descriptor.RemoveValueChanged(...).

I wrote this utility class:

• It gives DependencyPropertyChangedEventArgs with old & new value.
• The source is stored in a weak reference in the binding.
• Not sure if exposing Binding & BindingExpression is a good idea.
• No leaks.

using System;
using System.Collections.Concurrent;
using System.Windows;
using System.Windows.Data;


public sealed class DependencyPropertyListener : DependencyObject, IDisposable
{
private static readonly ConcurrentDictionary<DependencyProperty, PropertyPath> Cache = new ConcurrentDictionary<DependencyProperty, PropertyPath>();


private static readonly DependencyProperty ProxyProperty = DependencyProperty.Register(
"Proxy",
typeof(object),
typeof(DependencyPropertyListener),
new PropertyMetadata(null, OnSourceChanged));


private readonly Action<DependencyPropertyChangedEventArgs> onChanged;
private bool disposed;


public DependencyPropertyListener(
DependencyObject source,
DependencyProperty property,
Action<DependencyPropertyChangedEventArgs> onChanged = null)
: this(source, Cache.GetOrAdd(property, x => new PropertyPath(x)), onChanged)
{
}


public DependencyPropertyListener(
DependencyObject source,
PropertyPath property,
Action<DependencyPropertyChangedEventArgs> onChanged)
{
this.Binding = new Binding
{
Source = source,
Path = property,
Mode = BindingMode.OneWay,
};
this.BindingExpression = (BindingExpression)BindingOperations.SetBinding(this, ProxyProperty, this.Binding);
this.onChanged = onChanged;
}


public event EventHandler<DependencyPropertyChangedEventArgs> Changed;


public BindingExpression BindingExpression { get; }


public Binding Binding { get; }


public DependencyObject Source => (DependencyObject)this.Binding.Source;


public void Dispose()
{
if (this.disposed)
{
return;
}


this.disposed = true;
BindingOperations.ClearBinding(this, ProxyProperty);
}


private static void OnSourceChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var listener = (DependencyPropertyListener)d;
if (listener.disposed)
{
return;
}


listener.onChanged?.Invoke(e);
listener.OnChanged(e);
}


private void OnChanged(DependencyPropertyChangedEventArgs e)
{
this.Changed?.Invoke(this, e);
}
}

using System;
using System.Windows;


public static class Observe
{
public static IDisposable PropertyChanged(
this DependencyObject source,
DependencyProperty property,
Action<DependencyPropertyChangedEventArgs> onChanged = null)
{
return new DependencyPropertyListener(source, property, onChanged);
}
}

You could inherit the Control you're trying to listen, and then have direct access to:

protected void OnPropertyChanged(string name)

No risk of memory leak.

Don't be afraid of standard OO techniques.

There are multiple ways to achieve this. Here is a way to convert a dependent property to an observable, such that it can be subscribed to using System.Reactive:

public static class DependencyObjectExtensions
{
public static IObservable<EventArgs> Observe<T>(this T component, DependencyProperty dependencyProperty)
where T:DependencyObject
{
return Observable.Create<EventArgs>(observer =>
{
EventHandler update = (sender, args) => observer.OnNext(args);
var property = DependencyPropertyDescriptor.FromProperty(dependencyProperty, typeof(T));
property.AddValueChanged(component, update);
return Disposable.Create(() => property.RemoveValueChanged(component, update));
});
}
}

Usage

Remember to dispose the subscriptions to prevent memory leaks:

public partial sealed class MyControl : UserControl, IDisposable
{
public MyControl()
{
InitializeComponent();


// this is the interesting part
var subscription = this.Observe(MyProperty)
.Subscribe(args => { /* ... */}));


// the rest of the class is infrastructure for proper disposing
Subscriptions.Add(subscription);
Dispatcher.ShutdownStarted += DispatcherOnShutdownStarted;
}


private IList<IDisposable> Subscriptions { get; } = new List<IDisposable>();


private void DispatcherOnShutdownStarted(object sender, EventArgs eventArgs)
{
Dispose();
}


Dispose(){
Dispose(true);
}


~MyClass(){
Dispose(false);
}


bool _isDisposed;
void Dispose(bool isDisposing)
{
if(_disposed) return;


foreach(var subscription in Subscriptions)
{
subscription?.Dispose();
}


_isDisposed = true;
if(isDisposing) GC.SupressFinalize(this);
}
}