Silverlight监听属性变化

最新推荐文章于 2025-08-26 01:29:01 发布

转载最新推荐文章于 2025-08-26 01:29:01 发布 · 187 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/oneivan/archive/2012/07/12/2587775.html

现有两个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

View Code

  1 using System;
  2 using System.Windows;
  3 using System.Windows.Data;
  4 
  5 namespace Controls.Query.Helpers
  6 {
  7     /// <summary>
  8     /// This class implements a listener to receive notifications for dependency property changes.
  9     /// </summary>
 10     public class DependencyPropertyChangedListener
 11     {
 12         #region Inner types
 13 
 14         // Helper element to make it possible to use the binding engine to get notified when the source element property changes.
 15         private sealed class RelayObject : DependencyObject
 16         {
 17             private DependencyPropertyChangedListener _listener;
 18 
 19             internal RelayObject(DependencyPropertyChangedListener listener)
 20             {
 21                 _listener = listener;
 22             }
 23 
 24             #region Value (DependencyProperty)
 25 
 26             public object Value
 27             {
 28                 get { return (object)GetValue(ValueProperty); }
 29                 set { SetValue(ValueProperty, value); }
 30             }
 31             public static readonly DependencyProperty ValueProperty = DependencyProperty.Register("Value", typeof(object), typeof(RelayObject), new PropertyMetadata(default(object), new PropertyChangedCallback(OnValueChanged)));
 32 
 33             private static void OnValueChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
 34             {
 35                 object oldValue = (object)e.OldValue;
 36                 object newValue = (object)e.NewValue;
 37                 RelayObject source = (RelayObject)d;
 38                 source.OnValueChanged(oldValue, newValue);
 39             }
 40 
 41             private void OnValueChanged(object oldValue, object newValue)
 42             {
 43                 _listener.OnValueChanged(oldValue, newValue);
 44             }
 45 
 46             #endregion
 47         }
 48 
 49         #endregion
 50 
 51         #region Events
 52 
 53         /// <summary>
 54         /// Raises when the dependency property changes.
 55         /// </summary>
 56         public event EventHandler<DependencyPropertyValueChangedEventArgs> ValueChanged;
 57 
 58         #endregion
 59 
 60         #region Ctor
 61 
 62         private DependencyPropertyChangedListener()
 63         {
 64             // just to make it private
 65         }
 66 
 67         #endregion
 68 
 69         // holds a reference to the relay object in order that the GC does not collect it
 70         private RelayObject RelayInstance { get; set; }
 71 
 72         public static DependencyPropertyChangedListener Create(DependencyObject sourceElement, string propertyPath)
 73         //public static DependencyPropertyChangedListener Create(DependencyObject sourceElement, DependencyProperty property)
 74         {
 75             // check input
 76             if (sourceElement == null)
 77                 throw new ArgumentNullException("sourceElement");
 78             if (string.IsNullOrWhiteSpace(propertyPath))
 79                 throw new ArgumentException("propertyPath is empty");
 80 
 81             // create listener
 82             DependencyPropertyChangedListener listener = new DependencyPropertyChangedListener();
 83 
 84             // setup binding
 85             Binding binding = new Binding();
 86             binding.Source = sourceElement;
 87             binding.Mode = BindingMode.OneWay;
 88             //binding.Path = new PropertyPath(property); // throws exception
 89             binding.Path = new PropertyPath(propertyPath);
 90 
 91             // create relay object
 92             RelayObject relay = new RelayObject(listener);
 93             // ...the listener holds a reference to the relay object in order that the GC does not collect it
 94             listener.RelayInstance = relay;
 95 
 96             // set binding
 97             BindingOperations.SetBinding(relay, RelayObject.ValueProperty, binding);
 98 
 99             return listener;
100         }
101 
102         public void Detach()
103         {
104             if (this.RelayInstance != null)
105             {
106                 // first: reset member to prevent further eventing of ValueChanged event.
107                 RelayObject temp = this.RelayInstance;
108                 this.RelayInstance = null;
109 
110                 // second: clear the binding -> raises property changed event...
111                 temp.ClearValue(RelayObject.ValueProperty);
112             }
113         }
114 
115         private void OnValueChanged(object oldValue, object newValue)
116         {
117             // raise event, but only if the listener is not detached.
118             if (ValueChanged != null && this.RelayInstance != null)
119                 ValueChanged(this, new DependencyPropertyValueChangedEventArgs(oldValue, newValue));
120         }
121     }
122 }

DependencyPropertyValueChangedEventArgs，继承EventArgs

View Code

 1 using System;
 2 
 3 namespace Controls.Query.Helpers
 4 {
 5     /// <summary>
 6     /// Provides data for a DependencyPropertyChangedListener ValueChanged implementation.
 7     /// </summary>
 8     public class DependencyPropertyValueChangedEventArgs : EventArgs
 9     {
10         internal DependencyPropertyValueChangedEventArgs(object oldValue, object newValue)
11         {
12             OldValue = oldValue;
13             NewValue = newValue;
14         }
15 
16         /// <summary>
17         ///  Gets the value of the property before the change.
18         /// </summary>
19         public object OldValue { get; private set; }
20 
21         /// <summary>
22         /// Gets the value of the property after the change.
23         /// </summary>
24         public object NewValue { get; private set; }
25     }
26 }

在引用的地方这样写

 1 private DependencyPropertyChangedListener listener;
 2        
 3 public MainPage()
 4 {
 5     InitializeComponent();
 6 
 7     listener = DependencyPropertyChangedListener.Create(this, "BindingGrid.ItemsSource");
 8     listener.ValueChanged += ListenerValueChanged;
 9 }
10 
11 void ListenerValueChanged(object sender, DependencyPropertyValueChangedEventArgs e)
12 {
13      var itemsSource = BindingGrid.ItemsSource;
14             if (itemsSource != null)
15             {
16                 //SourceInitialized(itemsSource);
17             }
18 }
19 
20  public DataGrid BindingGrid
21         {
22             get { return (DataGrid)GetValue(BindingGridProperty); }
23             set { SetValue(BindingGridProperty, value); }
24         }
25 
26  public static readonly DependencyProperty BindingGridProperty =
27             DependencyProperty.Register("BindingGrid", typeof(DataGrid), typeof(ConfigurableQueryer),
28                                         new PropertyMetadata(null, OnBindingGridChange));
29 
30 //只跑一次
31  private static void OnBindingGridChange(DependencyObject sender, DependencyPropertyChangedEventArgs e)
32         {
33             var configurableQueryer = sender as ConfigurableQueryer;
34             var dg = e.NewValue as DataGrid;
35 }

转载于:https://www.cnblogs.com/oneivan/archive/2012/07/12/2587775.html