第六章主要介绍了WPF的依赖属性，可以用来实现WPF中的样式、自动绑定及实现动画等特性。

一、依赖属性基本介绍

本篇开始学习WPF的另一个重要内容依赖属性。

大家都知道WPF带来了很多新的特性，其中一个就是引入了一种新的属性机制——依赖属性。依赖属性出现的目的是用来实现WPF中的样式、自动绑定及实现动画等特性。依赖属性的出现是WPF这种特殊的呈现原理派生出来的，与.NET普通属性不同的是，依赖属性的值是依靠多个提供程序来判断的，并且其具有内建的传递变更通知的能力。

依赖属性基本应用在了WPF的所有需要设置属性的元素。依赖属性根据多个提供对象来决定它的值 （可以是动画、父类元素、绑定、样式和模板等），同时这个值也能及时响应变化。

依赖属性就是可以自己没有值，并能够通过Binding从数据源获 取值（依赖在别人身上）的属性。拥有依赖属性的对象被称为“依赖对象”。依赖项属性的重点在于“依赖”二字，既然是依赖了，也就是说：依赖项属性的值的改变过程一定与其它对相关，不A依赖B就B依赖A，或者相互依赖。

说白了，所谓依赖，主要应用在以下地方：

1、双向绑定。有了这个，依赖项属性不用写额的代码，也不用实现什么接口，它本身就俱备双向绑定的特性，比如，我把员工对象的姓名绑定到摇文本框，一旦绑定，只要文本框中的值发生改变，依赖项属性员工姓名也会跟着变化，反之亦然；

2、触发器。这个东西在WPF中很重要，比如，一个按钮背景是红色，我想让它在鼠标停留在它上面是背景变成绿色，而鼠标一旦移开，按钮恢复红色。

如果在传统的Windows编程中，你一定会想办法弄一些事件，或者委托来处理，还要写一堆代码。告诉你，有了依赖项属性，你将一行代码都不用写，所有的处理均由WPF属性系统自动处理。而触发器只是临时改变属性的值，当触完成时，属性值自动被“还原”。

3、附加属性。附加属性也是依赖项属性，它可以把A类型的的某些属性推迟到运行时根据B类型的具体情况来进行设置，而且可以同时被多个类型对象同时维护同一个属性值，但每个实例的属性值是独立的。

4、A属性改变时，也同时改变其它属性的值，如TogleButton按下的同时，弹出下拉框。

与传统的CLR属性和面向对象相比依赖属性有很多新颖之处，其中包括：

 1、新功能的引入：加入了属性变化通知，限制、验证等等功能，这样就可以使我们更方便的实现我们的应用，同时也使代码量大大减少了，许多之前不可能的功能都可以轻松的实现了。
2、 节约内存：在WinForm等项目开发中，你会发现UI控件的属性通常都是赋予的初始值，为每一个属性存储一个字段将是对内存的巨大浪费。WPF依赖属性 允许对象在被创建的时候并不包含用于存储数据的空间（即字段所占用的空间）、只保留在需要用到数据的时候能够获得默认值。借用其它对象的数据或者实 时分配空间的能力----这种对象称为依赖对象而他这种实时获取数据的能力则依靠依赖属性来实现。在WPF开发中，必须使用依赖对象作为依赖属性的宿主， 使二者结合起来，才能形成完整的Binding目标被数据所驱动。。
3、支持多个提供对象：我们可以通过多种方式来设置依赖属性的值。同时其内部可以储存多个值，配合Expression、Style、Animation等可以给我们带来很强的开发体验。
在.NET当中，对于属性是大家应该很熟悉，封装类的字段，表示类的状态，编译后被转化为对应的get和set方法。属性可以被类或结构等使用。 一个简单的属性如下，也是我们常用的写法:

public class Student
{
    string m_Name;
    public string Name
    {
        get { return m_Name; }
        set { m_Name = value; }
    }
    static Student()
    {
    }
}

依赖属性与普通的.NET属性的区别是普通的.NET属性定义只需要定义其set和get区块的赋值与设置。那么依赖属性应该怎么定义呢？依赖属性和属性到底有什么区别和联系呢？其实依赖属性的实现也很简单，按以下步骤做就可以了：

第一步： 让自己的类继承自 DependencyObject基类。在WPF中，几乎所有的UI元素都继承自DependencyObject，这个类封装了对依赖属性的存储及 访问等操作，使用静态类型与依赖属性的内部存储机制相关。WPF处理依赖属性不再像普通.NET属性那样将属性值存储到一个私有变量中，而是使用一个字典 型的变量来存放用户显示设置的值。

第二步：依赖属性的定义必须使用 public static 声明一个 DependencyProperty的变量，并且有一个Property作为后缀，该变量才是真正的依赖属性 。例如下面的代码定义了一个依赖属性NameProperty：

public static readonly DependencyProperty NameProperty;

第三步：在静态构造函数中向属性系统注册依赖属性，并获取对象引用。依赖属性是通过调用DependencyProperty.Register静态方法创建，该方法需要传递一个属性 名称，这个名称非常重要，在定义控件Style和Template的时候，Setter的Property属性填入的值就是注册依赖属性时使用的名称。propertyType指明了依赖属性实际的类型，ownerType指明了是哪个类注册了此依赖属性，最后typeMetadata存放了一些依赖属 性的元信息，包括依赖属性使用的默认值，还有属性值发生变更时的通知函数。例如，下面的代码注册了依赖属性。

NameProperty = DependencyProperty.Register("Name", typeof(string), typeof(Student),  new PropertyMetadata("名称", OnValueChanged));

第四步：在前面的三步中，我们完成了一个依赖属性的注册，那么我们怎样才能对这个依赖属性进行读写呢？答案就是提供一个依赖属性的实例化包装属性，通过这个属性来实现具体的读写操作。和CLR属性不同，依赖属性不是直接对私有变量的操纵，而是通过GetValue()和SetValue()方法来操作属性值的，可以使用标准的.NET属性定义语法进行封装，使依赖属性可以像标准属性那样来使用，代码如下。

public string Name
      {
          get { return (string)GetValue(NameProperty); }
          set { SetValue(NameProperty, value); }
      }

根据前面的四步操作，我们就可以写出下面的代码：

public class Student : DependencyObject
{
    //声明一个静态只读的DependencyProperty字段
    public static readonly DependencyProperty NameProperty;
    static Student()
    {
        //注册我们定义的依赖属性Name
        NameProperty = DependencyProperty.Register("Name", typeof(string), typeof(Student),
            new PropertyMetadata("名称", OnValueChanged));
    }
    private static void OnValueChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
    {
        //当值改变时，我们可以在此做一些逻辑处理
    }
    //属性包装器，通过它来读取和设置我们刚才注册的依赖属性
    public string Name
    {
        get { return (string)GetValue(NameProperty); }
        set { SetValue(NameProperty, value); }
    }
}

总结：我们一般.NET属性是直接对类的一个私有属性进行封装，所以读取值的时候，也就是直接读取这个字段；而依赖属性则是通过调用继承自DependencyObject的GetValue()和SetValue来进行操作，它实际存储在DependencyProperty的一个IDictionary的键-值配对字典中，所以一条记录中的键(Key)就是该属性的HashCode值，而值(Value)则是我们注册的DependencyProperty。

二、 依赖属性的优先级

由于WPF 允许我们可以在多个地方设置依赖属性的值，所以我们就必须要用一个标准来保证值的优先级别。比如下面的例子中，我们在三个地方设置了按钮的背景颜色，那么哪一个设置才会是最终的结果呢？是Black、Red还是Azure呢？

<Window x:Class="WpfApp1.WindowDepend"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="WindowDepend" Height="400" Width="400">
    <Grid>
        <Button x:Name="myButton" Background="Azure">
            <Button.Style>
                <Style TargetType="{x:Type Button}">
                    <Setter Property="Background" Value="Black"/>
                    <Style.Triggers>
                        <Trigger Property="IsMouseOver" Value="True">
                            <Setter Property="Background" Value="Red" />
                        </Trigger>
                    </Style.Triggers>
                </Style>
            </Button.Style>
            Click
        </Button>
    </Grid>
</Window>

通过前面的简单介绍，我们了解了简单的依赖属性，每次访问一个依赖属性，它内部会按照下面的顺序由高到底处理该值。详细见下图

由于这个流程图偏理想化，在实际的工作过程中我们会遇到各种各样的问题，我也不可能都碰到，也就无法彻底把这些问题说清楚，所以当我们遇到问题之后，再进行仔细分析，查找原因，不断总结、举一反三。

三、 依赖属性的继承

属性值继承是 Windows Presentation Foundation (WPF) 属性系统的一项功能。 属性值继承使元素树中的子元素可以从父元素那里获取特定属性的值，并继承该值，就好像它是在最近的父元素中的任意位置设置的一样。 父元素还可以通过属性值继承来获得其值，因此系统有可能一直递归到页面根元素。 属性值继承不是属性系统的默认行为；属性必须用特定的元数据设置来建立，以便使该属性能够对子元素启动属性值继承。

依赖属性继承的最初意愿是父元素的相关设置会自动传递给所有层次的子元素 ，即元素可以从其在树中的父级继承依赖项属性的值。这个我们在编程当中接触得比较多，如当我们修改窗体父容器控件的字体设置时，所有级别的子控件都将自动 使用该字体设置 (前提是该子控件未做自定义设置)。接下来，我们来做一个实际的例子。代码如下：

<Window x:Class="WpfApp1.WindowInherited"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="WindowInherited" Height="400" Width="500" Loaded="Window_Loaded" >
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="101*"/>
            <RowDefinition Height="80"/>
            <RowDefinition Height="80"/>
        </Grid.RowDefinitions>
        <StackPanel Grid.Row="0" >
            <Label Content="继承自Window的FontSize" />
            <TextBlock Name="textBlockInherited" Text="重写了继承，没有继承Window的FontSize"
               FontSize="36" TextWrapping="WrapWithOverflow"/>
            <StatusBar>没有继承自Window的FontSize，Statusbar</StatusBar>
        </StackPanel>
        <WrapPanel Grid.Row="1">
            <Label Content="窗体字体大小" />
            <ComboBox Name="drpWinFontSize"></ComboBox>
            <Button Name="btnFontSize" Click="btnFontSize_Click">改变window字体</Button>
        </WrapPanel>
        <WrapPanel Grid.Row="2">
            <Label Content="文本字体大小" />
            <ComboBox Name="drpTxtFontSize"></ComboBox>
            <Button Name="btnTextBlock" Click="btnTextBlock_Click">改变TextBlock字体</Button>
        </WrapPanel>
    </Grid>
</Window>

代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;
namespace WpfApp1
{
    /// <summary>
    /// WindowInherited.xaml 的交互逻辑
    /// </summary>
    public partial class WindowInherited : Window
    {
        public WindowInherited()
        {
            InitializeComponent();
        }
        private void btnFontSize_Click(object sender, RoutedEventArgs e)
        {
            this.FontSize = Convert.ToInt32(drpWinFontSize.Text);
        }
        private void btnTextBlock_Click(object sender, RoutedEventArgs e)
        {
            this.textBlockInherited.FontSize = Convert.ToInt32(drpTxtFontSize.Text);
        }
        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            List<int> listFontSize = new List<int>();
            for (int i = 0; i <= 60; i++)
            {
                listFontSize.Add(i + 4);
            }
            drpTxtFontSize.ItemsSource = listFontSize;
            drpWinFontSize.ItemsSource = listFontSize;
        }
    }
}

效果图如下：

Window.FontSize 设置会影响所有的内部元素字体大小，这就是所谓的属性值继承，如上面代码中的第一个Label没有定义FontSize ，所以它继承了Window.FontSize的值。但一旦子元素提供了显式设置，这种继承就会被打断，如第二个TextBlock定义了自己的 FontSize，所以这个时候继承的值就不会再起作用了。

这个时候你会发现一个很奇怪的问题：虽然StatusBar没有重写FontSize，同时它也是Window的子元素，但是它的字体大小却没 有变化，保持了系统默认值。那这是什么原因呢？作为初学者可能都很纳闷，官方不是说了原则是这样的，为什么会出现表里不一的情况呢？其实仔细研究才发现并 不是所有的元素都支持属性值继承。还会存在一些意外的情况，那么总的来说是由于以下两个方面：

1、有些Dependency属性在用注册的时候时指定Inherits为不可继承，这样继承就会失效了。

2、有其他更优先级的设置设置了该值，在前面讲的的“依赖属性的优先级”你可以看到具体的优先级别。

属性值继承通过混合树操作。持有原始值的父对象和继承该值的子对象都必须是 FrameworkElement 或 FrameworkContentElement，且都必须属于某个逻辑树。 但是，对于支持属性继承的现有 WPF 属性，属性值的继承能够通过逻辑树中没有的中介对象永久存在。 这主要适用于以下情况：让模板元素使用在应用了模板的实例上设置的所有继承属性值，或者使用在更高级别的页级成分（因此在逻辑树中也位于更高位置）中设置的所有继承属性值。 为了使属性值的继承在这两种情况下保持一致，继承属性必须注册为附加属性。

这里的原因是部分控件如StatusBar、Tooptip和Menu等内部设置它们的字体属性值以匹配当前系统。这样用户通过操作系统的控制 面板来修改它们的外观。这种方法存在一个问题：StatusBar等截获了从父元素继承来的属性，并且不影响其子元素。比如，如果我们在 StatusBar中添加了一个Button。那么这个Button的字体属性会因为StatusBar的截断而没有任何改变，将保留其默认值。所以大家 在使用的时候要特别注意这些问题。

四、 只读依赖属性

在以前在对于非WPF的功能来说，对于类的属性的封装中，经常会对那些希望暴露给外界只读操作的字段封装成只读属性，同样在WPF中也提供了只读属性的概念，如一些 WPF控件的依赖属性是只读的，它们经常用于报告控件的状态和信息，像IsMouseOver等属性， 那么在这个时候对它赋值就没有意义了。 或许你也会有这样的疑问：为什么不使用一般的.Net属性提供出来呢？一般的属性也可以绑定到元素上呀？这个是由于有些地方必须要用到只读依赖属性，比如 Trigger等，同时也因为内部可能有多个提供者修改其值，所以用.Net属性就不能完成天之大任了。
那么一个只读依赖属性怎么创建呢？其实创建一个只读的依赖属性和创建一个一般的依赖属性大同小异。不同的地方就是DependencyProperty.Register变成了DependencyProperty.RegisterReadOnly。和前面的普通依赖属性一样，它将返回一个 DependencyPropertyKey。而且只提供一个GetValue给外部，这样便可以像一般属性一样使用了，只是不能在外部设置它的值罢了。

下面我们就用一个简单的例子来概括一下：

public partial class WindowReadOnly : Window
{
    public WindowReadOnly()
    {
        InitializeComponent();
        //用SetValue的方法来设置值
        DispatcherTimer timer =
            new DispatcherTimer(TimeSpan.FromSeconds(1),
                                DispatcherPriority.Normal,
                                (object sender, EventArgs e) =>
                                {
                                    int newValue = Counter == int.MaxValue ? 0 : Counter + 1;
                                    SetValue(counterKey, newValue);
                                },
                                Dispatcher);
    }
    //属性包装器，只提供GetValue
    public int Counter
    {
        get { return (int)GetValue(counterKey.DependencyProperty); }
    }
    //用RegisterReadOnly来代替Register来注册一个只读的依赖属性
    private static readonly DependencyPropertyKey counterKey =
        DependencyProperty.RegisterReadOnly("Counter",
                                            typeof(int),
                                            typeof(WindowReadOnly),
                                            new PropertyMetadata(0));
}

XAML代码：

<Window x:Name="winReadOnly" x:Class="WpfApp1.WindowReadOnly"
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  Title="WindowDepend" Height="300" Width="300">
    <Grid>
        <Viewbox>
            <TextBlock Text="{Binding ElementName=winReadOnly, Path=Counter}" />
        </Viewbox>
    </Grid>
</Window>

效果如下图所示：

五、 附加属性

现在我们再继续探讨另外一种特殊的依赖属性——附加属性。附加属性是一种特殊的依赖属性。这是WPF的特性之一，通俗的理解起来就是，别人有的属性，由于你跟他产生了关系所以你也有了这个属于他的属性。

附加属性是说一个属性本来不属于某个对象，但由于某种需求而被后来附加上，也就是把对象放入一个特定环境后对象才具有的属性就称为附加属性，附加属性的作 用就是将属性与数据类型解耦，让数据类型的设计更加灵活，举例，一个TextBox被放在不同的布局容器中时就会有不同的布局属性，这些属性就是由布局容 器为TextBox附加上的，附加属性的本质就是依赖属性，二者仅仅在注册和包装器上有一点区别。

附加属性是依赖属性的一种特殊形式，它可以让用户在一个元素中设置其他元素的属性。一般来说，附加属性是用于一个父元素定位其他元素布局 的。就像Grid和DockPanel元素就包含附加属性。Grid使用附加属性来指定包含子元素的特定行和列，而DockPanel使用附加属性是来指 定子元素应该停靠在面板中的何处位置。

附加属性就是自己没有这个属性，在某些上下文中需要就被附加上去。比如StackPanel的Grid.Row属性，如果我们定义StackPanel类时定义一个Row属性是没有意义的，因为我们并不知道一定会放在Grid里，这样就造成了浪费。

例如，下面转场控件的定义使用了Grid的Row属性来将自身定位到特定的行中。

<Grid>
    <Grid.RowDefinitions>
        <RowDefinition Height="101*"/>
        <RowDefinition Height="80"/>
        <RowDefinition Height="80"/>
    </Grid.RowDefinitions>
    <StackPanel Grid.Row="0" >

尽管对于一个普通的WPF开发人员来说，理解依赖和附加属性并不一定是必须的，但是掌握好WPF系统的整个运行机制对于提升WPF应用技术是非常重要的。

使用附加属性，可以避开可能会防止一个关系中的不同对象在运行时相互传递信息的编码约定。一定可以针对常见的基类设置属性，以便每个对象只需获取和 设置该属性即可。但是，你可能希望在很多情况下这样做，这会使你的基类最终充斥着大量可共享的属性。它甚至可能会引入以下情况：在数百个后代中，只有两个 后代尝试使用一个属性。这样的类设计很糟糕。为了解决此问题，我们使用附加属性概念来允许对象为不是由它自己的类结构定义的属性赋值。在创建对象树中的各 个相关对象之后，在运行时从子对象读取此值。

最好的例子就是布局面板。每一个布局面板都需要自己特有的方式来组织它的子元素。如Canvas需要Top和left来布 局，DockPanel需要Dock来布局。当然你也可以写自己的布局面板（在上一篇文章中我们对布局进行了比较细致的探讨，如果有不清楚的朋友也可以再 回顾一下）。

下面代码中的Button 就是用了Canvas的Canvas.Top和Canvas.Left="20" 来进行布局定位，那么这两个就是传说中的附加属性。

<Canvas>
    <Button Canvas.Top="20" Canvas.Left="20" Content="Knights Warrior!"/>
</Canvas>

定义附加属性的方法与定义依赖属性的方法一致，前面我们是使用DependencyProperty.Register来注册一个依赖属性，只是在注册属性时使用的是RegisterAttach()方法。这个RegisterAttached的参数和 Register是完全一致的，那么Attached（附加）这个概念又从何而来呢？

其实我们使用依赖属性，一直在Attached（附加）。我们注册（构造）一个依赖属性，然后在DependencyObject中通过 GetValue和SetValue来操作这个依赖属性，也就是把这个依赖属性通过这样的方法关联到了这个DependencyObject上，只不过是 通过封装CLR属性来达到的。那么RegisterAttached又是怎样的呢？

下面我们来看一个最简单的应用：首先我们注册（构造）一个附加属性

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Media;
namespace WpfApp1.Services
{
    public class TurnoverManager : DependencyObject
    {
        //通过静态方法的形式暴露读的操作
        public static double GetAngle(DependencyObject obj)
        {
            return (double)obj.GetValue(AngleProperty);
        }
        //通过静态方法的形式暴露写的操作
        public static void SetAngle(DependencyObject obj, double value)
        {
            obj.SetValue(AngleProperty, value);
        }
        //通过使用RegisterAttached来注册一个附加属性
        public static readonly DependencyProperty AngleProperty =
            DependencyProperty.RegisterAttached("Angle", typeof(double), typeof(TurnoverManager), new PropertyMetadata(0.0, OnAngleChanged));
        //根据附加属性中的值，当值改变的时候，旋转相应的角度。
        private static void OnAngleChanged(DependencyObject obj, DependencyPropertyChangedEventArgs e)
        {
            var element = obj as UIElement;
            if (element != null)
            {
                element.RenderTransformOrigin = new Point(0.5, 0.5);
                element.RenderTransform = new RotateTransform((double)e.NewValue);
            }
        }
    }
}

然后，我们在程序中使用这个我们自己定义的附加属性

<Window x:Class="WpfApp1.WindowTurnover"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:local="clr-namespace:WpfApp1.Services"
        Title="WindowTurnover" Height="400" Width="500" Loaded="Window_Loaded">
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="313*"/>
            <RowDefinition Height="57*"/>
        </Grid.RowDefinitions>
        <Canvas Grid.Row="0">
            <Ellipse Name="ellipseRed" Fill="Red" Width="100" Height="60" Canvas.Left="56"
                     Canvas.Top="98" local:TurnoverManager.Angle="{Binding ElementName=sliderAngle, Path=Value}"/>
            <Rectangle Name="ellipseBlue" Fill="Blue" Width="80" Height="80" Canvas.Left="285"
                       Canvas.Top="171" local:TurnoverManager.Angle="45" />
            <Button  Name="btnWelcome" Content="欢迎光临" Canvas.Left="265" Canvas.Top="48" FontSize="20" local:TurnoverManager.Angle="60"/>
        </Canvas>
        <WrapPanel Grid.Row="1">
            <Label Content="角度大小" />
            <Slider x:Name="sliderAngle" Minimum="0" Maximum="240" Width="300" />
        </WrapPanel>
    </Grid>
</Window>

在XAML中就可以使用刚才注册（构造）的附加属性了：如下图。

通过调整角度值，显示不同的效果如下两图。图1，图2。

图1

图2

六、依赖属性回调、验证及强制值

我们通过下面的这幅图，简单介绍一下WPF属性系统对依赖属性操作的基本步骤：

借用一个常见的图例，介绍一下WPF属性系统对依赖属性操作的基本步骤：

• 第一步，确定Base Value，对同一个属性的赋值可能发生在很多地方。比如控件的背景（Background），可能在Style或者控件的构造函数中都对它进行了赋值，这个Base Value就要确定这些值中优先级最高的值，把它作为Base Value。
• 第二步，估值。如果依赖属性值是计算表达式（Expression），比如说一个绑定，WPF属性系统就会计算表达式，把结果转化成一个实际值。
• 第三步，动画。动画是一种优先级很高的特殊行为。如果当前属性正在作动画，那么因动画而产生的值会优于前面获得的值，这个也就是WPF中常说的动画优先。
• 第四步，强制。如果我们在FrameworkPropertyMetadata中传入了 CoerceValueCallback委托，WPF属性系统会回调我们传入的的delagate，进行属性值的验证，验证属性值是否在我们允许的范围之内。例如强制设置该值必须大于于0小于10等等。在属性赋值过程中，Coerce拥有 最高的优先级，这个优先级要大于动画的优先级别。
• 第五步，验证。验证是指我们注册依赖属性如果提供了ValidateValueCallback委托，那么最后WPF会调用我们传入的delegate，来验证数据的有效性。当数据无效时会抛出异常来通知。

那么应该如何使用这些功能呢？

前面我们讲了基本的流程，下面我们就用一个小的例子来进行说明：

XAML的代码如下：

<Window x:Class="WpfApp1.WindowValid"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title=" WindowValid " Height="300" Width="400">
    <Grid>
        <StackPanel>
            <Button Name="btnDPTest" Click="btnDPTest_Click" >属性值执行顺序测试</Button>
        </StackPanel>
    </Grid>
</Window>

C#的代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;
using System.Windows.Threading;
using WpfApp1.Models;
namespace WpfApp1
{
    /// <summary>
    /// WindowThd.xaml 的交互逻辑
    /// </summary>
    public partial class WindowValid: Window
    {
        public WindowValid ()
        {
            InitializeComponent();
    }
    private void btnDPTest_Click(object sender, RoutedEventArgs e)
    {
        SimpleDP test = new SimpleDP();
        test.ValidDP = 1;
    } 
    }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
namespace WpfApp1.Models
{
    public class SimpleDP : DependencyObject
    {
        public static readonly DependencyProperty ValidDPProperty =
            DependencyProperty.Register("ValidDP", typeof(int), typeof(SimpleDP),
                new FrameworkPropertyMetadata(0,
                    FrameworkPropertyMetadataOptions.None,
                    new PropertyChangedCallback(OnValueChanged),
                    new CoerceValueCallback(CoerceValue)),
                    new ValidateValueCallback(IsValidValue));
        public int ValidDP
        {
            get { return (int)GetValue(ValidDPProperty); }
            set { SetValue(ValidDPProperty, value); }
        }
        private static void OnValueChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            Console.WriteLine("当属性值的OnValueChanged方法被调用，属性值为： {0}", e.NewValue);
        }
        private static object CoerceValue(DependencyObject d, object value)
        {
            Console.WriteLine("当属性值的CoerceValue方法被调用，属性值强制为： {0}", value);
            return value;
        }
        private static bool IsValidValue(object value)
        {
            Console.WriteLine("当属性值的IsValidValue方法被调用，对属性值进行验证，返回bool值，如果返回True表示严重通过，否则会以异常的形式抛出： {0}", value);
            return true;
        } 
    }
}

结果如下：

当ValidDP属性变化之后，PropertyChangeCallback就会被调用。可以看到结果并没有完全按照我们先前的流程先 Coerce后Validate的顺序执行，有可能是WPF内部做了什么特殊处理，当属性被修改时，首先会调用Validate来判断传入的value是 否有效，如果无效就不继续后续的操作，这样可以更好的优化性能。从上面的结果上看出，CoerceValue后面并没有立即ValidateValue， 而是直接调用了PropertyChanged。这是因为前面已经验证过了value，如果在Coerce中没有改变value，那么就不用再验证了。如 果在 Coerce中改变了value，那么这里还会再次调用ValidateValue操作，和前面的流程图执行的顺序一样，在最后我们会调用 ValidateValue来进行最后的验证，这就保证最后的结果是我们希望的那样了。

上面简单介绍了处理流程，下面我们就以一个案例来具体看一看上面的流程到底有没有出入。

依赖属性代码文件如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
namespace WpfApp1.Controls
{
    class MyValiDP : System.Windows.Controls.Control
    {
        //注册Current依赖属性，并添加PropertyChanged、CoerceValue、ValidateValue的回调委托
        public static readonly DependencyProperty CurrentValueProperty = DependencyProperty.Register(
            "CurrentValue",
            typeof(double),
            typeof(MyValiDP),
            new FrameworkPropertyMetadata(
                Double.NaN,
                FrameworkPropertyMetadataOptions.None,
                new PropertyChangedCallback(OnCurrentValueChanged),
                new CoerceValueCallback(CoerceCurrentValue)
            ),
            new ValidateValueCallback(IsValidValue)
        );
        //属性包装器，通过它来暴露Current的值
        public double CurrentValue
        {
            get { return (double)GetValue(CurrentValueProperty); }
            set { SetValue(CurrentValueProperty, value); }
        }
        //注册Min依赖属性，并添加PropertyChanged、CoerceValue、ValidateValue的回调委托
        public static readonly DependencyProperty MinValueProperty = DependencyProperty.Register(
        "MinValue",
        typeof(double),
        typeof(MyValiDP),
        new FrameworkPropertyMetadata(
            double.NaN,
            FrameworkPropertyMetadataOptions.None,
            new PropertyChangedCallback(OnMinValueChanged),
            new CoerceValueCallback(CoerceMinValue)
        ),
        new ValidateValueCallback(IsValidValue));
        //属性包装器，通过它来暴露Min的值
        public double MinValue
        {
            get { return (double)GetValue(MinValueProperty); }
            set { SetValue(MinValueProperty, value); }
        }
        //注册Max依赖属性，并添加PropertyChanged、CoerceValue、ValidateValue的回调委托
        public static readonly DependencyProperty MaxValueProperty = DependencyProperty.Register(
            "MaxValue",
            typeof(double),
            typeof(MyValiDP),
            new FrameworkPropertyMetadata(
                double.NaN,
                FrameworkPropertyMetadataOptions.None,
                new PropertyChangedCallback(OnMaxValueChanged),
                new CoerceValueCallback(CoerceMaxValue)
            ),
            new ValidateValueCallback(IsValidValue)
        );
        //属性包装器，通过它来暴露Max的值
        public double MaxValue
        {
            get { return (double)GetValue(MaxValueProperty); }
            set { SetValue(MaxValueProperty, value); }
        }
        //在CoerceCurrent加入强制判断赋值
        private static object CoerceCurrentValue(DependencyObject d, object value)
        {
            MyValiDP g = (MyValiDP)d;
            double current = (double)value;
            if (current < g.MinValue) current = g.MinValue;
            if (current > g.MaxValue) current = g.MaxValue;
            return current;
        }
        //当Current值改变的时候，调用Min和Max的CoerceValue回调委托
        private static void OnCurrentValueChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            d.CoerceValue(MinValueProperty);
            d.CoerceValue(MaxValueProperty);
        }
        //当OnMin值改变的时候，调用Current和Max的CoerceValue回调委托
        private static void OnMinValueChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            d.CoerceValue(MaxValueProperty);
            d.CoerceValue(CurrentValueProperty);
        }
        //在CoerceMin加入强制判断赋值
        private static object CoerceMinValue(DependencyObject d, object value)
        {
            MyValiDP g = (MyValiDP)d;
            double min = (double)value;
            if (min > g.MaxValue) min = g.MaxValue;
            return min;
        }
        //在CoerceMax加入强制判断赋值
        private static object CoerceMaxValue(DependencyObject d, object value)
        {
            MyValiDP g = (MyValiDP)d;
            double max = (double)value;
            if (max < g.MinValue) max = g.MinValue;
            return max;
        }
        //当Max值改变的时候，调用Min和Current的CoerceValue回调委托
        private static void OnMaxValueChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            d.CoerceValue(MinValueProperty);
            d.CoerceValue(CurrentValueProperty);
        }
        //验证value是否有效，如果返回True表示验证通过，否则会提示异常
        public static bool IsValidValue(object value)
        {
            Double v = (Double)value;
            return (!v.Equals(Double.NegativeInfinity) && !v.Equals(Double.PositiveInfinity));
        }
    }
}

XAML代码如下：

<Window x:Class="WpfApp1.WindowProcess"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:local="clr-namespace:WpfApp1.Controls"
        Title="WindowProcess" Height="400" Width="500">
    <Grid>
        <StackPanel Orientation="Vertical">
            <local:MyValiDP x:Name="myValiDP1" MaxValue="500" MinValue="0" />
            <Label Content="可以设置最小值为0和最小大值为500" Height="30"/>
            <StackPanel Orientation="Horizontal" Height="60">
                <Label Content="当前值为 : "/>
                <Label Background="Yellow" BorderBrush="Black" BorderThickness="1"
                   IsEnabled="False" Content="{Binding ElementName=myValiDP1, Path=CurrentValue}" Height="25" VerticalAlignment="Top" />
            </StackPanel>
            <WrapPanel >
                <Label Content="最小值" />
                <Slider x:Name="sliderMin" Minimum="-200" Maximum="100" Width="300" ValueChanged="sliderMin_ValueChanged" SmallChange="10"  />
                <Label Content="{Binding ElementName=sliderMin, Path=Value}" />
            </WrapPanel>
            <WrapPanel >
                <Label Content="最大值" />
                <Slider x:Name="sliderMax" Minimum="200" Maximum="800" Width="300" ValueChanged="sliderMax_ValueChanged" SmallChange="10" />
                <Label Content="{Binding ElementName=sliderMax, Path=Value}" />
            </WrapPanel>
        </StackPanel>
    </Grid>
</Window>

C#代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;
namespace WpfApp1
{
    /// <summary>
    /// WindowProcess.xaml 的交互逻辑
    /// </summary>
    public partial class WindowProcess : Window
    {
        public WindowProcess()
        {
            InitializeComponent();
            //设置Current的值
            myValiDP1.CurrentValue = 100;
        }
        private void sliderMin_ValueChanged(object sender, RoutedPropertyChangedEventArgs<double> e)
        {
            //设置Current的值
            myValiDP1.CurrentValue = (int)sliderMin.Value;
        }
        private void sliderMax_ValueChanged(object sender, RoutedPropertyChangedEventArgs<double> e)
        {
            //设置Current的值
            myValiDP1.CurrentValue = (int)sliderMax.Value;
        }
    }
}

示例效果如下图。

在上面的例子中，一共有三个依赖属性相互作用——CurrentValue、MinValue和MaxValue，这些属性相互作 用，但它们的规则是MinValue≤CurrentValue≤MaxValue。根据这个规则，当其中一个依赖属性变化时，另外两个依赖 属性必须进行适当的调整，这里我们要用到的就是CoerceValue这个回调委托，那么实现起来也非常的简单，注册MaxValue的时候加入 CoerceValueCallback，在CoerceMaxValue函数中做处理：如果Maximum的值小于MinValue，则使 MaxValue值等于MinValue；同理在CurrentValue中也加入了CoerceValueCallback进行相应的强制 处理。然后在MinValue的ChangedValueCallback被调用的时候，调用CurrentValue和MaxValue的 CoerceValue回调委托，这样就可以达到相互作用的依赖属性一变应万变的”千机变“。

换句话说，当相互作用的几个依赖属性其中一个发生变化时，在它的PropertyChangeCallback中调用受它影响的依赖属性的CoerceValue，这样才能保证相互作用关系的正确性。 前面也提高ValidateValue主要是验证该数据的有效性，最设置了值以后都会调用它来进行验证，如果验证不成功，则抛出异常。

（本文转载自：http://www.cnblogs.com/chillsrc/）