Silverlight监听属性变化

现有两个DataGrid：A、B，A是母表，B是子表。即B是A集合的一部分，当点击A的不同行时，B发生变化，列出选中行的详细。

简单来说，B的ItemsSource是不断变化的。那怎么监听B的ItemsSource呢，当ItemsSource变化时，有通知事件？首先想到的是依赖属性，但依赖属性只会跑一次，实现不了监听的功能。在谷歌上，找到一篇博客，实现我的功能。

http://blog.thekieners.com/2010/08/27/listening-to-dependencyproperty-changes-in-silverlight/

首先，要定义两个类。

DependencyPropertyChangedListener

using System;
using System.Windows;
using System.Windows.Data;

namespace Controls.Query.Helpers
{
    /// <summary>
    /// This class implements a listener to receive notifications for dependency property changes.
    /// </summary>
    public class DependencyPropertyChangedListener
    {
        #region Inner types

        // Helper element to make it possible to use the binding engine to get notified when the source element property changes.
        private sealed class RelayObject : DependencyObject
        {
            private DependencyPropertyChangedListener _listener;

            internal RelayObject(DependencyPropertyChangedListener listener)
            {
                _listener = listener;
            }

            #region Value (DependencyProperty)

            public object Value
            {
                get { return (object)GetValue(ValueProperty); }
                set { SetValue(ValueProperty, value); }
            }
            public static readonly DependencyProperty ValueProperty = DependencyProperty.Register("Value", typeof(object), typeof(RelayObject), new PropertyMetadata(default(object), new PropertyChangedCallback(OnValueChanged)));

            private static void OnValueChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
            {
                object oldValue = (object)e.OldValue;
                object newValue = (object)e.NewValue;
                RelayObject source = (RelayObject)d;
                source.OnValueChanged(oldValue, newValue);
            }

            private void OnValueChanged(object oldValue, object newValue)
            {
                _listener.OnValueChanged(oldValue, newValue);
            }

            #endregion
        }

        #endregion

        #region Events

        /// <summary>
        /// Raises when the dependency property changes.
        /// </summary>
        public event EventHandler<DependencyPropertyValueChangedEventArgs> ValueChanged;

        #endregion

        #region Ctor

        private DependencyPropertyChangedListener()
        {
            // just to make it private
        }

        #endregion

        // holds a reference to the relay object in order that the GC does not collect it
        private RelayObject RelayInstance { get; set; }

        public static DependencyPropertyChangedListener Create(DependencyObject sourceElement, string propertyPath)
        //public static DependencyPropertyChangedListener Create(DependencyObject sourceElement, DependencyProperty property)
        {
            // check input
            if (sourceElement == null)
                throw new ArgumentNullException("sourceElement");
            if (string.IsNullOrWhiteSpace(propertyPath))
                throw new ArgumentException("propertyPath is empty");

            // create listener
            DependencyPropertyChangedListener listener = new DependencyPropertyChangedListener();

            // setup binding
            Binding binding = new Binding();
            binding.Source = sourceElement;
            binding.Mode = BindingMode.OneWay;
            //binding.Path = new PropertyPath(property); // throws exception
            binding.Path = new PropertyPath(propertyPath);

            // create relay object
            RelayObject relay = new RelayObject(listener);
            // ...the listener holds a reference to the relay object in order that the GC does not collect it
            listener.RelayInstance = relay;

            // set binding
            BindingOperations.SetBinding(relay, RelayObject.ValueProperty, binding);

            return listener;
        }

        public void Detach()
        {
            if (this.RelayInstance != null)
            {
                // first: reset member to prevent further eventing of ValueChanged event.
                RelayObject temp = this.RelayInstance;
                this.RelayInstance = null;

                // second: clear the binding -> raises property changed event...
                temp.ClearValue(RelayObject.ValueProperty);
            }
        }

        private void OnValueChanged(object oldValue, object newValue)
        {
            // raise event, but only if the listener is not detached.
            if (ValueChanged != null && this.RelayInstance != null)
                ValueChanged(this, new DependencyPropertyValueChangedEventArgs(oldValue, newValue));
        }
    }
}

DependencyPropertyValueChangedEventArgs，继承EventArgs

using System;

namespace Controls.Query.Helpers
{
    /// <summary>
    /// Provides data for a DependencyPropertyChangedListener ValueChanged implementation.
    /// </summary>
    public class DependencyPropertyValueChangedEventArgs : EventArgs
    {
        internal DependencyPropertyValueChangedEventArgs(object oldValue, object newValue)
        {
            OldValue = oldValue;
            NewValue = newValue;
        }

        /// <summary>
        ///  Gets the value of the property before the change.
        /// </summary>
        public object OldValue { get; private set; }

        /// <summary>
        /// Gets the value of the property after the change.
        /// </summary>
        public object NewValue { get; private set; }
    }
}

在引用的地方这样写

private DependencyPropertyChangedListener listener;
       
public MainPage()
{
    InitializeComponent();

    listener = DependencyPropertyChangedListener.Create(this, "BindingGrid.ItemsSource");
    listener.ValueChanged += ListenerValueChanged;
}

void ListenerValueChanged(object sender, DependencyPropertyValueChangedEventArgs e)
{
     var itemsSource = BindingGrid.ItemsSource;
            if (itemsSource != null)
            {
                //SourceInitialized(itemsSource);
            }
}

 public DataGrid BindingGrid
        {
            get { return (DataGrid)GetValue(BindingGridProperty); }
            set { SetValue(BindingGridProperty, value); }
        }

 public static readonly DependencyProperty BindingGridProperty =
            DependencyProperty.Register("BindingGrid", typeof(DataGrid), typeof(ConfigurableQueryer),
                                        new PropertyMetadata(null, OnBindingGridChange));

//只跑一次
 private static void OnBindingGridChange(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var configurableQueryer = sender as ConfigurableQueryer;
            var dg = e.NewValue as DataGrid;
}