听听依赖属性的变化


Answers:


59

如果它DependencyProperty是一个单独的类,则最简单的方法是将一个值绑定到它,并听取对该值的更改。

如果DP是您要在自己的类中实现的DP,则可以在创建时注册PropertyChangedCallbackDependencyProperty。您可以使用它来监听属性的更改。

如果使用子类,则可以使用OverrideMetadata将自己的子集添加PropertyChangedCallback到将被调用的DP中,而不是任何原始子类。


11
根据MSDN和我的经验,(提供的元数据的)某些特性...其他特性(例如PropertyChangedCallback)被组合在一起。因此,除了现有的回调外,还将调用您自己的PropertyChangedCallback ,而不是
Marcel Gosselin


可以在答案中添加此说明吗?我认为OverrideMetadata将替代父级的回调,这使我无法使用它。
用户名

1
我同意,这不是很清楚:“最简单的方法是将值绑定到该值,并听取该值的更改”。一个示例将非常有帮助
UuDdLrLrSs

153

此方法肯定在这里缺失:

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

67
请非常小心,因为它很容易引起内存泄漏!始终使用descriptor.RemoveValueChanged(...)
CodeMonkey


2
这适用于WPF(这是该问题的目的)。如果您在这里寻找Windows存储解决方案,则需要使用绑定技巧。发现此博客文章可能会有所帮助:blogs.msdn.com/b/flaviencharlon/archive/2012/12/07/…可能也可以与WPF一起使用(如以上答案中所述)。
Gordon

2
@Todd:我认为泄漏是相反的,由于对处理程序的引用,视图可能会使您的视图模型保持活动状态。在处理视图时,订阅也应该消失。我认为人们对事件处理程序的泄漏有点太偏执,通常这不是问题。
HB

4
@HB在这种情况下DependencyPropertyDescriptor具有应用程序中所有处理程序的静态列表,因此处理程序中引用的每个对象都会泄漏。它不像普通事件那样工作。
ghord's

19

我写了这个实用程序类:

  • 它为DependencyPropertyChangedEventArgs提供新旧值。
  • 源存储在绑定中的弱引用中。
  • 不知道公开Binding&BindingExpression是否是一个好主意。
  • 没有泄漏。
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);
    }
}

如果绑定是OneWay,为什么要设置UpdateSourceTrigger?
马斯洛

6

有多种方法可以实现此目的。这是一种将依赖属性转换为可观察属性的方法,以便可以使用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));
        });
    }
}

用法

切记要处置预订以防止内存泄漏:

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);
    }
}

4

您可以继承要尝试监听的控件,然后直接访问:

protected void OnPropertyChanged(string name)

没有内存泄漏的风险。

不要害怕标准的OO技术。


1

如果是这种情况,请使用hack。您可以使用引入静态类DependencyProperty。源类也绑定到该dp,而目标类也绑定到DP。

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.