绑定，这个看起来很神奇的东西，于我这种喜欢刨根儿的人而言，理解起来非常困难。
WPF绑定的核心思想是：数据层属性值的改变，能反应给展示层，反之亦然，并且这个响应的过程能被分离出来。
传统Winform编程更加原始，没有那么多隐藏的（implicate）技术。我就以winform的实现方式来领会WPF的机制。
public class DataLayer { public delegate void TextChangedEventHandler ( object sender, EventArgs e ); public event TextChangedEventHandler TextChanged; private string text = ""; public string Text { get { return text; } set { if ( text != value ) { text = value; if ( this.TextChanged != null ) this.TextChanged ( this, new EventArgs ( ) ); } } } }
public partial class PresentationLayer : Form { TextBox ui = new TextBox ( ); DataLayer data = new DataLayer ( ); public PresentationLayer ( ) { InitializeComponent ( ); this.Controls.Add ( ui ); ui.TextChanged += new System.EventHandler ( this.PresentationLayerTextChanged ); data.TextChanged += new DataLayer.TextChangedEventHandler ( this.DataLayerTextChanged ); } private void PresentationLayerTextChanged ( object sender, EventArgs e ) { data.Text = ui.Text; } private void DataLayerTextChanged ( object sender, EventArgs e ) { ui.Text = data.Text; } }
这样就实现了前、后台数据的同步。缺点有三方面：
1、每个属性的数据同步，功能单一，内容相同。没有必要在数据层对每个属性的响应事件都单独定义事件委托。
2、为了保持数据同步，需要在展示层编写大量的数据同步代码。如果有很多个属性，重复的工作量非常大。
3、data作为PresentationLayer的成员，增加了耦合度。数据层和展示层没有完全分隔开。
问题1很好解决，从数据层抽象出一个接口事件，并在事件参数中要求说明激发事件的属性名
public interface INotifyPropertyChanged { event PropertyChangedEventHandler PropertyChanged; } public delegate void PropertyChangedEventHandler ( object sender, PropertyChangedEventArgs e ); public class PropertyChangedEventArgs : EventArgs { private readonly string propertyName; public PropertyChangedEventArgs ( string propertyName ) { this.propertyName = propertyName; } public virtual string PropertyName { get { return this.propertyName; } } }
这样，原始的DataLayer就变成这样
public class DataLayerExt : INotifyPropertyChanged { public event PropertyChangedEventHandler PropertyChanged; private string text = ""; public string Text { get { return text; } set { if ( text != value ) { text = value; if ( this.PropertyChanged != null ) this.PropertyChanged ( this, new PropertyChangedEventArgs ( "Text" ) ); } } } }
问题2从逻辑上也不难解决，定义一个静态的方法，方法的参数要说明是哪两个对象的哪两个属性需要同步，并记录这种同步关系
public class BindingOperations { static List<BindingRelative> lstBindingRelative = new List<BindingRelative>(); // 源和目标的类型应该是object。这里只为表达语意，完全实现很困难 public static void SetBinding ( TextBox uiObject, string uiPropertyName, DataLayerExt dataObject, string dataPropertyName ) { // 用列表记录同步关系 lstBindingRelative.Add ( new BindingRelative ( ) { UIObject = uiObject, UIObjectPropertyName = uiPropertyName, DataObject = dataObject, DataObjectPropertyName = dataPropertyName } ); // 增加事件处理方法 uiObject.TextChanged += new EventHandler ( uiObject_TextChanged ); dataObject.PropertyChanged += new PropertyChangedEventHandler ( target_PropertyChanged ); } static void uiObject_TextChanged ( object sender, EventArgs e ) { foreach ( BindingRelative item in lstBindingRelative ) { if ( item.UIObjectPropertyName == "Text" ) { // 通用的方式应该是这样 //item.Source.SourcePropertyName = item.Target.dataPropertyName; item.DataObject.Text = item.UIObject.Text; break; } } } static void target_PropertyChanged ( object sender, PropertyChangedEventArgs e ) { foreach ( BindingRelative item in lstBindingRelative ) { if ( item.DataObjectPropertyName == e.PropertyName ) { // 通用的方式应该是这样 //item.Source.SourcePropertyName = item.Target.dataPropertyName; item.UIObject.Text = item.DataObject.Text; break; } } } } //定义一个用来记录绑定关系的结构 public class BindingRelative { public TextBox UIObject; public string UIObjectPropertyName; public DataLayerExt DataObject; public string DataObjectPropertyName; }
这样，展示层只需要设计界面的风格，定义界面中的展示元素，与后台数据完全分离。不知不觉中，问题1也一并解决了。
public partial class PresentationLayerExt : Form { public TextBox ui = new TextBox ( ); public PresentationLayerExt ( ) { InitializeComponent ( ); this.Controls.Add ( ui ); } }
当然，指定同步关系还是要用代码实现的，但不在展示层，而是在外部，比如在Main()函数处
static class Program { /// <summary> /// 应用程序的主入口点。 /// </summary> [STAThread] static void Main ( ) { Application.EnableVisualStyles ( ); Application.SetCompatibleTextRenderingDefault ( false ); PresentationLayerExt p = new PresentationLayerExt ( ); DataLayerExt d = new DataLayerExt ( ); BindingOperations.SetBinding ( p.ui, "Text", d, "Text" ); Application.Run ( p ); } }
以上，用Winform实现了数据同步，并做到了数据层与展示层的分离。由于Winform中根据属性名称字符串获取对象的属性非常困难，定义同步关系的方法SetBinding有很大的缺陷，几乎没有通用性可言。但这不妨碍通过Winform的示例理解WPF绑定技术的运行机制。
WPF的绑定技术，实现数据层和展示层的数据同步原理也是这样：
数据层的类需要派生自System.ComponentModel中的INotifyPropertyChanged接口，
每个类都必须包含PropertyChanged事件，并在属性值改变时，激发这个事件，事件参数中传入属性名。
数据同步关系由BindingOperations的SetBinding方法建立。
在WPF中SetBinding方法的后两个参数打包成Binding类型的对象
这样，SetBinding方法的对象参数就可以使用最原始的DependencyObject类型的对象，提高通用性。
很多WPF控件已封装过SetBinding方法，这样就在对象绑定自己的属性时，就可以调用自己的SetBinding方法省略目标这个参数
一个完整的WPF应用Binding技术的例子
// Data作为绑定的数据源头，总会接收绑定目标的改变 // 但是，如果想将Data源头的改变告诉绑定目标， // 必须要从INotifyPropertyChanged接口派生，并实现响应事件的激发 public class DataClass : System.ComponentModel.INotifyPropertyChanged { private string myString; public string MyString { get { return myString; } set { myString = value; //激发事件 if ( PropertyChanged != null ) PropertyChanged ( this, new System.ComponentModel.PropertyChangedEventArgs ( "MyString" ) ); } } public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged; }
// 作为被绑定的目标类，必须从DependencyObject派生 // 这样定义的类才能满足SetBinding方法的第一个参数的类型要求 // 还要额外定义一个依赖属性，用来满足SetBinding方法的第二个参数要求 // 用DependencyObject派生方法GetValue和SetValue，控制属性的存、取 public class UIClass : System.Windows.DependencyObject { public string MyText { get { return ( string ) GetValue ( MyTextProperty ); } set { SetValue ( MyTextProperty, value ); } } public static readonly System.Windows.DependencyProperty MyTextProperty = System.Windows.DependencyProperty.Register ( "MyText", typeof ( string ), typeof ( UIClass ) ); }
测试类相比Winform，WPF实现了按属性名称存/取对象属性的功能，并把这个技术叫做依赖属性。
有了依赖属性，WPF的SetBinding方法就真正做到通用，这个技术在后面继续研究。
程序的世界哪有什么神奇，只是有的人做了更多的工作，结果看起来很神奇而已。
所谓的数据与展示分离，不过是在这两层之外，额外创建了一个管理机构。
而WPF的绑定技术，就是这个管理机构中的一个部门，负责收、发快递！