WPF之Binding深入探讨--Darren

1，Data Binding在WPF中的地位

程序的本质是数据+算法。数据会在存储、逻辑和界面三层之间流通，所以站在数据的角度上来看，这三层都很重要。但算法在3层中的分布是不均匀的，对于一个3层结构的程序来说，算法一般分布在这几处：

A。数据库内部。

B。读取和写回数据。

C。业务逻辑。

D。数据展示。

E。界面与逻辑的交互。

A,B两部分的算法一般都非常稳定，不会轻易去改动，复用性也很高；C处与客户需求最紧密，最复杂，变化最大，大多少算法都集中在这里。D,E负责UI和逻辑的交互，也占有一定量的算法。

显然，C部分是程序的核心，是开发的重中之重，所以我们应该把精力集中在C部分。然而，D,E两部分却经常成为麻烦的来源。首先这两部分都与逻辑紧密相关，一不小心就有可能把本来该放在逻辑层里面的算法写进这两部分（所以才有了MVC、MVP等模式来避免这种情况出现）。其次，这两部分以消息或者事件的方式与逻辑层沟通，一旦出现同一个数据需要在多出展示/修改时，用于同步的代码错综复杂；最后，D和E本来是互逆的一对儿。但却需要分开来写-----显示数据写一个算法，修改数据再写一个算法。总之导致的结果就是D和E两部分会占去一部分算法，搞不好还会牵扯不少精力。

问题的根源在于逻辑层和展示层的地位不固定------当实现客户需求的时候，逻辑层的确处于核心地位。但到了实现UI的时候，展示层又处于核心的地位。WPF作为一种专业的展示层技术，华丽的外观和动画只是它的表层现象，最重要的是他在深层次上把程序员的思维固定在了逻辑层，让展示层永远处于逻辑层的从属地位。WPF具有这种能力的关键在于它引入了Data Binding概念及与之配套的Dependency Property系统和DataTemplate。

从传统的Winform转移到WPF上，对于一个三层程序而言，数据存储层由数据库和文件系统组成，数据传输和处理仍然使用.NetFramework的ADO.NET等基本类（与Winform开发一样）。展示层则使用WPF类库来实现，而展示层和逻辑层的沟通就使用Data Binding来实现。可见，Data Binding在WPF中所起的作用就是高速公路的作用。有了这条高速公路，加工好的数据自动送达用户界面并加以显示，被用户修改过的数据也会自动传回业务逻辑层，一旦数据被加工好又会被送往界面。。。。程序的逻辑层就像是一个强有力的引擎一直在运作，用加工好的数据驱动用户界面也文字、图形、动画等形式把数据显示出来------这就是数据驱动UI。

引入Data Binding之后，D,E两部分被简化了很多。首先，数据在逻辑层和用户界面直来之去、不涉及逻辑问题，这样的用户界面部分基本上不包含算法：Data Binding本身就是双向通信，所以相当于把D和E合二为一；对于多个UI元素关注同一个数据的情况，只需要用Data Binding将这些UI元素和数据一一关联上（以数据为中心的星形结构），当数据变化后，这些UI元素会同步显示这一变化。前面提到的问题也都迎刃而解了。更重要的是经过这样的优化，所有与业务逻辑相关的算法都处在业务逻辑层，逻辑层成了一个可以独立运转，完整的体系，而用户界面则不需要任何逻辑代码。完全依赖和从属于业务逻辑层。这样做有两个显而易见的好处，第一：如果把UI看做是应用程序的皮，把存储层和逻辑层看作是程序的瓤，我们可以很轻易的把皮撕下来换一个新的。第二：因为数据层能够独立运作，自成体系，所以我们可以进行更完善的单元测试而无需借助UI自动化测试工具----你完全可以把单元测试看作是一个“看不见的UI”，单元测试只是使用这个UI绕过真实的UI直接测试业务逻辑罢了。

2 ，  Binding 基础

如果把Binding比作数据的桥梁，那么它的两端分别是源(Source)和目标(Target)。数据丛哪里来哪里就是源，到哪里去哪里就是目标。一般情况下，Binding的源是业务逻辑层的对象，Binding的目标是UI层的控件对象。这样数据就会源源不断的通过Binding送达UI界面，被UI层展现，这就完成了数据驱动UI的过程。有了这座桥梁，我们不仅可以控制车辆在源与目标之间是双向通行还是单向通行。还可以控制数据的放行时机，甚至可以在桥上搭建一些关卡用来转换数据类型或者检验数据的正确性。

通过对Binding有了一个基本概念之后，让我们看一个最基本的例子。这个例子是创建一个简单的数据源并通过Binding把它连接到UI元素上。

首先，我们创建一个名为"Student"的类，这个类的实例将作为数据源来使用。

 

[csharp]  view plain copy print ?
 
  1. public class Student  
  2.     {  
  3.         private string name;  
  4.   
  5.         public string Name  
  6.         {  
  7.             get { return name; }  
  8.             set  
  9.             {  
  10.                 name = value;  
  11.         }  
  12.     }  

这个类很简单，简单到只有一个string类型的Name属性。前面说过数据源是一个对象，一个对象本身可能会有很多数据，这些数据又通过属性暴露给外界。那么其中哪个元素是你想通过Binding送达UI元素的呢，换句话说，UI元素关心的是哪个属性值的变化呢？这个属性值称之为Binding的路径（Path）。但光有属性还不行-------Binding是一种自动机制，当值变化后属性要有能力通知Binding，让Binding把变化传递给UI元素。怎样才能让一个属性具备这种通知Binding值已经改变的能力呢？方法是在属性的Set语句中激发一个PropertyChanged事件。这个事件不需要我们自己声明，我们要做的事是让作为数据源的类实现System.ComponentModel名称空间中的INotifyPropertyChanged接口。当为Binding设置了数据源之后，Binding就会自动侦听来自这个接口PropertyChanged事件。

 

实现INotifyPropertyChanged接口的类看起来是这样：

 

[csharp]  view plain copy print ?
 
  1. public class Student : INotifyPropertyChanged  
  2.     {  
  3.         private string name;  
  4.   
  5.         public string Name  
  6.         {  
  7.             get { return name; }  
  8.             set  
  9.             {  
  10.                 name = value;  
  11.                 if (PropertyChanged != null)  
  12.                 {  
  13.                     this.PropertyChanged.Invoke(this, new PropertyChangedEventArgs("Name"));  
  14.                 }  
  15.             }  
  16.         }  
  17.         public event PropertyChangedEventHandler PropertyChanged;  
  18.     }  


经过这样一升级，当Name属性的值发生变化时PropertyChanged事件就会被激发，Binding接收到这个事件后发现事件的消息告诉它是Name属性值发生了变化，于是通知Binding目标端的UI元素显示新的值。

 

然后我们在窗体上准备一个TextBox和Button，代码如下:

 

[html]  view plain copy print ?
 
  1. <Window x:Class="WpfApplication1.MainWindow"  
  2.         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
  3.         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"  
  4.         Title="MainWindow" Height="350" Width="525">  
  5.     <Grid>  
  6.         <TextBox Height="23" HorizontalAlignment="Left" Margin="185,43,0,0" Name="textBox1" VerticalAlignment="Top" Width="120" />  
  7.         <Button Content="Button" Height="23" HorizontalAlignment="Left" Margin="209,96,0,0" Name="button1" VerticalAlignment="Top" Width="75" Click="button1_Click" />  
  8.     </Grid>  
  9. </Window>  


后台代码这样写:

 

 

[csharp]  view plain copy print ?
 
  1. /// <summary>  
  2.    /// MainWindow.xaml 的交互逻辑  
  3.    /// </summary>  
  4.    public partial class MainWindow : Window  
  5.    {  
  6.        Student stu = null;  
  7.        public MainWindow()  
  8.        {  
  9.            InitializeComponent();  
  10.            stu = new Student();  
  11.            Binding bind = new Binding();  
  12.            bind.Source = stu;  
  13.            bind.Path = new PropertyPath("Name");  
  14.            this.textBox1.SetBinding(TextBox.TextProperty, bind);  
  15.   
  16.        }  
  17.   
  18.        private void button1_Click(object sender, RoutedEventArgs e)  
  19.        {  
  20.            stu.Name += "f";  
  21.            new Window1().Show();  
  22.        }  
  23.    }  


让我们逐句解释一下这段代码，这段代码是MainWIndow的后台代码，它的前端代码就是上面的XAML代码。“Student stu;”是为MainWindow声明一个Student类型的成员变量，这样做的目的是为了在MainWindow的构造器和Button.Click事件处理器中都可以访问到由它引用的Student实例（数据源）。

 

在MainWindow的构造器中“InitializeComponent();”是自动生成的代码，用途是初始化UI元素。“stu=new Student();”这句是创建一个Student实例并用stu成员变量引用它，这个对象就是我们的数据源。

在准备Binding的部分，先使用“Binding bind = new Binding();”声明Binding类型变量并创建实例，然后使用“bind.Source=stu;”为Binding实例指定数据源，最后使用“bind.Path= new PropertyPath('Name')”语句为Binding指定访问路径。

把数据源和目标连接在一起的任务是使用“BindingOperations.SetBinding(...)”方法完成的，这个方法的3个参数是我们记忆的重点：

第一个参数是指定Binding的目标，本例中的this.textBoxName。

与数据源的Path原理类似，第二个参数用于为Binding指明为Binding指明把这个数据送达目标的哪个数据。

第三个参数很明显，就是指定使用哪个Binding实例将数据源和目标关联起来。

运行程序，单击按钮我们将会看到如下的效果图:

WPF之Binding深入探讨--Darren_第1张图片

通过上面的例子，我们已经在头脑中建立起来如图所示的模型

WPF之Binding深入探讨--Darren_第2张图片

先用这个做基础，后面我们将研究Binding的每个特点。

1.3         Binding的源与路径

Binding 的源也就是数据的源头。Binding对源的要求并不苛刻------只要它是一个对象，并且通过属性(Property)公开自己的数据，它就能作为Binding 的源。

前面一个例子已经向大家证明，如果想让作为Binding源的对象具有自动通知Binding自己属性值已经已经变化的能力。那么就需要让类实现INotifyChanged接口并在属性的Set语句中激发PropertyChanged事件。在日常生活中，除了使用这种对象作为数据源之外，我们还有更多的选择，比如控件把自己的容器或子集元素当源、用一个控件做为另一个控件的数据源，把集合作为ItemControl的数据源、使用XML作为TreeView或Menu的数据源。把多个控件关联到一个“数据制高点”上，甚至干脆不给Binding指定数据源、让他自己去找。下面我们就分述这些情况。

1.3.1       把控件作为Binding源与Binding标记扩展。

前面讲过，大多数情况下Binding的源是逻辑层对象，但有的时候为了让UI产生联动效果也会使用Binding在控件间建立关联。下面的代码是吧一个TextBox的Text属性关联到Slider的Value的属性上。

 

[html]  view plain copy print ?
 
  1. <Window x:Class="WpfApplication1.Window1"  
  2.         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
  3.         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"  
  4.         Title="Window1" Height="321" Width="401">  
  5.     <Grid>  
  6.         <TextBox Height="23" HorizontalAlignment="Left" Margin="141,46,0,0" Name="textBox1" VerticalAlignment="Top" Width="120" Text="{Binding Path=Value,ElementName=slider1}"/>  
  7.         <Slider Height="23" HorizontalAlignment="Left" Margin="84,106,0,0" Name="slider1" VerticalAlignment="Top" Width="212" />  
  8.         <Button Content="Button" Height="23" HorizontalAlignment="Left" Margin="166,197,0,0" Name="button1" VerticalAlignment="Top" Width="75" Click="button1_Click" />  
  9.     </Grid>  
  10. </Window>  

运行效果如下图:

 

WPF之Binding深入探讨--Darren_第3张图片
正如大家所见，除了可以在C#中建立Binding外在XAML代码里也可以方便的设置Binding，这就给设计师很大的自由度来决定UI元素之间的关联情况。值得注意的是，在C#代码中，可以访问在XAML中声明的变量但是XAML中不能访问C#中声明的变量，因此，要想在XAML中建立UI元素和逻辑对象的Binding还要颇费些周折，把逻辑代码声明为XAML中的资源（Resource），我们放资源一章去讲。

回头来看XAML代码，它使用了Binding标记扩展语法：

 

[html]  view plain copy print ?
 
  1. <TextBox Height="23" HorizontalAlignment="Left" Margin="141,46,0,0" Name="textBox1" VerticalAlignment="Top" Width="120" Text="{Binding Path=Value,ElementName=slider1}"/>  

与之等价的C#代码是：

 

 

[csharp]  view plain copy print ?
 
  1. this.textBox1.SetBinding(TextBox.TextProperty, new Binding("Value") { ElementName="Slider1"});  

因为Binding类的构造器本身具有可以接收Path的参数，所以也常写作:

 

 

[html]  view plain copy print ?
 
  1. <TextBox Height="23" HorizontalAlignment="Left" Margin="141,46,0,0" Name="textBox1" VerticalAlignment="Top" Width="120" Text="{Binding Value,ElementName=slider1}"/>  

注意:

 

因为我们在C#代码中可以直接访问控件对象，所以一般不会使用Binding的ElementName属性，而是直接赋值给Binding的Sourece属性。

Binding的标记扩展语法，初看有些平淡甚至有些别扭，但细品就会体验到其的精巧之处。说它别扭，是因为我们已经习惯了Text=“Hello World”这种键--值式的赋值方式，而且认为值与属性的值类型一定要一致-------大脑很快会质询Text="{Binding Value,ElementName=Slider1}"的字面意思----Text的类型是String，为什么要赋一个Binding类型的值呢？其实我们并不是为Text属性赋值，为了消除这种误会，我们可以把代码读作：为Text属性设置Binding为...。再想深一步，我们不是经常把函数视为一个值吗？只是这个值在函数执行之后才能得到。同理，我们也可以把Binding视为一种间接的、不固定的赋值方式-----Binding扩展很恰当的表达了这个赋值方式。

1.3.2        控制Binding的方向及数据更新

Binding在源与目标之间架起了沟通的桥梁，默认情况下数据即可以通过Binding送达目标，也可以通过目标回到源(收集用户对数据的修改)。有时候数据只需要展示给用户，不需要用户修改，这时候可以把Binding模式设置为从目标向源的单向沟通以及只在Binding关系确立时读取一次数据，这需要我们根据实际情况选择。

控制Binding数据流向的属性是Model，它的类型是BindingModel的枚举。BindingModel可以取值为TwoWay、OneWay、OneTime、OneWayToSource和Default。这里的Default指的是Binding的模式会根据目标是实际情况来确定，不如是可以编辑的（TextBox的Text属性），Default就采用双向模式。如果是TextBlock，不可编辑，就使用单向模式。

接上一节的小例子，拖动Slider手柄时，TextBox就会显示Slider的当前值（实际上这一块涉及到一个Double到String类型的转换，暂且忽略不计）；如果我们在TextBox里面输入一个恰当的值按Tab键、让焦点离开TextBox，则Slider手柄就会跳转至相应的值那里。如下图所示:

WPF之Binding深入探讨--Darren_第4张图片

为什么一定要在TextBox失去焦点以后才改变值呢？这就引出了Binding的另外一个属性-----UpdateSourceTrigger，它的类型是UpdateSourceTrigger枚举，可取值为PropertyChanged、LostFous、Explicit和Default。显然，对于Text的Default行为与LostFocus一致，我们只需要把这个值改成PropertyChanged，则Slider就会随着输入值的变化而变化了。

注意:

顺便提一句，Binding还具有NotifyOnSourceUpdated属性和NotifyOnTargetUpdated两个bool类型是属性。如果设置为True，则在源或目标被更新以后就会触发相应的SourceUpdated事件和TargetUpdated事件。实际工作中我们可以监听这两个事件来找出来哪些数据或控件被更新了。

1.3.3   Binding的路径(Path)

做为Binding的源可能会有很多属性，通过这些属性Binding源可以把数据暴露给外界。那么，Binding到底需要关注哪个属性值呢？就需要用Binding的Path属性来指定了。例如前面这个例子，我们把Slider控件对象作为数据源，把它的Value属性作为路径。

尽管在XAML代码中或者Binding类的构造器参数列表中我们使用字符串来表示Path，但Path的实际类型是PropertyPath。下面让我们来看看如何创建Path来应付实际情况（我将使用C#和XAML两种代码进行描述）。

最简单的方法就是直接把Binding关联到Binding源的属性上，前面的例子就是这样，语法如下:

 

[html]  view plain copy print ?
 
  1. <TextBox Height="23" HorizontalAlignment="Left" Margin="141,46,0,0" Name="textBox1" VerticalAlignment="Top" Width="120" Text="{Binding Path=Value,ElementName=slider1}"/>  

等效的C#代码就是：

 

 

[csharp]  view plain copy print ?
 
  1. this.textBox1.SetBinding(TextBox.TextProperty, new Binding("Value") {Source=slider1});  

Binding还支持多级路径（通俗的讲就是一路“点”下去），比如，我们想让一个TextBox显示另外一个TextBox内容的长度，我们可以这样写：

 

 

[html]  view plain copy print ?
 
  1. <TextBox Height="23" HorizontalAlignment="Left" Margin="152,50,0,0" Name="textBox1" VerticalAlignment="Top" Width="158" />  
  2.        <TextBox Height="23" HorizontalAlignment="Left" Margin="152,105,0,0" Name="textBox2" Text="{Binding Path=Text.Length,ElementName=textBox1,Mode=OneWay}" VerticalAlignment="Top" Width="158"/>  


等效的C#代码是：

 

 

[csharp]  view plain copy print ?
 
  1. this.textBox2.SetBinding(TextBox.TextProperty, new Binding("Text.Length") {Source = textBox1, Mode= BindingMode.OneWay });  


运行效果如下图:

 

WPF之Binding深入探讨--Darren_第5张图片
我们知道，集合类型是索引器(Indexer)又称为带参属性。既然是属性，索引器也能作为Path来使用。比如我们想让一个TextBox显示另外一个TextBox的第4个字符，我们可以这样写：

 

[html]  view plain copy print ?
 
  1. <TextBox Height="23" HorizontalAlignment="Left" Margin="152,50,0,0" Name="textBox1" VerticalAlignment="Top" Width="158" Text="ABCDE" />  
  2.        <TextBox Height="23" HorizontalAlignment="Left" Margin="152,105,0,0" Name="textBox2" Text="{Binding Path=Text[3],ElementName=textBox1,Mode=OneWay}" VerticalAlignment="Top" Width="158"/>  


C#代码如下:

 

 

[csharp]  view plain copy print ?
 
  1. this.textBox2.SetBinding(TextBox.TextProperty, new Binding("Text.[3]") { Source=textBox1,Mode= BindingMode.OneWay});  


我们甚至可以把Text与[3]之间的点去掉，一样可以正确工作，运行效果如下图:

 

WPF之Binding深入探讨--Darren_第6张图片
当使用一个集合或者DataView做为数据源时，如果我们想把它默认的元素做为数据源使用，则需要使用下面的语法:

 

[csharp]  view plain copy print ?
 
  1. List<string> infos = new List<string>() { "Jim","Darren","Jacky"};  
  2.            textBox1.SetBinding(TextBox.TextProperty, new Binding("/") { Source=infos});  
  3.            textBox2.SetBinding(TextBox.TextProperty, new Binding("/[2]") { Source = infos, Mode= BindingMode.OneWay });  
  4.            textBox3.SetBinding(TextBox.TextProperty, new Binding("/Length") { Source = infos, Mode= BindingMode.OneWay });  


显示效果如下:

 

WPF之Binding深入探讨--Darren_第7张图片

如果集合中仍然是集合,我们想把子集集合中的元素做Path，我们可以使用多级斜线的语法（即“一路”斜线下去），例如:

 

[html]  view plain copy print ?
 
  1. /// <summary>  
  2.    /// Window4.xaml 的交互逻辑  
  3.    /// </summary>  
  4.    public partial class Window4 : Window  
  5.    {  
  6.        public Window4()  
  7.        {  
  8.            InitializeComponent();  
  9.            List<Contry> infos = new List<Contry>() { new Contry() { Name = "中国", Provinces= new List<Province>(){ new Province(){ Name="四川",Citys=new List<City>(){new  City(){Name="绵阳市"  
  10.            }}}}}};  
  11.            this.textBox1.SetBinding(TextBox.TextProperty, new Binding("/Name") { Source=infos});  
  12.            this.textBox2.SetBinding(TextBox.TextProperty, new Binding("/Provinces/Name") { Source = infos });  
  13.            this.textBox3.SetBinding(TextBox.TextProperty, new Binding("/Provinces/Citys/Name") { Source = infos });  
  14.        }  
  15.    }  
  16.   
  17.     class City  
  18.    {  
  19.        public string Name { set; get; }  
  20.    }  
  21.   
  22.    class Province  
  23.    {  
  24.        public string Name { set; get; }  
  25.        public List<City> Citys { set; get; }  
  26.    }  
  27.   
  28.    class Contry  
  29.    {  
  30.        public string Name { set; get; }  
  31.        public List<Province> Provinces { get; set; }  
  32.    }  


运行效果如图:

 

WPF之Binding深入探讨--Darren_第8张图片

1.3.4       "没有Path"的Binding

有的时候我们会在代码中我们看大Path是一个“.”或者干脆没有Path的Binding，着实让人摸不着头脑。原来这是一种比较特殊的情况---Binding源本身就是一种数据且不需要Path来指明。典型的string,int等基本类型都是这样，他们是实例本身就是数据，我们无法指定通过那个属性来访问这个数据，这是我们只需要将这个数据设置为.就可以了。在XAML中这个.可以忽略不写，但是在C#中编程必须要带上。下面请看下面这段代码:

 

[html]  view plain copy print ?
 
  1. <Window x:Class="WpfApplication1.Window5"  
  2.         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
  3.         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"  
  4.         xmlns:String="clr-namespace:System;assembly=mscorlib"  
  5.         Title="Window5" Height="331" Width="538">  
  6.     <StackPanel Height="184" Name="stackPanel1" Width="288">  
  7.         <StackPanel.Resources>  
  8.             <String:String x:Key="myString">  
  9.                 菩提本无树，何处染尘埃。  
  10.             </String:String>  
  11.               
  12.         </StackPanel.Resources>  
  13.         <TextBlock Height="23" Name="textBlock1" Text="{Binding Path=.,Source={StaticResource ResourceKey=myString}}" />  
  14.     </StackPanel>  
  15. </Window>  


上面的代码可以简写成:

 

 

[html]  view plain copy print ?
 
  1. <TextBlock Height="23" Name="textBlock1" Text="{Binding .,Source={StaticResource ResourceKey=myString}}" />  

或者直接写成:

 

 

[html]  view plain copy print ?
 
  1. <TextBlock Height="23" Name="textBlock1" Text="{Binding Source={StaticResource ResourceKey=myString}}" />  

 

注意:

最后这种简写很容易被误解为没有指定Path，其实只是省略掉了。与只等效的C#代码如下:

 

[csharp]  view plain copy print ?
 
  1. string myString = "菩提本无树，明镜亦无台。本来无一物，何处染尘埃。";  
  2.            this.textBlock1.SetBinding(TextBlock.TextProperty, new Binding(".") { Source=myString});  


注意：

 

最后顺便带一句，PropertyPath除了用于Binding的Path属性之外，在动画编程的时候也会派上用场（Storyboard.TargetProperty）。在用于动画编程的时候，PropertyPath还有另外一种语法，到时候我们细说。

1.3.5      把Binding指定为源(Source)的几种方法

上一节我们学习了如何通过Binding的path属性如何在一个对象上寻找数据。这一节我们将学习如何为Binding指定源（Source）。

Binding的源是数据的来源，所以，只要一个对象包含数据并且能够通过属性将数据暴露出来，它就能当作Binding的源来使用。包含数据的对象比比皆是，但必须为Binding的Source指定合适的对象Binding才能正常工作，常用的办法有:

 

  • 把普通的CLR单个对象指定为Source：包括.NetFrameWork自带类型的对象和用户自定义类型的对象。如果类型实现了INotifyPropertyChanged接口，这可以通过在属性的Set语句里激发PropertyChanged事件来通知Binding已经更新。
  • 把普通的CLR对象集合指定为Source：包括数组,List<T>,ObservableCollection<T>等集合类型。实际工作中，我们经常需要将一个集合类型作为ItemControl的派生类的数据来使用，一般把控件ItemSource属性使用Binding关联到一个集合对象上。
  • 把ADO.NET数据指定为Source：包括DataTable和DataView对象。
  • 使用XmlDataProvider把XML数据指定为Source:XML做为标准的数据传输和存储格式，几乎无处不在，我们可以用它表示单个对象或者集合对象；一些WPF控件是级联的（如Treeview和Menu），我们可以把树状结构的XML数据作为源指定给与之关联的Binding。
  • 把依赖对象(Dependency Object)指定为Source：依赖对象不仅可以做为Binding 的目标，还能作为Binding 的源。这样就有可能形成Binding链。依赖对象中的依赖属性可以做为Binding的Path。
  • 把容器的DataContext指定为Source（WPF 中Binding的默认行为）：有时候我们会遇到这样一种情况----我们明确知道将从那个属性获取数据，但具体使用哪个对象作为Binding的源还不确定。这时候我们只需要先建立一个Binding，只给它设置Path而不设置Source，让这个Binding自己去寻找源，这时候，Binding会自动把控件的DataContext作为当作自己的Source（它会沿着控件树一直向外找，直到找到带有Path指定的对象为止）。
  • 通过ElementName指定Source：在C#代码中可以直接把对象作为Source赋值给Binding，但是XAML无法访问对象，只能使用Name属性来找到对象。
  • 通过Binding的RelataveSource属性相对的指定Source：当控件需要关注自己的、自己容器的或者自己内部某个属性值就需要使用这种办法。
  • 把ObjectDataProvider指定为Source：当数据源的数据不是通过属性，而是通过方法暴露给外界的时候，我们可以使用这种对象来包装数据源再把它们指定为Source。
  • 把使用LINQ检索到的数据作为数据源。

 

下面我们使用实例来分别描述每种情况：

1.3.6       没有Source的Binding----使用DataContext作为数据源

前面的例子都是把单个的CLR对象作为Binding 的源，方法有两种：把对象赋值给Binding.Source属性或者把对象的Name赋值给Binding.ElementName。DataContext被定义在FrameWorkElement类中，这个类是WPF控件的基类，这意味着所有的WPF控件包括布局控件都包含这个属性。如前所述，WPF的UI布局是树形结构，这个树的每个节点都是控件，由此我们推出一个结论----在UI树的每个节点都有DataContext属性。这一点非常重要，因为当一个Binding只知道自己的Path而不知道自己的源的时候，它会沿着树的一路向树的根部找过去，每经过一个节点都要查看这个节点的DataContext属性是否具有Path所指定的属性。如果有，就把这个对象作为自己的Source；如果没有，就继续找下去；如果到树的根部还没有找到，那这个Binding就没有Source，因而也不会得到数据，让我们看看下面的例子:

先创建一个名为Student的类，它具有ID,Name,Age3个属性：

 

[csharp]  view plain copy print ?
 
  1. public class Student  
  2.     {  
  3.         public int Id { get; set; }  
  4.         public string Name { get; set; }  
  5.         public int Age { get; set; }  
  6.     }  


在后在XAML中建立UI界面:

 

 

[html]  view plain copy print ?
 
  1. <Window x:Class="WpfApplication1.Window6"  
  2.         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
  3.         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"  
  4.         xmlns:Stu="clr-namespace:WpfApplication1"  
  5.         Title="Window6" Height="345" Width="464">  
  6.     <StackPanel Background="AliceBlue">  
  7.         <StackPanel.DataContext>  
  8.             <Stu:Student Id="1" Name="Darren" Age="10"></Stu:Student>  
  9.         </StackPanel.DataContext>  
  10.         <Grid>  
  11.             <StackPanel Height="283" HorizontalAlignment="Left" Margin="12,12,0,0" Name="stackPanel1" VerticalAlignment="Top" Width="418">  
  12.                 <TextBox Height="23" Name="textBox1" Width="120" Margin="15" Text="{Binding Path=Id}"/>  
  13.                 <TextBox Height="23" Name="textBox2" Width="120" Margin="15" Text="{Binding Path=Name}"/>  
  14.                 <TextBox Height="23" Name="textBox3" Width="120" Margin="15" Text="{Binding Path=Age}"/>  
  15.             </StackPanel>  
  16.         </Grid>  
  17.     </StackPanel>  
  18.       
  19. </Window>  

这个UI可以用如下的柱状图来表示:

 

WPF之Binding深入探讨--Darren_第9张图片

使用xmlns:Stu="clr-namespace:WpfApplication1"，我们就可以在XAML中使用在C#中定义的类。使用了这几行代码:

 

[html]  view plain copy print ?
 
  1. <StackPanel.DataContext>  
  2.            <Stu:Student Id="1" Name="Darren" Age="10"></Stu:Student>  
  3.        </StackPanel.DataContext>  


就为外层StackPanel的DataContext进行了赋值----它是一个Student对象。3个TextBox通过Binding获取值，但只为Binding指定了Path，没有指定Source。简写成这样也可以：

 

 

[html]  view plain copy print ?
 
  1. <TextBox Height="23" Name="textBox1" Width="120" Margin="15" Text="{Binding Id}"/>  
  2.                 <TextBox Height="23" Name="textBox2" Width="120" Margin="15" Text="{Binding Name}"/>  
  3.                 <TextBox Height="23" Name="textBox3" Width="120" Margin="15" Text="{Binding Age}"/>  


这样3个TextBox就会沿着树向上寻找可用的DataContext对象。运行效果如下图:

 

WPF之Binding深入探讨--Darren_第10张图片

前面在学习Binding路径的时候，当Binding的Source本身就是数据、不需要使用属性来暴露数据时，Binding的Path可以设置为"."，亦可省略不写。现在Source也可以省略不写了，这样，当某个DataContext为简单类型对象的时候，我们完全可能看到一个既没有Path，又没有Source的Binding：

 

[html]  view plain copy print ?
 
  1. <Window x:Class="WpfApplication1.Window7"  
  2.         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
  3.         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"  
  4.         xmlns:Str="clr-namespace:System;assembly=mscorlib"  
  5.         Title="Window7" Height="300" Width="300">  
  6.     <Grid>  
  7.         <Grid.DataContext>  
  8.             <Str:String>Hello DataContext</Str:String>  
  9.         </Grid.DataContext>  
  10.         <StackPanel>  
  11.             <TextBlock Height="23" HorizontalAlignment="Left" Margin="15" Name="textBlock1" Text="{Binding}" VerticalAlignment="Top" />  
  12.             <TextBlock Height="23" HorizontalAlignment="Left" Margin="15" Name="textBlock2" Text="{Binding}" VerticalAlignment="Top" />  
  13.             <TextBlock Height="23" HorizontalAlignment="Left" Margin="15" Name="textBlock3" Text="{Binding}" VerticalAlignment="Top" />  
  14.         </StackPanel>  
  15.           
  16.     </Grid>  
  17. </Window>  


运行效果如下图:

 

WPF之Binding深入探讨--Darren_第11张图片

你可能回想，Binding怎么会自动向UI元素上一层查找DataContext并把它作为自己的Source呢？其实，“Binding沿着UI元素树向上找”只是WPF给我们的一个错觉，Binding并没有那么智能。之所以会这样是因为DataContext是一个“依赖属性”，后面的章节我们会详细描述，依赖属性有一个很明显的特点就是你没有为某个控件的依赖属性赋值的时候，控件会把自己容器的属性值接过来当作自己的属性值。实际上属性值是沿着UI元素树向下传递的。

在实际工作中，DataContext属性值的运用非常的灵活。比如:

当UI上的多个控件都使用Binding关注同一个对象变化的时候，不妨使用DataContext。

当作为Source的对象不能被直接访问的时候----比如B窗体内的控件想把A窗体里的控件当作自己的Binding源时，但是A窗体内的控件可访问级别是private类型，这是就可以把这个控件或者控件值作为窗体A的DataContext（这个属性是Public级别的）这样就可以暴露数据了。

形象的说，这时候外层的数据就相当于一个数据的“至高点”，只要把元素放上去，别人就能够看见。另外DataContext本身就是一个依赖属性，我们可以使用Binding把它关联到一个数据源上。

1.3.7     使用集合对象作为列表控件的ItemsSource

有了DataContext作为基础，我们再来看看把集合类型对象作为Binding源的情况。

WPF中的列表式控件都派生自ItemControl类，自然也继承了ItemSource这个属性。ItemSource可以接收一个IEnumerable接口派生类的实例作为自己的值（所有可被迭代遍历的集合都实现了这个接口，包括数组、List<T>等）。每个ItemControl都具有自己的条目容器Item Container，例如，ListBox的条目容器是ListBoxItem、Combox的条目容器是ComboxItem。ItemSource里面保存的是一条一条的数据，想要把数据显示出来就要为数据穿上外衣，条目容器就起到了数据外衣的作用。这样将数据外衣和它所对应的条目容器关联起来呢？当然时依靠Binding！只要我们为一个ItemControl设置了ItemSource属性值，ItemControl会自动迭代其中的数据元素，为每个数据元素准备一个条目容器，并使用Binding元素在条目容器和数据元素之间建立起关联，让我们来看一个例子：

UI代码如下：

 

[html]  view plain copy print ?
 
  1. <Window x:Class="WpfApplication1.Window8"  
  2.         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
  3.         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"  
  4.         Title="Window8" Height="356" Width="471">  
  5.     <Grid>  
  6.         <StackPanel Height="295" HorizontalAlignment="Left" Margin="10,10,0,0" Name="stackPanel1" VerticalAlignment="Top" Width="427">  
  7.             <TextBlock Height="23" Name="textBlock1" Text="学员编号:" />  
  8.             <TextBox Height="23" Name="txtStudentId" Width="301" HorizontalAlignment="Left"/>  
  9.             <TextBlock Height="23" Name="textBlock2" Text="学员列表:" />  
  10.             <ListBox Height="208" Name="lbStudent" Width="305" HorizontalAlignment="Left"/>  
  11.         </StackPanel>  
  12.     </Grid>  
  13. </Window>  

 

窗体运行效果如下图:

WPF之Binding深入探讨--Darren_第12张图片

我们要实现的效果就是把List<Student>的集合作为ListBox的ItemSource,让ListBox显示学员的Name,并使用TextBox显示当前选中学员的Id,为了实现这个功能,我们需要在窗体的构造函数中添加几行代码:

 

[csharp]  view plain copy print ?
 
  1. List<Student> infos = new List<Student>() {   
  2.             new Student(){ Id=1, Age=11, Name="Tom"},  
  3.             new Student(){ Id=2, Age=12, Name="Darren"},  
  4.             new Student(){ Id=3, Age=13, Name="Jacky"},  
  5.             new Student(){ Id=4, Age=14, Name="Andy"}  
  6.             };  
  7.             this.lbStudent.ItemsSource = infos;  
  8.             this.lbStudent.DisplayMemberPath = "Name";  
  9.   
  10.             this.txtStudentId.SetBinding(TextBox.TextProperty,new Binding("SelectedItem.Id"){ Source=lbStudent});  

运行结果如下图：

 

WPF之Binding深入探讨--Darren_第13张图片
你可能回想，这个例子中并没有出现刚才我们说的Binding。实际上， this.lbStudent.DisplayMemberPath = "Name";这点代码露出了一点蛛丝马迹。注意到包含Path这个单词了吗？这说明它是一个路径。当DisplayMemberPath 被赋值以后，ListBox在获得ItemSource的时候就会创建一个等量的ListBoxItem并以DisplayMemberPath的值为Path创建Binding，Binding的目标是ListBoxItem的内容插件（实际上是一个TextBox，下面就会看见）。

如过在ItemControl类的代码里刨根问底，你会发现Binding的过程是在DisplayMemberTemplateSelector类的SelectTemplate方法里完成的。这个方法的定义格式如下:

 

[csharp]  view plain copy print ?
 
  1. public override DataTemplate SelectTemplate(object item, DependencyObject container)  
  2.         {  
  3.             //逻辑代码  
  4.         }  


这里我们倒不必关心它的实际内容，注意到它的返回值没有，是一个DataTemplate类型的值。数据的外衣就是由DataTemplate穿上的！当我们没有为ItemControl显示的指定Template的时候SelectTemplate会默认的为我们创建一个最简单的DataTemplate----就好像给数据穿上了一个简单的衣服一样。至于什么是Template以及这个方法的完整代码将会放到与Template相关的文章中仔细去讨论。这里我们只关心SelectTemplate内部创建Binding 的几行关键代码:

 

 

[csharp]  view plain copy print ?
 
  1. FrameworkElementFactory text = ContentPresenter.CreateTextBlockFactory();  
  2.            Binding bind = new Binding();  
  3.            bind.Path = new PropertyPath(_displayMemberPath);  
  4.            bind.StringFormat = _stringFormat;  
  5.            text.SetBinding(TextBlock.TextProperty,bind);  


注意：

 

这里对新创建的Binding设定了Path而没有指定Source，紧接这就把它关联到了TextBlock上。显然，要想得到Source，这个Binding需要向树根方向寻找包含_displayMemberPath指定属性的DataContext。

最后我们再看一个显示为数据设置DataTemplate的例子，先把C#代码中的this.lbStudent.DisplayMemberPath = "Name";一句删除，再在XAML代码中添加几行代码，ListBox的ItemTemplate属性（继承自ItemControl类）的类型是DataTemplate，下面我们就为Student类型实例量身定做“衣服”。

 

[html]  view plain copy print ?
 
  1. <Window x:Class="WpfApplication1.Window8"  
  2.         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
  3.         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"  
  4.         Title="Window8" Height="356" Width="471">  
  5.     <Grid>  
  6.         <StackPanel Height="295" HorizontalAlignment="Left" Margin="10,10,0,0" Name="stackPanel1" VerticalAlignment="Top" Width="427">  
  7.             <TextBlock Height="23" Name="textBlock1" Text="学员编号:" />  
  8.             <TextBox Height="23" Name="txtStudentId" Width="301" HorizontalAlignment="Left"/>  
  9.             <TextBlock Height="23" Name="textBlock2" Text="学员列表:" />  
  10.             <ListBox Height="208" Name="lbStudent" Width="305" HorizontalAlignment="Left">  
  11.                 <ListBox.ItemTemplate>  
  12.                     <DataTemplate>  
  13.                         <StackPanel Name="stackPanel2" Orientation="Horizontal">  
  14.                             <TextBlock  Text="{Binding Id}" Margin="5" Background="Beige"/>  
  15.                             <TextBlock Text="{Binding Name}" Margin="5"/>  
  16.                             <TextBlock  Text="{Binding Age}" Margin="5"/>  
  17.                         </StackPanel>  
  18.                     </DataTemplate>  
  19.                 </ListBox.ItemTemplate>  
  20.             </ListBox>  
  21.               
  22.         </StackPanel>  
  23.     </Grid>  
  24. </Window>  


运行效果图:

 

WPF之Binding深入探讨--Darren_第14张图片

最后特别提醒大家一点:

在使用集合类型的数据作为列表控件的ItemSource时一般会考虑使用ObservableCollection<T>替换List<T>，因为ObservableCollection<T>类实现了INotifyChange和INotifyPropertyChanged接口，能把集合的变化立刻通知显示到它的列表控件上，改变会立刻显示出来。

 

1.3.8     使用ADO.NET对象作为Binding的源

在.Net开发工作中，我们用ADO.NET类对数据库进行操作。常见的工作就是从数据库中读取数据到DataTable中，在把DataTable里的数据绑定的UI的控件里面（如成绩单、博客列表）。尽管在流行的软件架构中并不把DataTable中的数据直接显示在UI列表控件里面而是先通过LINQ等手段把DataTable里的数据转换成恰当的用户自定义类型集合，但WPF也支持DataTable也支持在列表控件和DataTable里直接建立Binding。

现在我们做一个实例来讲解如何在DataTable和UI建立Binding：

多数情况下我们会用ListView控件来显示一个DataTable，XAML代码如下:

 

[html]  view plain copy print ?
 
  1. <Window x:Class="WpfApplication1.Window9"  
  2.         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
  3.         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"  
  4.         Title="Window9" Height="345" Width="482">  
  5.     <StackPanel Height="279" Name="stackPanel1" Width="431">  
  6.         <ListView Height="247" Name="listView1" Width="376">  
  7.             <ListView.View>  
  8.                 <GridView>  
  9.                      
  10.                         <GridViewColumn Header="ID" DisplayMemberBinding="{Binding Id}" Width="60">  
  11.                               
  12.                         </GridViewColumn>  
  13.                         <GridViewColumn Header="Name" DisplayMemberBinding="{Binding Name}" Width="60">  
  14.   
  15.                         </GridViewColumn>  
  16.                         <GridViewColumn Header="Age" DisplayMemberBinding="{Binding Age}" Width="60">  
  17.   
  18.                         </GridViewColumn>  
  19.                         <GridViewColumn Header="Sex" DisplayMemberBinding="{Binding Sex}" Width="60">  
  20.   
  21.                         </GridViewColumn>  
  22.                       
  23.                 </GridView>  
  24.             </ListView.View>  
  25.         </ListView>  
  26.     </StackPanel>  
  27. </Window>  


这里我们有几点需要注意的地方:

 

从字面上来理解，ListView和GridView应该属于同一级别的控件，实际上远非这样！ListView是ListBox的派生类而GridView是ViewBase的派生类，ListView中的View是一个ViewBase对象，所以，GridView可以做为ListView的View来使用而不能当作独立的控件来使用。这里使用理念是组合模式，即ListView有一个View，但是至于是GridView还是其它类型的View，由程序员自己选择----目前只有一个GridView可用，估计微软在这里还会有扩展。其次，GridView的内容属性是Columns，这个属性是GridViewColumnCollection类型对象。因为XAML支持对内容属性的简写，可以省略<GridView.Columns>这层标签，直接在GridView的内容部分定义3个<GridViewColumn>对象，GridViewColumn中最重要的一个属性是DisplayBinding（类型是BindingBase），使用这个属性可以指定这一列使用什么样的Binding去关联数据------这与ListBox有点不同，ListBox使用的是DisplayMemberPath属性(类型是string)。如果想用更复杂的结构来表示这一标题或数据，则可为GridViewColumn设置HeadTemplate和CellTemplate，它们的类型都是DataTemplate。

运行效果如下:

WPF之Binding深入探讨--Darren_第15张图片

后台代码如下:

 

[csharp]  view plain copy print ?
 
  1. public Window9()  
  2.        {  
  3.            InitializeComponent();  
  4.            DataTable dtInfo = CreateDataTable();  
  5.            for (int i = 0; i < 10; i++)  
  6.            {  
  7.                DataRow dr = dtInfo.NewRow();  
  8.                dr[0] = i;  
  9.                dr[1] = "猴王" + i;  
  10.                dr[2] = i + 10;  
  11.                dr[3] = "男";  
  12.                dtInfo.Rows.Add(dr);  
  13.            }  
  14.    
  15.            this.listView1.ItemsSource = dtInfo.DefaultView;  
  16.        }  
  17.   
  18.   
  19.        private DataTable CreateDataTable()  
  20.        {  
  21.            DataTable dt = new DataTable("newtable");  
  22.              
  23.            DataColumn[] columns = new DataColumn[]{new DataColumn("Id"),new DataColumn("Name"),new DataColumn("Age"),new DataColumn("Sex")};  
  24.            dt.Columns.AddRange(columns);  
  25.            return dt;  
  26.        }  


通过上面的例子我们已经知道DataTable的DefaultView可以做为ItemSource来使用，拿DataTable直接用可以吗，让我们试试看：

 

 

[csharp]  view plain copy print ?
 
  1. InitializeComponent();  
  2.            DataTable dtInfo = CreateDataTable();  
  3.            for (int i = 0; i < 10; i++)  
  4.            {  
  5.                DataRow dr = dtInfo.NewRow();  
  6.                dr[0] = i;  
  7.                dr[1] = "猴王" + i;  
  8.                dr[2] = i + 10;  
  9.                dr[3] = "男";  
  10.                dtInfo.Rows.Add(dr);  
  11.            }  
  12.    
  13.            this.listView1.ItemsSource = dtInfo;  


编译的时候系统会报错提示:

 

错误 1无法将类型“System.Data.DataTable”隐式转换为“System.Collections.IEnumerable”。存在一个显式转换(是否缺少强制转换?)d:\我的文档\visual studio 2010\Projects\WpfApplication2\WpfApplication1\Window9.xaml.cs3642WpfApplication1

显然DataTable不能直接拿来为ItemSource赋值。不过，当你把DataTable对象放在一个对象的Context属性的时候，并把一个ItemSource与一个既没有指定Source又没有指定Path的Binding绑定起来的时候，Binding却能自动找到它的DefaultView并当作自己的Source来使用：

 

[csharp]  view plain copy print ?
 
  1. DataTable dtInfo = CreateDataTable();  
  2.             for (int i = 0; i < 10; i++)  
  3.             {  
  4.                 DataRow dr = dtInfo.NewRow();  
  5.                 dr[0] = i;  
  6.                 dr[1] = "猴王" + i;  
  7.                 dr[2] = i + 10;  
  8.                 dr[3] = "男";  
  9.                 dtInfo.Rows.Add(dr);  
  10.             }  
  11.   
  12.             this.listView1.DataContext = dtInfo;  
  13.             this.listView1.SetBinding(ListView.ItemsSourceProperty, new Binding());  


所以，如果你在代码中发现把DataTable而不是DefaultView作为DataContext值，并且为ItemSource设置一个既无Path又没有Source的Binding的时候，千万别感觉到疑虑。

 

1.3.9        使用XML数据作为Binding的源

迄今为止，.NETFramWork提供了两套处理XML数据的类库：

符合DOM（Document Object Modle，文档对象模型）标准类库：包括XmlDocument、XmlElement、XmlNode、XmlAttribute等类。这套类库的特点是中规中矩，功能强大，但也背负了太多了XML的传统和复杂。

以LINQ（Language-Intergrated Query，语言集成查询）为基础的类库：包括XDocument，XElement，XNode，XAttribute等类。这套类库的特点是可以通过LINQ进行查询和操作，方便快捷。

下面我们主要讲解一下标准类型的类库，基于LINQ的查询我们放在下一节讨论。

现在程序设计只要涉及到远程传输就离不开XML，因为大多数数据传输是基于SOAP(Simple Object Access Protocol，简单对象访问协议)相关文档协议，而SOAP又是将对象序列化为XML文本进行传输。XML文本是树形结构的，所以XML可以方便的用于表示线性集合（如Array、List等）和树形结构数据。

注意:

在使用XML数据作为Binding的Source的时候我们将使用XPath属性而不是Path属性来指定数据的来源。

我们先看一个线性集合的例子。下面的XML文本是一组文本信息，我们要把它显示在一个ListView控件里：

 

[html]  view plain copy print ?
 
  1. <?xml version="1.0" encoding="utf-8" ?>  
  2. <StudentList>  
  3.   <Student id="1">  
  4.     <Name>Andy</Name>  
  5.   </Student>  
  6.   <Student id="2">  
  7.     <Name>Jacky</Name>  
  8.   </Student>  
  9.   <Student id="3">  
  10.     <Name>Darren</Name>  
  11.   </Student>  
  12.   <Student id="4">  
  13.     <Name>DK</Name>  
  14.   </Student>  
  15.   <Student id="1">  
  16.     <Name>Jim</Name>  
  17.   </Student>  
  18. </StudentList>  

对应的XAML如下：

 

 

[csharp]  view plain copy print ?
 
  1. <Window x:Class="WpfApplication1.Window10"  
  2.         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
  3.         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"  
  4.         Title="Window10" Height="397" Width="485">  
  5.     <StackPanel Width="409" Height="331" Background="LightBlue">  
  6.         <ListView Height="302" Name="listView1" Width="396">  
  7.             <ListView.View>  
  8.                 <GridView>  
  9.                     <GridViewColumn Header="ID" DisplayMemberBinding="{Binding XPath=@id}" Width="80">  
  10.                           
  11.                     </GridViewColumn>  
  12.                     <GridViewColumn Header="Name" DisplayMemberBinding="{Binding XPath=Name}" Width="150">  
  13.   
  14.                     </GridViewColumn>  
  15.                 </GridView>  
  16.             </ListView.View>  
  17.         </ListView>  
  18.     </StackPanel>  
  19. </Window>  

C#代码如下：

 

 

[csharp]  view plain copy print ?
 
  1. private void BindingInfo()  
  2. {  
  3.     XmlDocument doc = new XmlDocument();  
  4.     doc.Load(@"d:\我的文档\visual studio 2010\Projects\WpfApplication2\WpfApplication1\StudentData.xml");  
  5.   
  6.     XmlDataProvider dp = new XmlDataProvider();  
  7.     dp.Document = doc;  
  8.   
  9.     dp.XPath = @"StudentList/Student";  
  10.     this.listView1.DataContext = dp;  
  11.     this.listView1.SetBinding(ListView.ItemsSourceProperty, new Binding());  
  12. }  


程序运行效果如下：

 

WPF之Binding深入探讨--Darren_第16张图片

XMLDataProvider还有一个名为Source的属性，可以直接用它指定XML文档所在位置（无论是XML文档是存储在本地硬盘还是网络位置），所以，后台代码也可以写成如下：

 

[csharp]  view plain copy print ?
 
  1. private void BindingInfo()  
  2.         {  
  3.             //XmlDocument doc = new XmlDocument();  
  4.             //doc.Load(@"d:\我的文档\visual studio 2010\Projects\WpfApplication2\WpfApplication1\StudentData.xml");  
  5.   
  6.             XmlDataProvider dp = new XmlDataProvider();  
  7.             dp.Source = new Uri(@"d:\我的文档\visual studio 2010\Projects\WpfApplication2\WpfApplication1\StudentData.xml");  
  8.            // dp.Document = doc;  
  9.   
  10.             dp.XPath = @"StudentList/Student";  
  11.             this.listView1.DataContext = dp;  
  12.             this.listView1.SetBinding(ListView.ItemsSourceProperty, new Binding());  
  13.         }  


XAML最关键的两句：DisplayMemberBinding="{Binding XPath=@id}"和DisplayMemberBinding="{Binding XPath=Name}"，他们分别为GridView两列指定了要关注的XML路径----很明显，使用@符号加字符串表示的是XML元素的Attribute，不加@符号表示的是子级元素。

 

XML语言可以方便的表示树形数据结构，下面的例子是使用TreeView控件来显示拥有若干层目录的文件系统，而且，这次把XML数据和XMLDataProvider对象直接写在XAML里面，代码中用到了HierarchicalDataTemplate类，这个类具有ItemsSource属性，可见由这种Template展示的数据是可以有子级集合的。代码如下：

 

[html]  view plain copy print ?
 
  1. <Window x:Class="WpfApplication1.Window11"  
  2.         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
  3.         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"  
  4.         Title="Window11" Height="349" Width="545">  
  5.     <Window.Resources>  
  6.         <XmlDataProvider x:Key="xdp" XPath="FileSystem/Folder">  
  7.             <x:XData>  
  8.                 <FileSystem xmlns="">  
  9.                     <Folder Name="Books">  
  10.                         <Folder Name="Programming">  
  11.                             <Folder Name="Windows">  
  12.                                 <Folder Name="WPF">  
  13.                                    
  14.                                 </Folder>  
  15.                                 <Folder Name="Winform">  
  16.   
  17.                                 </Folder>  
  18.                                 <Folder Name="ASP.NET">  
  19.   
  20.                                 </Folder>  
  21.                             </Folder>  
  22.                         </Folder>  
  23.                     </Folder>  
  24.                     <Folder Name="Tools">  
  25.                         <Folder Name="Development"/>  
  26.                         <Folder Name="Designment"/>  
  27.                         <Folder Name="Players"/>  
  28.                     </Folder>  
  29.                 </FileSystem>  
  30.             </x:XData>  
  31.         </XmlDataProvider>  
  32.     </Window.Resources>  
  33.     <Grid>  
  34.         <TreeView Height="283" HorizontalAlignment="Left"  Name="treeView1" VerticalAlignment="Top" Width="511" ItemsSource="{Binding Source={StaticResource ResourceKey=xdp}}">  
  35.             <TreeView.ItemTemplate>  
  36.                 <HierarchicalDataTemplate ItemsSource="{Binding XPath=Folder}">  
  37.                     <TextBlock Height="23" HorizontalAlignment="Left"  Name="textBlock1" Text="{Binding XPath=@Name}" VerticalAlignment="Top" />  
  38.                 </HierarchicalDataTemplate>  
  39.             </TreeView.ItemTemplate>  
  40.         </TreeView>  
  41.           
  42.     </Grid>  
  43. </Window>  


注意：

 

将XmlDataProvider直接写在XAML代码里面，那么他的数据需要放在<x:XData>标签中。

由于本例子设计到了StaticResource和HierarchicalDataTemplate，都是后面的内容，相对比较难懂，等学习完后面的Resource和Template章节之后再回来便会了然于胸。

程序运行效果如下图：

WPF之Binding深入探讨--Darren_第17张图片

1.3.10      使用LINQ检索结果做为Binding 的源

至3.0版本开始，.NET Framework开始支持LINQ（Language-Intergrated Query   语言集成查询），使用LINQ，我们可以方便的操作集合对象、DataTable对象和XML对象不必动辄不动把好几层foreach循环嵌套在一起却只是为了完成一个很简单的任务。

LINQ查询的结果是一个IEnumerable<T>类型对象，而IEnumerable<T>又派生自IEnumerable，所以它可以作为列表控件的ItemsSource来使用。

先创建一个名为Student的类：

 

[csharp]  view plain copy print ?
 
  1. public class Student  
  2.   {  
  3.       public int Id { get; set; }  
  4.       public string Name { get; set; }  
  5.       public int Age { get; set; }  
  6.   }  

XAML代码如下：

 

 

[html]  view plain copy print ?
 
  1. <Window x:Class="WpfApplication1.Window12"  
  2.         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
  3.         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"  
  4.         Title="Window12" Height="372" Width="538">  
  5.     <Grid>  
  6.         <ListView Height="311" HorizontalAlignment="Left" Margin="10,10,0,0" Name="listView1" VerticalAlignment="Top" Width="494">  
  7.             <ListView.View>  
  8.                 <GridView>  
  9.                     <GridViewColumn Header="ID" DisplayMemberBinding="{Binding Id}" Width="100"/>  
  10.                     <GridViewColumn Header="Name" DisplayMemberBinding="{Binding Name}" Width="100"/>  
  11.                     <GridViewColumn Header="Age" DisplayMemberBinding="{Binding Age}" Width="100"/>  
  12.                 </GridView>  
  13.             </ListView.View>  
  14.         </ListView>  
  15.     </Grid>  
  16. </Window>  

 

 

后台代码如下：

[csharp]  view plain copy print ?
 
  1. private void BindingData()  
  2.         {  
  3.             List<Student> infos = new List<Student>()  
  4.             {  
  5.                 new Student(){Id=1, Age=29, Name="Tim"},  
  6.                  new Student(){Id=1, Age=28, Name="Tom"},  
  7.                   new Student(){Id=1, Age=27, Name="Kyle"},  
  8.                    new Student(){Id=1, Age=26, Name="Tony"},  
  9.                     new Student(){Id=1, Age=25, Name="Vina"},  
  10.                      new Student(){Id=1, Age=24, Name="Mike"}  
  11.             };  
  12.             this.listView1.ItemsSource = from stu in infos where stu.Name.StartsWith("T") select stu;  
  13.         }  

如果数据存放在一个DataTable对象里面，则后台代码如下：

 

[csharp]  view plain copy print ?
 
  1. private void BindingDataByDataTable()  
  2.        {  
  3.            DataTable dtInfo = CreateDataTable();  
  4.            this.listView1.ItemsSource = from row in dtInfo.Rows.Cast<DataRow>()  
  5.                                         where Convert.ToString(row["Name"]).StartsWith("T")  
  6.                                         select new Student()  
  7.                                         {  
  8.                                             Id = Convert.ToInt32(row["Id"]), Name=Convert.ToString(row["Name"]),Age=Convert.ToInt32(row["Age"])  
  9.                                         };  
  10.              
  11.        }  

如果数据存储在XML里面，存储格式如下：

 

 

[html]  view plain copy print ?
 
  1. <?xml version="1.0" encoding="utf-8" ?>  
  2. <StudentList>  
  3.   <Class>  
  4.     <Student Id="0" Age="29" Name="Tim" />  
  5.     <Student Id="0" Age="28" Name="Tom" />  
  6.     <Student Id="0" Age="27" Name="Mess" />  
  7.   </Class>  
  8.   <Class>  
  9.     <Student Id="0" Age="26" Name="Tony" />  
  10.     <Student Id="0" Age="25" Name="Vina" />  
  11.     <Student Id="0" Age="24" Name="Emily" />  
  12.   </Class>  
  13. </StudentList>  


则代码是这样（注意：xd.Descendants("Student")这个方法，它可以跨XML的层级）：

 

 

[csharp]  view plain copy print ?
 
  1. private void BindingDataByXml()  
  2.         {  
  3.             XDocument xd = XDocument.Load(@"d:\我的文档\visual studio 2010\Projects\WpfApplication2\WpfApplication1\testDate.xml");  
  4.   
  5.             this.listView1.ItemsSource = from element in xd.Descendants("Student")  
  6.                                          where element.Attribute("Name").Value.StartsWith("T")  
  7.                                          select new Student()  
  8.                                              {  
  9.                                                  Name = element.Attribute("Name").Value,  
  10.                                                  Id = Convert.ToInt32(element.Attribute("Id").Value),  
  11.                                                  Age = Convert.ToInt32(element.Attribute("Age").Value)  
  12.                                              };  
  13.         }  

 

 

程序运行效果如下图:

WPF之Binding深入探讨--Darren_第18张图片

1.3.11    使用ObjectDataProvider作为binding的Source

理想情况下，上游程序员将类设计好、使用属性把数据暴露出来，下游程序员将这些类作为Binding的Source、把属性作为Binding的Path来消费这些类。但很难保证一个类的属性都用属性暴露出来，比如我们需要的数据可能是方法的返回值。而重新设计底层类的风险和成本会比较高，况且黑盒引用类库的情况下我们不可能更改已经编译好的类，这时候需要使用ObjectDataProvider来包装做为Binding源的数据对象了。

ObjcetDataProvider 顾名思义就是把对对象作为数据源提供给Binding。前面还提到过XmlDataProvider，这两个类的父类都是DataSourceProvider抽象类。

现在有一个名为Calculator的类，它具有加、减、乘、除的方法：

 

[csharp]  view plain copy print ?
 
  1. public class Caculate  
  2. {  
  3.     public string Add(string arg1,string arg2)  
  4.     {  
  5.         double x = 0;  
  6.         double y = 0;  
  7.         double z = 0;  
  8.         if(double.TryParse(arg1,out x)&&double.TryParse(arg2,out y))  
  9.         {  
  10.             z = x + y;  
  11.             return z.ToString();  
  12.         }  
  13.         return "Iput Error";  
  14.     }  
  15.   
  16.     //其它方法省略  
  17. }  


我们先写一个非常简单的小例子来了解下ObjectDataProvider类。随便新建一个WPF窗体，窗体内拖放一个控件，控件的Click事件如下：

 

 

[csharp]  view plain copy print ?
 
  1. private void button1_Click(object sender, RoutedEventArgs e)  
  2.      {  
  3.          ObjectDataProvider odp = new ObjectDataProvider();  
  4.          odp.ObjectInstance = new Caculate();  
  5.          odp.MethodName="Add";  
  6.          odp.MethodParameters.Add("100");  
  7.          odp.MethodParameters.Add("200");  
  8.          MessageBox.Show(odp.Data.ToString());  
  9.   
  10.      }  


运行程序，单击button我们会看到如下界面：

 

WPF之Binding深入探讨--Darren_第19张图片

通过这个程序我们可以了解到ObjectDataProvider对象和它被包装的对象关系如下图：

WPF之Binding深入探讨--Darren_第20张图片

 

了解了ObjectDataProvider的使用方法，我们看看如何把它当作Binding的Source来使用。程序的XAML代码和截图如下：

 

[html]  view plain copy print ?
 
  1. <Window x:Class="WpfApplication1.Window14"  
  2.         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
  3.         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"  
  4.         Title="Window14" Height="202" Width="345">  
  5.     <StackPanel Background="LightBlue">  
  6.         <TextBox Height="23" Name="textBox1" Width="200" HorizontalAlignment="Left" Margin="15"/>  
  7.         <TextBox Height="23" Name="textBox2" Width="200" HorizontalAlignment="Left" Margin="15"/>  
  8.         <TextBox Height="23" Name="textBox3" Width="200" HorizontalAlignment="Left" Margin="15"/>  
  9.     </StackPanel>  
  10. </Window>  


WPF之Binding深入探讨--Darren_第21张图片

 

这个程序实现的功能是，我在前两个TextBox里面输入值的时候，第三个TextBox会显示前两个文本框里面相加之和。把代码写在一个名为SetBinding的方法里面，然后在窗体的构造器里面调用这个方法：

 

[csharp]  view plain copy print ?
 
  1. private void SetBinding()  
  2.        {  
  3.            ObjectDataProvider objpro = new ObjectDataProvider();  
  4.            objpro.ObjectInstance = new Caculate();  
  5.            objpro.MethodName = "Add";  
  6.            objpro.MethodParameters.Add("0");  
  7.            objpro.MethodParameters.Add("0");  
  8.            Binding bindingToArg1 = new Binding("MethodParameters[0]") { Source=objpro,BindsDirectlyToSource=true, UpdateSourceTrigger= UpdateSourceTrigger.PropertyChanged};  
  9.            Binding bindingToArg2 = new Binding("MethodParameters[1]") { Source=objpro,BindsDirectlyToSource=true,UpdateSourceTrigger=UpdateSourceTrigger.PropertyChanged};  
  10.            Binding bindToResult = new Binding(".") { Source=objpro};  
  11.            this.textBox1.SetBinding(TextBox.TextProperty, bindingToArg1);  
  12.            this.textBox2.SetBinding(TextBox.TextProperty, bindingToArg2);  
  13.            this.textBox3.SetBinding(TextBox.TextProperty,bindToResult);  
  14.        }  


让我们先来分析一下上面两段代码，前面说过，ObjectDataProvider类的作用是包装一个以方法暴露数据的对象，这里我们先创建了一个ObjectDataProvider的对象，然后用一个Caculate对象为其ObjectInstance对象赋值---这就把一个Caculate对象包装在了ObjectDataProvider里面。还有另外一个办法来创建被包装的对象，那就是告诉包装对象被包装对象的类型和希望调用的构造器，让ObjectDataProvider自己来创建对象，代码大概是这样：

 

 

[csharp]  view plain copy print ?
 
  1. //---  
  2.            objpro.ObjectInstance = typeof(Caculate);  
  3.            objpro.ConstructorParameters.Add(arg1);  
  4.            objpro.ConstructorParameters.Add(arg2);  
  5.            //----  


因为在XAML中创建对象比较麻烦，可读性差，所以我们一般会在XAML代码中使用这种指定类型和构造器的办法。

 

接着，我们使用MethodName属性指定要调用的Caculator对象中名为Add的方法---问题又来了，如果Caculator有多个构造器参数的方法Add应该如何区分？我们知道，重载方法的区别在于参数列表，紧接着两句就是向MethodParameter属性里面加入两个string类型的参数，这就相当于告诉ObjectDataProvider对象去调用Caculator对象中具有两个string类型参数的Add方法，换句话说，MethodParameter对于参数的感应是非常敏感的。

准备好数据源之后，我们准备创建Binding。前面我们已经讲过使用索引器作为Binding的Path，第一个Binding它的Source是一个ObjectDataProvider对象，Path是ObjectDataProvider中MethodParameters所引用的第一个元素。BindsDirectlyToSource这句话是告诉Binding只是将UI上的值传递给源而不是被ObjectDataProvider包装的Caculator，同时UpdateSourceTrigger设置为UI只要一有变化就更新Source。第二个Binding只是对第一个的翻版，只是把Path属性指向了第二个元素。第三个binding仍然使用ObjectDataProvider作为Source，但使用“.”作为Path----前面讲过，当数据源本身就是数据的时候就用“.”来做为Path，在XAML中"."可以不写。

注意：

在ObjectDataProvider对象作为Binding的Source的时候，这个对象本身就代表了数据，所以这里的Path使用的“.”，而不是Data属性。

最后几行就是将Binding对象关联到3个TextBox对象上。程序运行效果如下：

WPF之Binding深入探讨--Darren_第22张图片

一般情况下数据从那里来，哪里就是Binding的Source，数据到哪里去，哪里就是Binding 的Target。按这个理论，前两个TextBox应该是ObjcetDataProvider的源，而ObjcetDataProvider对象又是最后一个TextBox的源。但实际上，三个TextBox都以ObjcetDataProvider作为数据源，只是前两个在数据流向上做了限制，这样做的原因不外乎有两个：

1、ObjcetDataProvider的MethodParameter不是依赖属性，不能作为Binding的目标。

2、数据驱动UI理念要求我们尽可能的使用数据对象作为Binding的Source而把UI当做Binding的Target。

1.3.12    使用Binding的RelativeSource

当一个Binding有明确的来源的时候，我们可以通过Source或者ElementName赋值的办法让Binding与之关联。有些时候我们不能确定作为Source对象叫什么名字，但是我们知道它与做为Binding目标对象在UI上的相对关系，比如控件自己关联自己的某个数据，关联自己某级容器的数据，这时候就需要用到Binding的RelativeSource属性。

RelativeSource属性的类型是RelativeSource类，通过这个类的几个静态或者非静态的属性我们可以控制它搜索相对数据源的方式。请看下面这段代码：

 

[html]  view plain copy print ?
 
  1. <Window x:Class="WpfApplication1.Window15"  
  2.         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
  3.         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"  
  4.         Title="Window15" Height="375" Width="516">  
  5.     <Grid Background="Red" Margin="10" x:Name="gd1">  
  6.         <DockPanel x:Name="dp1" Margin="10" Background="Orange">  
  7.             <Grid Background="Yellow" Margin="10" x:Name="gd2">  
  8.                 <DockPanel Name="dp2" Margin="10" Background="LawnGreen">  
  9.                     <TextBox  Name="textBox1"  Margin="10" FontSize="24"/>  
  10.                 </DockPanel>  
  11.             </Grid>  
  12.         </DockPanel>  
  13.     </Grid>  
  14. </Window>  

界面运行结果如下：

 

WPF之Binding深入探讨--Darren_第23张图片

我们把TextBox的Text属性关联到外层容器的Name属性上。在窗体的构造器里面添加如下几行代码：

 

[csharp]  view plain copy print ?
 
  1. RelativeSource rs = new RelativeSource(RelativeSourceMode.FindAncestor);  
  2.            rs.AncestorLevel = 1;  
  3.            rs.AncestorType = typeof(Grid);  
  4.            Binding bind = new Binding("Name") { RelativeSource = rs };  
  5.            this.textBox1.SetBinding(TextBox.TextProperty, bind);  

或在XAML代码中插入等效代码：

 

 

[html]  view plain copy print ?
 
  1. <TextBox  Name="textBox1"  Margin="10" FontSize="24" Text="{Binding Path=Name, RelativeSource={RelativeSource Mode=FindAncestor,AncestorType={x:Type Grid},AncestorLevel=1}}"/>  

AncestorLevel属性指定的是以Binding目标控件为起点的层级偏移量---gd2的偏移量是1，gd2的偏移量是2，依次类推。AncestorType属性告诉Binding去找什么类型的对象作为自己的源，不是这个类型的对象会被跳过。上面这段代码的意思是告诉Binding从自己的第一层依次向外找，找到第一个Grid类型对象后把它当作自己的源。运行效果如下图：

 

WPF之Binding深入探讨--Darren_第24张图片
如果把代码改成如下这样：

 

[csharp]  view plain copy print ?
 
  1. RelativeSource rs = new RelativeSource(RelativeSourceMode.FindAncestor);  
  2.            rs.AncestorLevel = 2;  
  3.            rs.AncestorType = typeof(DockPanel);  
  4.            Binding bind = new Binding("Name") { RelativeSource = rs };  
  5.            this.textBox1.SetBinding(TextBox.TextProperty, bind);  


或者把XAML代码改成如下：

 

 

[html]  view plain copy print ?
 
  1. Text="{Binding Path=Name, RelativeSource={RelativeSource Mode=FindAncestor,AncestorType={x:Type DockPanel},AncestorLevel=2}}"  

运行效果如下：

 

WPF之Binding深入探讨--Darren_第25张图片

如果TextBox需要关联自身的Name属性，那么代码应该这样写：

 

[csharp]  view plain copy print ?
 
  1. RelativeSource rs = new RelativeSource(RelativeSourceMode.Self);  
  2.             
  3.            Binding bind = new Binding("Name") { RelativeSource = rs };  
  4.            this.textBox1.SetBinding(TextBox.TextProperty, bind);  


对应的XAML代码如下：

 

 

[html]  view plain copy print ?
 
  1. Text="{Binding Path=Name, RelativeSource={RelativeSource Mode=Self}}"  

运行效果如下图：

 

WPF之Binding深入探讨--Darren_第26张图片

RelativeSource类的Mode属性是RelativeSourceMode枚举，它的值有：PriviousData、TemplatedParent、Self和FindAncestor。RelativeSource还有3个静态属性：PriviousData、Self、TemplatedParent，它们的类型是RelativeSource类。实际上这3个静态属性就是创建一个RelativeSource的实例、把实例的Mode设置为相对应的值，然后返回这个实例。之所以准备这3个静态属性是为了在XAML代码里面直接获取RelativeSource实例。

在DataTemplate中经常用到这这3个静态属性，学习DataTemplate的时候请留意它们的使用方法。

1.4      binding对数据的转换和校验

前面我们已经知道Binding的作用就是架在Source和Target之间的桥梁，数据可以在这座桥梁的帮助下来流通。就像现实社会中桥梁需要设置安检和关卡一样，Binding这座桥上也可以设置关卡对数据进行验证，不仅如此，如果Binding两端需要不同的数据类型的时候我们还可以为数据设置转换器。

Binding用于数据有效性校验的关卡是他的ValidationRules属性，用于数据类型转换的关卡是它的Convert属性。

1.4.1          Binding的数据校验

Binding的ValidationRules属性是Collection<ValidationRule>，从它的名称和数据类型我们可以得知可以为每个Binding设置多个数据校验条件，每一个条件是一个ValidationRule对象。ValidationRule是一个抽象类，在使用的时候我们需要创建它的派生类并实现它的Validate方法的返回值是ValidateionResult类型对象，如果通过验证，就把ValidateionResult对象的IsValidate属性设为true，反之，则需要将IsValidate设置为false并为其ErrorContent属性设置一个合适的消息内容（一般是字符串）。

下面这个程序的UI绘制一个TextBox和一个Slider，然后在后台C#代码中建立Binding把它们关联起来---- 已Slide为源，TextBox为目标。Slider的取值范围是0~100，也就是说我们需要验证TextBox中输入的值是不是在0~100之间。

程序的XAML部分如下：

 

[html]  view plain copy print ?
 
  1. <Window x:Class="WpfApplication1.Window16"  
  2.         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
  3.         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"  
  4.         Title="Window16" Height="300" Width="300">  
  5.     <StackPanel Background="AliceBlue" Margin="10">  
  6.         <TextBox Height="23" Name="textBox1" Width="200" Margin="20"/>  
  7.         <Slider Height="23" Name="slider1" Width="219" Maximum="100" />  
  8.     </StackPanel>  
  9. </Window>  

为了进行校验，我们准备一个ValidationRule的派生类，内容如下：

 

 

[csharp]  view plain copy print ?
 
  1. public class RangeValidationRule : ValidationRule  
  2. {  
  3.   
  4.     public override ValidationResult Validate(object value, System.Globalization.CultureInfo cultureInfo)  
  5.     {  
  6.         double d = 0;  
  7.         if(double.TryParse(value.ToString(),out d))  
  8.         {  
  9.             if(d>=0&&d<=100)  
  10.             {  
  11.                 return new ValidationResult(true,null);  
  12.             }  
  13.         }  
  14.         return new ValidationResult(false,"ErrorContent");  
  15.     }  
  16. }  


然后在窗体里面建立Binding：

 

 

[csharp]  view plain copy print ?
 
  1. public Window16()  
  2.        {  
  3.            InitializeComponent();  
  4.            Binding bind =new Binding("Value") { UpdateSourceTrigger= UpdateSourceTrigger.PropertyChanged,Source=slider1, Mode= BindingMode.TwoWay};  
  5.            ValidationRule rule = new RangeValidationRule();  
  6.            rule.ValidatesOnTargetUpdated = true;  
  7.            bind.ValidationRules.Add(rule);  
  8.   
  9.            this.textBox1.SetBinding(TextBox.TextProperty, bind);  
  10.        }  

完成后运行程序，当输入0~100之间的值的时候程序正常显示，但是输入区间之外的值的时候TextBox会显示为红色边框，表示值是错误的，不能传值给Source。效果如下图：

 

WPF之Binding深入探讨--Darren_第27张图片WPF之Binding深入探讨--Darren_第28张图片

先把Silider的取值范围从0~100改为-100~200：

WPF之Binding深入探讨--Darren_第29张图片WPF之Binding深入探讨--Darren_第30张图片

你也许回想，在验证错误的时候，ValidationResult会携带一条错误信息，那么如何使用这条错误信息呢？想要用到这一点，需要用到后面会详细讲解到的知识-----路由事件（Routed Event）。

首先在创建Binding 的时候要把Binding的对象的NotifyOnValidationError属性设置为true，这样，当数据校验失败的时候Binding就像报警器一样发出一个信号。这个信号会在已Binding对象的Target为起点的UI树上进行传播。信号没到达一个节点，如果这个节点设置了对这种信号的侦听器（事件处理器），那么这个侦听器就会被触发并处理这个信号，信号处理完毕后，还可以是否让信号继续沿着UI树向上传播---这就是路由事件。信号在UI树上传递的过程称为路由（Route）。

建立Binding的代码如下：

 

[csharp]  view plain copy print ?
 
  1. public Window16()  
  2.        {  
  3.            InitializeComponent();  
  4.            Binding bind =new Binding("Value") { UpdateSourceTrigger= UpdateSourceTrigger.PropertyChanged,Source=slider1, Mode= BindingMode.TwoWay};  
  5.            ValidationRule rule = new RangeValidationRule();  
  6.            rule.ValidatesOnTargetUpdated = true;  
  7.            bind.ValidationRules.Add(rule);  
  8.            bind.NotifyOnValidationError = true;  
  9.            this.textBox1.SetBinding(TextBox.TextProperty, bind);  
  10.            this.textBox1.AddHandler(Validation.ErrorEvent, new RoutedEventHandler(ValidationError));  
  11.        }  


用于侦听校验错误事件的事件处理器如下：

 

 

[csharp]  view plain copy print ?
 
  1. private void ValidationError(object sender, RoutedEventArgs e)  
  2.         {  
  3.             if (Validation.GetErrors(textBox1).Count > 0)  
  4.             {  
  5.                 this.textBox1.ToolTip = Validation.GetErrors(textBox1)[0].ErrorContent.ToString();  
  6.             }  
  7.             else  
  8.             {  
  9.                 this.textBox1.ToolTip = "";  
  10.             }  
  11.         }  


程序如果校验失败，就会使用ToolTip提示用户，如下图：

 

WPF之Binding深入探讨--Darren_第31张图片

1.4.2    Binding的数据转换

前面的很多例子我们都在使用Binding将TextBox和Slider之间建立关联----Slider控件作为Source（Path的Value属性），TextBox作为Target（目标属性为Text）。不知道大家有没有注意到，Slider的Value属性是Double类型值，而TextBox的Text属性是string类型的值，在C#这种强类型语言中却可以来往自如，是怎么回事呢？

原来Binding还有另外一种机制称为数据转换，当Source端指定的Path属性值和Target端指定的目标属性不一致的时候，我们可以添加数据转换器（DataConvert）。上面我们提到的问题实际上就是double和stirng类型相互转换的问题，因为处理起来比较简单，所以WPF类库就自己帮我们做了，但有些数据类型转换就不是WPF能帮我们做的了，例如下面的这种情况：

 

  • Source里面的值是Y、N、X三个值（可能是Char类型，string类型或者自定义枚举类型），UI上对应的是CheckBox控件，需要把这三个值映射为它的IsChecked属性值（bool类型）。
  • 当TextBox里面必须输入的有类容时候用于登录的Button才会出现，这是string类型与Visibility枚举类型或bool类型之间的转换（Binding的Model将是oneway）。
  • Source里面的值有可能是Male或FeMale（string或枚举），UI是用于显示图片的Image控件，这时候需要把Source里面值转换为对应的头像图片URI（亦是oneway）。

 

当遇到这些情况，我们只能自己动手写Converter，方法是创建一个类并让这个类实现IValueConverter接口，IValueConverter定义如下：

 

[csharp]  view plain copy print ?
 
  1. public interface IValueConverter  
  2. {  
  3.     object Convert(object value, Type targetType, object parameters, CultureInfo culture);  
  4.     object ConvertBack(object value, Type targetType, object parameters, CultureInfo culture);  
  5. }  

当数据从Binding的Source流向Target的时候，Convert方法将被调用；反之ConvertBack将被调用。这两个方法的参数列表一模一样：第一个参数为Object。最大限度的保证了Convert的重要性。第二个参数用于确定返回参数的返回类型。第三个参数为了将额外的参数传入方法，若需要传递多个信息，则需要将信息做为一个集合传入即可。

 

Binding对象的Mode属性将影响这两个方法的调用；如果Mode为TwoWay或Default行为与TwoWay一致则两个方法都有可能被调用。如果Mode是OneWay或者Default行为与OneWay一致则只有Convert方法会被调用。其它情况同理。

下面这个例子是一个Converter的综合实例，程序的用途是向玩家显示一些军用飞机的状态信息。

首先创建几个自定义数据类型：

 

[csharp]  view plain copy print ?
 
  1. public enum Category  
  2.    {  
  3.        Bomber,  
  4.        Fighter  
  5.    }  
  6.   
  7.    public enum State  
  8.    {  
  9.        Available,  
  10.        Locked,  
  11.        Unknown  
  12.    }  
  13.   
  14.    public class Plane  
  15.    {  
  16.        public Category category { get; set; }  
  17.        public State state { get; set; }  
  18.        public string name { get; set; }  
  19.    }  


在UI里，Category的状态被映射为图标，这两个图标已经被我放入项目中，如图：

 

WPF之Binding深入探讨--Darren_第32张图片

同时飞机的State属性在UI里面被映射为CheckBox。因为存在以上两种映射关系。我们需要提供两个Converter：一个有Categroy类型单向转换为string类型（XAML会把string解析为图片资源），另一个是State和bool类型直接的双向转换。代码如下：

 

[csharp]  view plain copy print ?
 
  1. public class CategoryToSourceConverter:IValueConverter  
  2.     {  
  3.   
  4.         public object Convert(object value, Type targetType, object parameters, System.Globalization.CultureInfo culture)  
  5.         {  
  6.             Category category = (Category)value;  
  7.             switch (category)  
  8.             {  
  9.                 case Category.Bomber:  
  10.                     return @"ICONS/Bomber.png";  
  11.                      
  12.                 case Category.Fighter:  
  13.                     return @"ICONS/Fighter.png";  
  14.                      
  15.                 default:  
  16.                     return null;  
  17.                       
  18.             }  
  19.         }  
  20.   
  21.         public object ConvertBack(object value, Type targetType, object parameters, System.Globalization.CultureInfo culture)  
  22.         {  
  23.             throw new NotImplementedException();  
  24.         }  
  25.     }  

 

[csharp]  view plain copy print ?
 
  1. public class StateToNullableBoolConverter:IValueConverter  
  2.     {  
  3.   
  4.         public object Convert(object value, Type targetType, object parameters, System.Globalization.CultureInfo culture)  
  5.         {  
  6.             State state = (State)value;  
  7.             switch (state)  
  8.             {  
  9.                 case State.Available:  
  10.                     return true;  
  11.                       
  12.                 case State.Locked:  
  13.                     return false;  
  14.                 case State.Unknown:  
  15.                       
  16.                 default:  
  17.                     return null;  
  18.             }  
  19.         }  
  20.   
  21.         public object ConvertBack(object value, Type targetType, object parameters, System.Globalization.CultureInfo culture)  
  22.         {  
  23.             bool? nb = (bool?)value;  
  24.             switch (nb)  
  25.             {  
  26.                 case true:  
  27.                     return State.Available;  
  28.                 case false:  
  29.                     return State.Locked;  
  30.                 case null:  
  31.                 default:  
  32.                     return State.Unknown;  
  33.                       
  34.             }  
  35.         }  
  36.     }  


下面我们来看看如何在XAML代码里面来消费这些Converter：

 

 

[html]  view plain copy print ?
 
  1. <Window x:Class="WpfApplication1.Window17"  
  2.         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
  3.         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"  
  4.         xmlns:local="clr-namespace:WpfApplication1.BLL"  
  5.         Title="Window17" Height="327" Width="460">  
  6.     <Window.Resources>  
  7.         <local:CategoryToSourceConverter x:Key="cts" />  
  8.         <local:StateToNullableBoolConverter x:Key="snb" />  
  9.     </Window.Resources>  
  10.     <StackPanel Name="stackPanel1" Background="AliceBlue" Margin="10">  
  11.         <ListBox  Name="listBox1" Height="160" Margin="5">  
  12.             <ListBox.ItemTemplate>  
  13.                 <DataTemplate>  
  14.                     <StackPanel Orientation="Horizontal">  
  15.                         <Image Height="16" Name="image1" Stretch="Fill" Width="16" Source="{Binding Path=category,Converter={StaticResource cts}}"/>  
  16.                         <TextBlock Height="23" Name="textBlock1" Text="{Binding name}" Margin="8,0" Width="80"/>  
  17.                         <CheckBox  Height="16" Name="checkBox1" IsChecked="{Binding Path=state,Converter={StaticResource snb}}" IsThreeState="True"/>  
  18.                     </StackPanel>  
  19.                 </DataTemplate>  
  20.             </ListBox.ItemTemplate>  
  21.         </ListBox>  
  22.         <Button Content="Load" Height="23" Name="button1" Width="131" Margin="5" Click="button1_Click" />  
  23.         <Button Content="Save" Height="23" Name="button2" Width="131" Margin="5" Click="button2_Click" />  
  24.     </StackPanel>  
  25. </Window>  

Load按钮的事件处理器负责把一组飞机的数据赋值给ListBox的ItemSource属性，Save的Click事件负责把用户修改过的数据写入文件：

 

 

[csharp]  view plain copy print ?
 
  1. /// <summary>  
  2.         /// Load按钮事件处理器  
  3.         /// </summary>  
  4.         /// <param name="sender"></param>  
  5.         /// <param name="e"></param>  
  6.         private void button1_Click(object sender, RoutedEventArgs e)  
  7.         {  
  8.             List<Plane> infos = new List<Plane>() {   
  9.             new Plane(){ category= Category.Bomber,name="B-1", state= State.Unknown},  
  10.             new Plane(){ category= Category.Bomber,name="B-2", state= State.Unknown},  
  11.             new Plane(){ category= Category.Fighter,name="F-22", state= State.Locked},  
  12.             new Plane(){ category= Category.Fighter,name="Su-47", state= State.Unknown},  
  13.             new Plane(){ category= Category.Bomber,name="B-52", state= State.Available},  
  14.             new Plane(){ category= Category.Fighter,name="J-10", state= State.Unknown},  
  15.             };  
  16.             this.listBox1.ItemsSource = infos;  
  17.         }  
  18.         /// <summary>  
  19.         /// Save按钮事件处理器  
  20.         /// </summary>  
  21.         /// <param name="sender"></param>  
  22.         /// <param name="e"></param>  
  23.         private void button2_Click(object sender, RoutedEventArgs e)  
  24.         {  
  25.             StringBuilder sb = new StringBuilder();  
  26.             foreach (Plane item in listBox1.Items)  
  27.             {  
  28.                 sb.AppendLine(string.Format("Categroy={0},State={1},Name={2}",item.category,item.state,item.name));  
  29.             }  
  30.             File.WriteAllText(@"D:\PlaneList.text",sb.ToString());  
  31.         }  


运行程序，单击CheckBox修改飞机的State，如图：

 

WPF之Binding深入探讨--Darren_第33张图片WPF之Binding深入探讨--Darren_第34张图片

单击Save后打开D:\\PlaneList.text数据如下图：

WPF之Binding深入探讨--Darren_第35张图片

1.5   MultiBinding(多路Binding)

有时候UI需要显示的数据来源不止一个数据来源决定，这个时候就需要用到MultiBinding，即多路绑定。MultiBinding与Binding一样均以BindingBase为基类，也就是说，凡是能用Binding的场合都能使用MultiBinding。MutiBinding具有一个Bindings的属性，其类型是Connection<BindingBase>，通过这个属性,MultiBinding把一组Binding对象聚合起来，处在这个Binding结合中的对象可以拥有自己的数据校验和转换机制。它们汇集起来的数据将共同决定传往MultiBinding目标的数据。如下图：

WPF之Binding深入探讨--Darren_第36张图片

考虑这样一个需求，有一个用于新用户注册的UI（4个TextBox和一个Button），还有如下一些限定：

 

  • 第一，二个TextBox用于输入用户名，要求数据必须一致。
  • 第三，四个TextBox用于显示输入的邮箱，要求数据必须一致。
  • 当TextBox的内容全部符合要求的时候，Button可用。

 

此UI的XAML代码如下：

 

[html]  view plain copy print ?
 
  1. <Window x:Class="WpfApplication1.Window18"  
  2.         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
  3.         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"  
  4.         Title="Window18" Height="300" Width="300">  
  5.     <StackPanel Name="stackPanel1"  Margin="10" Background="AliceBlue">  
  6.         <TextBox Height="23" Name="textBox1" Margin="5" />  
  7.         <TextBox Height="23" Name="textBox2" Margin="5" />  
  8.         <TextBox Height="23" Name="textBox3" Margin="5" />  
  9.         <TextBox Height="23" Name="textBox4" Margin="5" />  
  10.         <Button Content="Regist" Height="23" Name="btnSubmit" Width="75"  Margin="10"/>  
  11.     </StackPanel>  
  12. </Window>  


后台代码如下：

 

 

[csharp]  view plain copy print ?
 
  1. public Window18()  
  2.        {  
  3.            InitializeComponent();  
  4.            SetBinding();  
  5.        }  
  6.   
  7.        private void SetBinding()  
  8.        {  
  9.            //准备基础Binding  
  10.            Binding bind1 = new Binding("Text") { Source=textBox1};  
  11.            Binding bind2 = new Binding("Text") { Source = textBox2 };  
  12.            Binding bind3 = new Binding("Text") { Source = textBox3 };  
  13.            Binding bind4 = new Binding("Text") { Source = textBox4 };  
  14.   
  15.            //准备MultiBinding  
  16.            MultiBinding mb = new MultiBinding() { Mode= BindingMode.OneWay};  
  17.            mb.Bindings.Add(bind1);//注意，MultiBinding对子元素的顺序是很敏感的。  
  18.            mb.Bindings.Add(bind2);  
  19.            mb.Bindings.Add(bind3);  
  20.            mb.Bindings.Add(bind4);  
  21.            mb.Converter = new MultiBindingConverter();  
  22.            ///将Binding和MultyBinding关联  
  23.            this.btnSubmit.SetBinding(Button.IsVisibleProperty, mb);  
  24.        }  


注意：

 

 

  • MultiBinding对子元素的顺序非常敏感，因为这个数据决定了汇集到Convert里数据的顺序。
  • MultiBinding的Converter实现的是IMultiValueConverter。

 

本例的Converter代码如下：

 

[csharp]  view plain copy print ?
 
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Linq;  
  4. using System.Text;  
  5. using System.Windows.Data;  
  6.   
  7. namespace WpfApplication1.BLL  
  8. {  
  9.     public class MultiBindingConverter:IMultiValueConverter  
  10.     {  
  11.         public object Convert(object[] values, Type targetType, object parameter, System.Globalization.CultureInfo culture)  
  12.         {  
  13.             if(!values.Cast<string>().Any(text=>string.IsNullOrEmpty(text))&&values[0].ToString()==values[1].ToString()&&values[3].ToString()==values[4].ToString())  
  14.             {  
  15.                 return true;  
  16.             }  
  17.             return false;  
  18.         }  
  19.         /// <summary>  
  20.         /// 该方法不会被调用  
  21.         /// </summary>  
  22.         /// <param name="value"></param>  
  23.         /// <param name="targetTypes"></param>  
  24.         /// <param name="parameter"></param>  
  25.         /// <param name="culture"></param>  
  26.         /// <returns></returns>  
  27.         public object[] ConvertBack(object value, Type[] targetTypes, object parameter, System.Globalization.CultureInfo culture)  
  28.         {  
  29.             throw new NotImplementedException();  
  30.         }  
  31.     }  
  32. }  

程序运行效果如图：

 

WPF之Binding深入探讨--Darren_第37张图片    WPF之Binding深入探讨--Darren_第38张图片

小结：

WPF的核心理念是变传统的UI驱动数据变成数据驱动UI，支撑这个理念的基础就是本章讲的Data Binding和与之相关的数据校验和数据转换。在使用Binding的时候，最重要的就是设置它的源和路径。

 

 

Data Binding到此讲解完毕。


 

 







 

 

转载请注明出处:http://blog.csdn.net/fwj380891124

你可能感兴趣的:(bind)

  • WPF中的ComboBox控件几种数据绑定的方式 互联网打工人no1 wpfc#
    一、用字典给ItemsSource赋值（此绑定用的地方很多，建议熟练掌握）在XMAL中：在CS文件中privatevoidBindData(){DictionarydicItem=newDictionary();dicItem.add(1,"北京");dicItem.add(2,"上海");dicItem.add(3,"广州");cmb_list.ItemsSource=dicItem;cmb_l
  • docker igotyback eureka云原生
    Docker容器的文件系统是隔离的，但是可以通过挂载卷（Volumes）或绑定挂载（BindMounts）将宿主机的文件系统目录映射到容器内部。要查看Docker容器的映射路径，可以使用以下方法：查看容器配置：使用dockerinspect命令可以查看容器的详细配置信息，包括挂载的卷。例如：bashdockerinspect在输出的JSON格式中，查找"Mounts"部分，这里会列出所有的挂载信息
  • Spring Boot中实现跨域请求 BABA8891 springboot后端java
    在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
  • 【RabbitMQ 项目】服务端：数据管理模块之绑定管理 月夜星辉雪 rabbitmq分布式
    文章目录一.编写思路二.代码实践一.编写思路定义绑定信息类交换机名称队列名称绑定关键字：交换机的路由交换算法中会用到没有是否持久化的标志，因为绑定是否持久化取决于交换机和队列是否持久化，只有它们都持久化时绑定才需要持久化。绑定就好像一根绳子，两端连接着交换机和队列，当一方不存在，它就没有存在的必要了定义绑定持久化类构造函数：如果数据库文件不存在则创建，打开数据库，创建binding_table插入
  • SpringBoot 设置传入参数非必要 loveLifeLoveCoding springbootspringbootjavaspring
    查看RequestParam源码packageorg.springframework.web.bind.annotation;importjava.lang.annotation.Documented;importjava.lang.annotation.ElementType;importjava.lang.annotation.Retention;importjava.lang.annotat
  • html 删除事件,html 事件的添加和删除 列蒂齐亚 html删除事件
    jQuery在jQuery1.7版本中bind()unbind(),live()die(),on()off(),delegate()下面我们给li元素添加事件bind()旧版写法:事件不能适用脚本创建的新元素live()旧版写法:适用脚本创建的新元素写法，但性能极不好on()新版写法，事件不能适用脚本创建的新元素(接收多个函数绑定)这三种方法都是基于要给添加事件的元素本身。$("ulli").bi
  • JavaScript 基础 - 第15天 +码农快讯+ JavaScript学习笔记javascript前端开发语言
    文章目录JavaScript基础-第15天深浅拷贝浅拷贝深拷贝通过JSON序列化实现js库lodash实现深拷贝通过递归实现深拷贝异常处理throwtry...catchdebugger处理this改变thiscallapplybindthis指向性能优化防抖（debounce）手写防抖函数节流（throttle）手写节流函数JavaScript基础-第15天深浅拷贝浅拷贝浅拷贝：把对象拷贝给一个
  • Android-悬浮窗功能的实现（附Java、KT实现源码）(1) egrhef 程序员androidjava开发语言
    //获取服务的操作对象valbinder=serviceasFloatWinfowServices.MyBinderbinder.service}overridefunonServiceDisconnected(name:ComponentName){}}overridefunonActivityResult(requestCode:Int,resultCode:Int,data:Intent){
  • udp的广播，多播，单播 demo mengzhi啊 udp网络
    enumclassEMsgType:uint8_t{EMSGT_SINGLE,//单播EMSGT_MULTICAST,//多播EMSGT_BROADCAST,//广播};sendSocket=newQUdpSocket(this);sendSocket->setSocketOption(QAbstractSocket::MulticastTtlOption,1);sendSocket->bind(
  • Apache DataFusion Python 绑定教程 柏赢安Simona
    ApacheDataFusionPython绑定教程datafusion-pythonApacheDataFusionPythonBindings项目地址:https://gitcode.com/gh_mirrors/data/datafusion-python项目介绍ApacheDataFusion是一个基于ApacheArrow的内存查询引擎，提供了高性能的查询处理能力。DataFusion的
  • Camera2 CameraService 启动 yaoming168 CameraFramewrokandroid
    文章目录frameworks/av/media/mediaserver/main_mediaserver.cppframeworks/av/media/mediaserver/Android.bpframeworks/native/include/binder/BinderService.hframeworks/av/services/camera/libcameraservice/CameraS
  • java 什么是多态性_Java多态性理解 职路施语 java什么是多态性
    什么是多态面向对象的三大特性：封装、继承、多态。从一定角度来看，封装和继承几乎都是为多态而准备的。这是我们最后一个概念，也是最重要的知识点。多态的定义：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。(发送消息就是函数调用)实现多态的技术称为：动态绑定(dynamicbinding)，是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应
  • BindingException: Invalid bound statement (not found) 小卡车555 MyBatismybatisjavamysql
    Mybatis出现绑定异常问题的解决org.apache.ibatis.binding.BindingException:Invalidboundstatement(notfound)一般的原因是Mapperinterface和xml文件的定义对应不上，需要检查包名，namespace，函数名称等能否对应上，需要比较细致的对比，我经常就是写错了一两个字母搞的很长时间找不到错误按以下步骤一一执行：1
  • socket网络编程 jdq_summer socket网络编程socket网络编程
    TCP实现网络通信：服务器端一、创建服务器套接字（CREATE）。二、服务器套接字进行信息绑定（BIND），并开始监听连接（LISTEN）。三、接受来自客户端的连接请求（ACCEPT），并创建接收进程。四、开始数据传输(SEND、RECEIVE)。五、关闭套接字（CLOSESOCKET）。客户机端一、创建客户机套接字（CREATE）。二、与远程服务器进行连接（CONNECT），如被接受则创建接收进
  • 《Android内核剖析》笔记 第5章 进程间通信核心框架Binder 2401_84408814 程序员android笔记binder
    服务端：即服务提供者，比如android就提供了很多的系统服务，比如Alarm、WIFI、INPUT、LAYOUT_INFLATER、ACTIVITY等；当然开发者也可以实现自己的服务，然后把服务开放给其他应用使用，在代码上服务接口必须继承IInterface，服务具体实现类必须继承Binder；Binder驱动：实际上他是一个遵从Linux设备驱动模型的虚拟驱动，设备节点为/dev/binder
  • 登录校验实现——Jwt、Filter/Interceptor 应起忆 javaspring
    Jwt令牌生成引入依赖，JDK8之后的版本需要引入JAXBjavax.xml.bindjaxb-api2.3.1org.glassfish.jaxbjaxb-runtime2.3.1io.jsonwebtokenjjwt0.9.1写JwtUtilsimportio.jsonwebtoken.Claims;importio.jsonwebtoken.Jwts;importio.jsonwebtoke
  • 【React】MobX 小秀_heo React及其周边生态react.js前端前端框架
    概述mobx实现像vue一样声明式的修改数据，我们在项目中直接使用mobx+mobx-react。mobxjs/mobx-react:ReactbindingsforMobX(github.com)https://zh.mobx.js.org/the-gist-of-mobx.htmlstate数据action动作derivation派生computedobserver监听变化，包裹的React组
  • 网络套接字编程（二） knight-n 网络网络linuxc++
    socket常见API创建套接字：（TCP/UDP，客户端+服务器）intsocket(intdomain,inttype,intprotocol);绑定端口号：（TCP/UDP，服务器）intbind(intsockfd,conststructsockaddr*addr,socklen_taddrlen);监听套接字：（TCP，服务器）intlisten(intsockfd,intbacklog
  • 微信小程序自定义组件及传参 墨染凉梦 微信小程序小程序
    1.新建文件夹，然后右键选择新建components2.组件的js结构如下图所示3.使用组件，在需要引用组件的页面json配置中引入组件4.组件传参之父传子父组件直接传参子组件在properties中接收，直接使用即可5.子组件传参给父组件子组件使用this.triggerEvent('事件名',参数)进行传参。父组件bind+事件名='回调方法'进行接收，并在回调方法中可以获得传递的参数
  • Qt中的QTcpSocket作为客户端的时候获取绑定的端口号 一路初心向前 Qt
    在socket中，客户端socket并不是必须调用bind函数来指定端口号。而是在连接成功之后会给客户端socket自动分配一个可用的端口号。解决办法在QTcpSocket调用了connectToHost函数成功连接服务端之后。会触发一个QTcpSocket::connected信号。编写相关的槽函数。在槽函数中调用localPort函数就可以获取客户端自动绑定的端口号。作为服务端由于作为服务端(
  • 入坑解决mybatis plus not found mapper(最准确解决办法) weixin_45863786 mybatismybatisplus
    具体报错信息报错信息：org.apache.ibatis.binding.BindingException:Invalidboundstatement(notfound):xxx.mapper.CourseMapper.getCourseTeacherDetail，很多文章说是mapper的namespace路径不对,或者替换原来mbatis-plus-boot-starter相关依赖等，更换原来
  • 总结函数相关知识 你会发光哎u JavaScript高级学习javascript前端开发语言
    这里写目录标题1.函数的特性声明调用参数参数默认值返回值属性方法arguments剩余参数（`rest`）作用域原型`this`指向执行过程2.特殊的函数`with`函数`eval`函数apply/call/bind函数纯函数箭头函数立即执行函数`IIFE`高阶函数递归函数组合函数柯里化函数概念优势自动柯里化类和构造函数JavaScript是支持函数式编程的，在JavaScript中函数是一等公民
  • DNS主从服务架构（thirteen day） 沉迷于学习的网络狗 服务器网络运维
    回顾编号主机名IP地址说明修改1web服务器192.168.1.11发布部署web服务发布了一个nginxweb服务2DNS服务器192.168.1.22用于解析域名和IP地址1、安装bind2、配置一个conf，zones，zone3、检查了3个文件4、启动3client主机192.168.1.33用于模拟客户机修改dns的访问主机临时修改echo“nameserver192.168.1.22”
  • 提高工作效率的利器！快来体验 Vimo Rebinder Vimo Rebinder 软件需求鼠标键盘rpa
    你是否在繁忙的工作中感到力不从心？是否被复杂的快捷键弄得头晕目眩？别担心！VimoRebinder来帮你轻松解决这些问题！什么是VimoRebinder？VimoRebinder不是普通的App，它是一套完整的快捷键系统和操作方法。通过使用VimoRebinder和相应的方法，旨在帮助你实现简单高效的快捷键记忆和使用，大幅度提高工作效率。VimoRebinder的独特优势：轻松记忆：简化大量快捷键
  • 【已解决】onnx无法找到CUDA的路径 烟花节 已解决人工智能深度学习pythonpip
    报错RuntimeError:D:\a\_work\1\s\onnxruntime\python\onnxruntime_pybind_state.cc:857onnxruntime::python::CreateExecutionProviderInstanceCUDA_PATHissetbutCUDAwasntabletobeloaded.Pleaseinstallthecorrectvers
  • DataBinding-Android JetpacK 组件之一 Mac Zhu androidjetpackandroid
    一、DataBinding简介在传统的Android应用开发中，布局文件通常只负责应用界面的布局工作，如果需要实现页面交互就需要调用setContentView()将Activity、fragment和XML布局文件关联起来。然后通过控件的id找到控件，接着在页面中通过代码对控件进行逻辑处理。在这种传统的开发方式中，页面承担了大部分的工作量，大量的逻辑处理需要在Activity、Fragment中
  • 编程模型 咔啡
    本节介绍SpringCloudStream的编程模型。SpringCloudStream提供了许多预定义的注释，用于声明绑定的输入和输出通道，以及如何收听频道。声明和绑定频道触发绑定@EnableBinding您可以将Spring应用程序转换为SpringCloudStream应用程序，将@EnableBinding注释应用于应用程序的配置类之一。@EnableBinding注释本身使用@Conf
  • HBuilderX 安装 scss/sass编译 插件报错 binding.node 解决方案windows版 这个需求建议不做 uni-app小程序
    HBuilderX安装scss/sass编译插件报错binding.node解决方案windows版官方给出的解决方案让我们在命令行执行下面三行代码[0;31m-->LibSass的二进制文件(C:\ProgramFiles\HBuilderX\plugins\compile-node-sass\node_modules\node-sass-china\vendor\win32-ia32-72\b
  • 2021-10-06 多去看看
    下载完数据后，一用do.call(dplyr::bind_rows,diagnose)然后去clinical$demographic两者用patient_id合并，可以得到数据现在做单因素分析，然后lasso回归分析已经得到数据表，单因素分析需要什么？似乎需要的数据不多，看看怎么弄做单因素分析：基因表达值，生存状态：死亡或者存活，生存时间那剩下的那些是个什么鬼生存分析，生存时间，生存状态生存分析模
  • 不同编程语言之间的互操作:Py,Js,Java调用C/C++ procoder338 杂项cppjavascriptjavac语言
    个人博客:Sekyoro的博客小屋个人网站:Proanimer的个人网站当项目比较大涉及到多门编程语言时会有这种需求.通常是要求调用C/C++等.某些语言之间相对来说调用就比较简单,比如Go和C,Rust和C等,这几个语言之间互相调用就很方便.但是其他语言相对来说就麻烦了.本文主要涉及Python,JS,Java和C/C+的互相调用,以备不时之需.TL;DR:Python使用pybind11,JS
  • java线程Thread和Runnable区别和联系 zx_code javajvmthread多线程Runnable
    我们都晓得java实现线程2种方式，一个是继承Thread，另一个是实现Runnable。 模拟窗口买票，第一例子继承thread，代码如下 package thread; public class ThreadTest { public static void main(String[] args) { Thread1 t1 = new Thread1(
  • 【转】JSON与XML的区别比较 丁_新 jsonxml
    1.定义介绍 (1).XML定义 扩展标记语言 (Extensible Markup Language, XML) ，用于标记电子文件使其具有结构性的标记语言，可以用来标记数据、定义数据类型，是一种允许用户对自己的标记语言进行定义的源语言。 XML使用DTD(document type definition)文档类型定义来组织数据;格式统一，跨平台和语言，早已成为业界公认的标准。 XML是标
  • c++ 实现五种基础的排序算法 CrazyMizzz C++c算法
    #include<iostream> using namespace std; //辅助函数，交换两数之值 template<class T> void mySwap(T &x, T &y){ T temp = x; x = y; y = temp; } const int size = 10; //一、用直接插入排
  • 我的软件 麦田的设计者 我的软件音乐类娱乐放松
         这是我写的一款app软件，耗时三个月，是一个根据央视节目开门大吉改变的，提供音调，猜歌曲名。1、手机拥有者在android手机市场下载本APP，同意权限，安装到手机上。2、游客初次进入时会有引导页面提醒用户注册。（同时软件自动播放背景音乐）。3、用户登录到主页后，会有五个模块。a、点击不胫而走，用户得到开门大吉首页部分新闻，点击进入有新闻详情。b、
  • linux awk命令详解 被触发 linux awk
    awk是行处理器: 相比较屏幕处理的优点，在处理庞大文件时不会出现内存溢出或是处理缓慢的问题，通常用来格式化文本信息 awk处理过程: 依次对每一行进行处理，然后输出 awk命令形式: awk [-F|-f|-v] ‘BEGIN{} //{command1; command2} END{}’ file [-F|-f|-v]大参数，-F指定分隔符，-f调用脚本，-v定义变量 var=val
  • 各种语言比较 _wy_ 编程语言
                        Java Ruby PHP 擅长领域                  
  • oracle 中数据类型为clob的编辑 知了ing oracle clob
    public void updateKpiStatus(String kpiStatus,String taskId){ Connection dbc=null; Statement stmt=null; PreparedStatement ps=null; try { dbc = new DBConn().getNewConnection(); //stmt = db
  • 分布式服务框架 Zookeeper -- 管理分布式环境中的数据 矮蛋蛋 zookeeper
    原文地址： http://www.ibm.com/developerworks/cn/opensource/os-cn-zookeeper/ 安装和配置详解 本文介绍的 Zookeeper 是以 3.2.2 这个稳定版本为基础，最新的版本可以通过官网 http://hadoop.apache.org/zookeeper/来获取，Zookeeper 的安装非常简单，下面将从单机模式和集群模式两
  • tomcat数据源 alafqq tomcat
    数据库 JNDI(Java Naming and Directory Interface，Java命名和目录接口)是一组在Java应用中访问命名和目录服务的API。 没有使用JNDI时我用要这样连接数据库： 03.  Class.forName("com.mysql.jdbc.Driver");  04.  conn
  • 遍历的方法 百合不是茶 遍历
                                                          遍历 在java的泛
  • linux查看硬件信息的命令 bijian1013 linux
    linux查看硬件信息的命令 一.查看CPU： cat /proc/cpuinfo   二.查看内存： free   三.查看硬盘： df   linux下查看硬件信息 1、lspci 列出所有PCI 设备； lspci - list all PCI devices:列出机器中的PCI设备（声卡、显卡、Modem、网卡、USB、主板集成设备也能
  • java常见的ClassNotFoundException bijian1013 java
    1.java.lang.ClassNotFoundException: org.apache.commons.logging.LogFactory   添加包common-logging.jar2.java.lang.ClassNotFoundException: javax.transaction.Synchronization    
  • 【Gson五】日期对象的序列化和反序列化 bit1129 反序列化
    对日期类型的数据进行序列化和反序列化时，需要考虑如下问题：   1. 序列化时，Date对象序列化的字符串日期格式如何 2. 反序列化时，把日期字符串序列化为Date对象，也需要考虑日期格式问题 3. Date A -> str -> Date B,A和B对象是否equals   默认序列化和反序列化     import com
  • 【Spark八十六】Spark Streaming之DStream vs. InputDStream bit1129 Stream
      1. DStream的类说明文档：   /** * A Discretized Stream (DStream), the basic abstraction in Spark Streaming, is a continuous * sequence of RDDs (of the same type) representing a continuous st
  • 通过nginx获取header信息 ronin47 nginx header
    1. 提取整个的Cookies内容到一个变量，然后可以在需要时引用，比如记录到日志里面， if ( $http_cookie ~* "(.*)$") {         set $all_cookie $1; }     变量$all_cookie就获得了cookie的值，可以用于运算了
  • java-65.输入数字n，按顺序输出从1最大的n位10进制数。比如输入3，则输出1、2、3一直到最大的3位数即999 bylijinnan java
    参考了网上的http://blog.csdn.net/peasking_dd/article/details/6342984 写了个java版的： public class Print_1_To_NDigit { /** * Q65.输入数字n，按顺序输出从1最大的n位10进制数。比如输入3，则输出1、2、3一直到最大的3位数即999 * 1.使用字符串
  • Netty源码学习-ReplayingDecoder bylijinnan javanetty
    ReplayingDecoder是FrameDecoder的子类，不熟悉FrameDecoder的，可以先看看 http://bylijinnan.iteye.com/blog/1982618 API说，ReplayingDecoder简化了操作，比如： FrameDecoder在decode时，需要判断数据是否接收完全： public class IntegerH
  • js特殊字符过滤 cngolon js特殊字符js特殊字符过滤
    1.js中用正则表达式 过滤特殊字符, 校验所有输入域是否含有特殊符号function stripscript(s) {    var pattern = new RegExp("[`~!@#$^&*()=|{}':;',\\[\\].<>/?~！@#￥……&*（）&mdash;—|{}【】‘；：”“'。，、？]"
  • hibernate使用sql查询 ctrain Hibernate
    import java.util.Iterator; import java.util.List; import java.util.Map; import org.hibernate.Hibernate; import org.hibernate.SQLQuery; import org.hibernate.Session; import org.hibernate.Transa
  • linux shell脚本中切换用户执行命令方法 daizj linuxshell命令切换用户
    经常在写shell脚本时，会碰到要以另外一个用户来执行相关命令，其方法简单记下：   1、执行单个命令：su - user -c "command" 如：下面命令是以test用户在/data目录下创建test123目录 [root@slave19 /data]# su - test -c "mkdir /data/test123" 
  • 好的代码里只要一个 return 语句 dcj3sjt126com return
    别再这样写了：public boolean foo() {    if (true) {         return true;     } else {          return false;    
  • Android动画效果学习 dcj3sjt126com android
    1、透明动画效果 方法一：代码实现 public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { View rootView = inflater.inflate(R.layout.fragment_main, container, fals
  • linux复习笔记之bash shell (4)管道命令 eksliang linux管道命令汇总linux管道命令linux常用管道命令
    转载请出自出处： http://eksliang.iteye.com/blog/2105461     bash命令执行的完毕以后，通常这个命令都会有返回结果，怎么对这个返回的结果做一些操作呢？那就得用管道命令‘|’。     上面那段话，简单说了下管道命令的作用，那什么事管道命令呢？     答：非常的经典的一句话，记住了，何为管
  • Android系统中自定义按键的短按、双击、长按事件 gqdy365 android
    在项目中碰到这样的问题： 由于系统中的按键在底层做了重新定义或者新增了按键，此时需要在APP层对按键事件（keyevent）做分解处理，模拟Android系统做法，把keyevent分解成： 1、单击事件：就是普通key的单击； 2、双击事件：500ms内同一按键单击两次； 3、长按事件：同一按键长按超过1000ms（系统中长按事件为500ms）； 4、组合按键：两个以上按键同时按住；
  • asp.net获取站点根目录下子目录的名称 hvt .netC#asp.nethovertreeWeb Forms
    使用Visual Studio建立一个.aspx文件(Web Forms)，例如hovertree.aspx,在页面上加入一个ListBox代码如下： <asp:ListBox runat="server" ID="lbKeleyiFolder" />   那么在页面上显示根目录子文件夹的代码如下： string[] m_sub
  • Eclipse程序员要掌握的常用快捷键 justjavac javaeclipse快捷键ide
      判断一个人的编程水平，就看他用键盘多，还是鼠标多。用键盘一是为了输入代码（当然了，也包括注释），再有就是熟练使用快捷键。   曾有人在豆瓣评 《卓有成效的程序员》：“人有多大懒，才有多大闲”。之前我整理了一个 程序员图书列表，目的也就是通过读书，让程序员变懒。  写道 程序员作为特殊的群体，有的人可以这么懒，懒到事情都交给机器去做，而有的人又可
  • c++编程随记 lx.asymmetric C++笔记
     为了字体更好看，改变了格式……   &&运算符：   #include<iostream> using namespace std; int main(){      int a=-1,b=4,k;      k=(++a<0)&&!(b--
  • linux标准IO缓冲机制研究 音频数据 linux
    一、什么是缓存I/O(Buffered I/O)缓存I/O又被称作标准I/O,大多数文件系统默认I/O操作都是缓存I/O。在Linux的缓存I/O机制中，操作系统会将I/O的数据缓存在文件系统的页缓存(page cache)中，也就是说，数据会先被拷贝到操作系统内核的缓冲区中，然后才会从操作系统内核的缓冲区拷贝到应用程序的地址空间。1.缓存I/O有以下优点:A.缓存I/O使用了操作系统内核缓冲区，
  • 随想 生活 暗黑小菠萝 生活
    其实账户之前就申请了，但是决定要自己更新一些东西看也是最近。从毕业到现在已经一年了。没有进步是假的，但是有多大的进步可能只有我自己知道。   毕业的时候班里12个女生，真正最后做到软件开发的只要两个包括我，PS：我不是说测试不好。当时因为考研完全放弃找工作，考研失败，我想这只是我的借口。那个时候才想到为什么大学的时候不能好好的学习技术，增强自己的实战能力，以至于后来找工作比较费劲。我
  • 我认为POJO是一个错误的概念 windshome javaPOJO编程J2EE设计
                  这篇内容其实没有经过太多的深思熟虑，只是个人一时的感觉。从个人风格上来讲，我倾向简单质朴的设计开发理念；从方法论上，我更加倾向自顶向下的设计；从做事情的目标上来看，我追求质量优先，更愿意使用较为保守和稳妥的理念和方法。    &
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他