WPF --依赖属性详解

依赖项属性可以称得上是WPF中比较难理解的概念，为了搞清楚这个概念，我都把.NET类库进行了反编译，但是，其结果我也是想到了的，微软不是傻子，.NET那么庞大，就算能被你反编译了，你也看不懂它的代码。

所以说，经过我一番研究，虽然没有把.NET的每一行代码都弄明白，不过，黄天终不负有心人，依赖项属性的使用方法与基本原理，我可以说已经弄明白了，恰巧，前两天在网上看到一篇讨论依赖项属性的文章，写得还不错，作者估计也是一位高人，再加上我个人的研究，从实际应用的角度来说，我现在已经掌握了依赖项属性的使用方法了，不妨告诉你，其实很简单，可以这么说，整个WPF都很简单，和许多刚接触WPF的朋友一样，一开始我也是认为它很复杂很难懂。

 

为什么这样说呢？大家都知道，微软官方总是为它自己推出的产品配备很完备的文档，对，就是那个很出名的MSDN。

 

许多初学WPF的朋友，一定也会像我一样，去查阅MSDN，通过上面的介绍来入门，可杯具正是发生在这个时候，WPF的难懂难学就是被微软自己的文档所误导，先别说翻译的质量不好，就算你看英文原文，你大概也会看得头晕。

 

真的，那些概念模型实在太抽象了，从刚接触WPF到现在，我都不知道把MSDN翻了多少遍了，甚至查到微软都把我的IP列入黑名单了，呵呵，而且，  我也下载了英文原版的SDK来对比研究。

说实话，对.NET类库进行反编译的学习方法效率很低，表面上说可以更深入地了解.NET框架，但是，我不推荐这样学习，真的，得不尝失，花费很多精力和时间，而收获甚少；还有就是，反编译.NET类库是属于侵权，哈，幸好我们都生活在没有法律的中国，不然，一定会被微软告上法庭。

 

这次反编译，完全出于无奈，因为有些概念的确难以理解。

在研究的同时，我也进行了反思，最后感悟是——还是那句老话：理论的东西，哪怕你把它背下来了，你永远也不懂。

 

对我们来说，学编程为了什么？不就是为了应用吗？也就是说用于实战，既然这样，其实我们不必把理论的东西钻得太死，不然，钻牛角尖容易走火入魔。

 

依赖项属性的重点在于“依赖”二字，既然是依赖了，也就是说：依赖项属性的值的改变过程一定与其它对相关，不A依赖B就B依赖A，或者相互依赖。

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

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

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

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

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

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

 

为了进行比较，我们先来说说传统面向对象编程中对类属性的定义，请看下面一个简单的类，它只有一个公共属性。

 

 public class Student
    {
        public string Name { set; get; }
    }

这时候，我们布局一下WPF主窗口，如下所示XAML：

<Window x:Class="WpfApplication1.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Window1" Height="180" Width="300" Loaded="Window_Loaded">
    <Grid>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="auto"/>
            <ColumnDefinition Width="*"/>
        </Grid.ColumnDefinitions>
        <Grid.RowDefinitions>
            <RowDefinition Height="auto"/>
            <RowDefinition Height="auto"/>
            <RowDefinition Height="auto"/>
        </Grid.RowDefinitions>
        <TextBlock Grid.Column="0" Grid.Row="0" Text="姓名："/>
        <TextBox x:Name="txtName" Grid.Column="1" Grid.Row="0" Margin="0,5,20,5"/>
        <TextBlock Grid.Column="0" Grid.Row="1" Text="改变值："/>
        <TextBox x:Name="txtCh" Grid.Column="1" Grid.Row="1" Margin="0,5,20,5"/>
        <Button x:Name="btn" Grid.Row="2" Grid.ColumnSpan="2" Margin="70,5,70,5" Click="btn_Click">显示属性值</Button>
    </Grid>
</Window>

在窗口的加载完成事件中，我们作两个绑定：

（1）把Student的实例的Name属性与textBox的text属性绑定；

（2）同时与第二个文本框也绑定。

 

运行程序，在第一个文本框中输入内容，再点一下第二个文本框，或点一下按钮，虽然第二个文本框也会随之改变，但并不是同步改变，而是当焦点离开第一个文本框后才发生改变，这就不属于同步了。

完整代码如下：

   Student myStu = new Student { Name = "小明" };
        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            //绑定数据
            BindingOperations.SetBinding(txtName, TextBox.TextProperty,
                new Binding { Source = myStu, Path = new PropertyPath("Name"), Mode = BindingMode.TwoWay });
            BindingOperations.SetBinding(txtCh, TextBox.TextProperty,
                new Binding { Source = myStu, Path = new PropertyPath("Name"), Mode = BindingMode.TwoWay });
        }
 
        private void btn_Click(object sender, RoutedEventArgs e)
        {
            MessageBox.Show("当前实例的属性值：Name = " + myStu.Name);
        }

在上一文中，我们用传统面向对象的方法来定义了一个类，而我们同时把该类的实例绑定到两个文本框，第一个文本框用于输入值，第二个文本框用于根据第一个文本框中的输入来取得属性值。

 

在上例中我们已经明了，虽然能做到同步更新，但这同步更新并不是实时的。而是在控件失去焦点或点击按钮之后才发生，因为那个时候是重新进行了绑定，所以，一般的属性声明并没有实现实时更新。

 

下面，我们把Student类进行改动，把Name属性改为依赖项属性。

 public class Student:DependencyObject
    {
        //注册依赖项属性
        public static readonly DependencyProperty NameProperty =
            DependencyProperty.Register("Name",
            typeof(string),
            typeof(Student),
            new PropertyMetadata(string.Empty));
    }

从定义中我们看到依赖项属性的定义规则：

1、必须是公开的静态字段，public static；

2、因为是静态成员而且是公开的，有可能被恶意或无意修改，为了保险，加上一个readonly关键字；

3、调用静态方法Register返回一个DependencyProperty实例。

 

从上述内容中，可以进一步分析，依赖项属性是通过注册到WPF属性系统来定义的， Register方法有多种重载，示例中用到的是以下签名：

  public static DependencyProperty Register(string name, Type propertyType, Type ownerType, PropertyMetadata typeMetadata);
 

       //
        // 摘要:
        //     使用指定的属性名称、属性类型、所有者类型和属性元数据注册依赖项属性。
        //
        // 参数:
        //   name:
        //     要注册的依赖项对象的名称。
        //
        //   propertyType:
        //     属性的类型。
        //
        //   ownerType:
        //     正注册依赖项对象的所有者类型。
        //
        //   typeMetadata:
        //     依赖项对象的属性元数据。
        //
        // 返回结果:
        //     一个依赖项对象标识符，应使用它在您的类中设置 public static readonly 字段的值。然后，在以后使用该标识符引用依赖项对象，用于某些操作，例如以编程方式设置其值，或者获取元数据。

 

这里说一下ownerType参数，它只的是注册依赖项属性的类型，如本例中就是Student类。

typeMetadata是所谓的元数据，就是属性的默认，当然，它也有N个构造函数，可以同时传递事件委托来对属性的改性或类型转换时进行事件处理。

 

下面一点很重要，就是属性的命名格式，根据约定，必须为以下格式：

XXXProperty，你的属性名后面紧跟Property，记住！

我们把前面的示例改一下，作以下绑定

   //声明一个Student类
        Student myStu = new Student();
        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            myStu.SetValue(Student.NameProperty, "小张");
            //绑定到第一个文本框
            BindingOperations.SetBinding(myStu, Student.NameProperty,
                new Binding
                {
                    Source = txtName,
                    Path = new PropertyPath("Text")
                });
            //绑定第二个文本框
            BindingOperations.SetBinding(txtChanged, TextBox.TextProperty,
                new Binding
                {
                    Source = myStu,
                    Path = new PropertyPath(Student.NameProperty)
                });
        }

这时候你运行程序，当你在第一个文本框中输入内容时，第二个的文本框就会立即发生改变，这就说明，在双向绑定的模式下，属性的更新是实时的。

 

 

好，为了能像普通CLR属性一样使用，我们对Student类做一些封装。在封装之前，说一下是如何获取和设置属性的。

在WPF中，要使用依赖项属性，该类必须继承DependencyObject类，DependencyObject类有两个属性专门处理属性的值。

（1）GetValue用于获取值；

（2）SetValue用于设置值。

于是，我们对Student类作以下封装：

  public class Student:DependencyObject
    {
        //注册依赖项属性
        public static readonly DependencyProperty NameProperty =
            DependencyProperty.Register("Name",
            typeof(string),
            typeof(Student),
            new PropertyMetadata(string.Empty));
 
        public string Name
        {
            get
            {
                return (string)this.GetValue(NameProperty);
            }
            set
            {
                this.SetValue(NameProperty, value);
            }
        }
    }
 

虽然现在已经知道如何使用依赖项属性了，但是，依赖项属性是如何注册到WPF的属性系统中的，我们似乎一头雾水。

要把这一问题搞清楚，只有一种办法，那就是把.NET类库反编译，工具不用我说了，网上大把，呵，这可是侵权的，靠，没办法，谁叫微软不开源。

 

通过反编译得到Register方法的定义如下，其实每个重载都是调用了下面这个方法：

public static DependencyProperty Register(string name, Type propertyType, Type ownerType, PropertyMetadata typeMetadata, ValidateValueCallback validateValueCallback){    RegisterParameterValidation(name, propertyType, ownerType);    PropertyMetadata defaultMetadata = null;    if ((typeMetadata != null) && typeMetadata.DefaultValueWasSet())    {        defaultMetadata = new PropertyMetadata(typeMetadata.DefaultValue);    }    DependencyProperty property = RegisterCommon(name, propertyType, ownerType, defaultMetadata, validateValueCallback);    if (typeMetadata != null)    {        property.OverrideMetadata(ownerType, typeMetadata);    }    return property;}

其它的不用看，我们只找重点语句，上面代码片段中，加粗斜体部分为重点，也就是说，所以的依赖项属性的注册，都是调用了RegisterCommon方法的。

接着，我们来看看RegisterCommon方法是如何定义的。

这段代码有点长，我就不全部复制过来了，我把重要的语句拿过来。

private static DependencyProperty RegisterCommon(string name, Type propertyType, Type ownerType, PropertyMetadata defaultMetadata, ValidateValueCallback validateValueCallback){    FromNameKey key = new FromNameKey(name, ownerType);    lock (Synchronized)    {        if (PropertyFromName.Contains(key))        {            throw new ArgumentException(SR.Get("PropertyAlreadyRegistered", new object[] { name, ownerType.Name }));        }    }

       //省略代码.................

    return dp;}

大家注意加粗斜体字标注的地方，其中有一个if语句判断，是否在PropertyFromName中存在某个key，如果存在就抛出异常，那么这个PropertyFromName究竟是什么呢? 

好，带着疑问，继续跟踪代码，在DependencyProperty类中发现了它的定义：

private static Hashtable PropertyFromName；

这下就明白了，原来刚来所检查的key的容器就是一个哈希表，而且是全局的。

上面的代码告诉我们，哈希表的key就是一个FromNameKey ，

    FromNameKey key = new FromNameKey(name, ownerType);

那么，这个FromNameKey又是如何计算的呢？继续反编译，我找到了它的定义：

private class FromNameKey{
    // Fields    private int _hashCode;
    private string _name; 
   private Type _ownerType;
    // Methods
    public FromNameKey(string name, Type ownerType)
    {
        this._name = name;
        this._ownerType = ownerType;
        this._hashCode =
        this._name.GetHashCode() ^
              this._ownerType.GetHashCode();
   }    //省略代码...............}
希哈值的计算方法是：(类名 + 属性名).HashCode();
这样一来，就可以保证依赖项属性只能注册一次，因为哈希值是全局唯一的。
而且，我们知道DependencyProperty类有个GlobalIndex，这个索引就是依赖项属性在哈希表中的位置，当我们要获取属性的值或要设属性的值，
就从这个索引表里寻找。

上节中，我们分析了依赖项属性的注册和定义方法，并解释了依赖项属性的注册过程，但是，有一个疑问会困惑着我们，既然依赖项属被声明为静态只读字段，那为什么它的值可以被改变呢？难道你不觉得很奇怪吗？

微软的葫芦里到底卖的什么药呢？我们来看看。

前文中我们提到过，设置依赖项属性的值使用SetValue方法，那好，我们就从SetValue方法入手。

SetValue方法的定义如下：

public void SetValue(DependencyProperty dp, object value)
{
    base.VerifyAccess();
    PropertyMetadata metadata = this.SetupPropertyChange(dp);
    this.SetValueCommon(dp, value, metadata, false, OperationType.Unknown, false);
}

VerifyAccess方法是用于检查可访问性，这个不管它，重点是看SetValueCommon方法，它才是真正设置值的方法，好，继续跟入，看看SetValueCommon方法的定义：

private void SetValueCommon(DependencyProperty dp, object value, PropertyMetadata metadata, bool coerceWithDeferredReference, OperationType operationType, bool isInternal)
{
    if (this.IsSealed)
    {
        throw new InvalidOperationException(SR.Get("SetOnReadOnlyObjectNotAllowed", new object[] { this }));
    }
    Expression expr = null;
    DependencySource[] newSources = null;
    EntryIndex entryIndex = this.LookupEntry(dp.GlobalIndex);
    if (value == DependencyProperty.UnsetValue)
    {
        this.ClearValueCommon(entryIndex, dp, metadata);
    }
    else
    {
        EffectiveValueEntry entry;
        EffectiveValueEntry entry2;
        bool flag = false;
        bool flag2 = value == ExpressionInAlternativeStore;
        if (!flag2)
        {
            bool flag3 = isInternal ? dp.IsValidValueInternal(value) : dp.IsValidValue(value);
            if (!flag3 || dp.IsObjectType)
            {
                expr = value as Expression;
                if (expr != null)
                {
                    if (!expr.Attachable)
                    {
                        throw new ArgumentException(SR.Get("SharingNonSharableExpression"));
                    }
                    newSources = expr.GetSources();
                    ValidateSources(this, newSources, expr);
                }
                else
                {
                    flag = value is DeferredReference;
                    if (!flag && !flag3)
                    {
                        throw new ArgumentException(SR.Get("InvalidPropertyValue", new object[] { value, dp.Name }));
                    }
                }
            }
        }
        if (operationType == OperationType.ChangeMutableDefaultValue)
        {
            entry = new EffectiveValueEntry(dp, BaseValueSourceInternal.Default) {
                Value = value
            };
        }
        else
        {
            entry = this.GetValueEntry(entryIndex, dp, metadata, RequestFlags.RawEntry);
        }
        object localValue = entry.LocalValue;
        Expression expression2 = null;
        Expression expression3 = null;
        if (entry.HasExpressionMarker)
        {
            if (expr == null)
            {
                expression3 = _getExpressionCore(this, dp, metadata);
            }
            if (expression3 != null)
            {
                localValue = expression3;
                expression2 = expression3;
            }
            else
            {
                localValue = DependencyProperty.UnsetValue;
            }
        }
        else
        {
            expression2 = entry.IsExpression ? (localValue as Expression) : null;
        }
        bool flag5 = false;
        if ((expression2 != null) && (expr == null))
        {
            if (flag)
            {
                value = ((DeferredReference) value).GetValue(BaseValueSourceInternal.Local);
                flag = false;
            }
            flag5 = expression2.SetValue(this, dp, value);
            entryIndex = this.CheckEntryIndex(entryIndex, dp.GlobalIndex);
        }
        if (flag5)
        {
            if (entryIndex.Found)
            {
                entry2 = this._effectiveValues[entryIndex.Index];
            }
            else
            {
                entry2 = EffectiveValueEntry.CreateDefaultValueEntry(dp, metadata.GetDefaultValue(this, dp));
            }
        }
        else
        {
            entry2 = new EffectiveValueEntry(dp, BaseValueSourceInternal.Local);
            if ((expression2 != null) && (expression2 != expression3))
            {
                DependencySource[] sources = expression2.GetSources();
                UpdateSourceDependentLists(this, dp, sources, expression2, false);
                expression2.OnDetach(this, dp);
                entryIndex = this.CheckEntryIndex(entryIndex, dp.GlobalIndex);
            }
            if (expr == null)
            {
                entry2.IsDeferredReference = flag;
                entry2.Value = value;
                entry2.HasExpressionMarker = flag2;
            }
            else
            {
                this.SetEffectiveValue(entryIndex, dp, dp.GlobalIndex, metadata, expr, BaseValueSourceInternal.Local);
                object defaultValue = metadata.GetDefaultValue(this, dp);
                entryIndex = this.CheckEntryIndex(entryIndex, dp.GlobalIndex);
                this.SetExpressionValue(entryIndex, defaultValue, expr);
                UpdateSourceDependentLists(this, dp, newSources, expr, true);
                expr.MarkAttached();
                expr.OnAttach(this, dp);
                entryIndex = this.CheckEntryIndex(entryIndex, dp.GlobalIndex);
                entry2 = this.EvaluateExpression(entryIndex, dp, expr, metadata, entry, this._effectiveValues[entryIndex.Index]);
                entryIndex = this.CheckEntryIndex(entryIndex, dp.GlobalIndex);
            }
        }
        this.UpdateEffectiveValue(entryIndex, dp, metadata, entry, ref entry2, coerceWithDeferredReference, operationType);
    }
}

第一个引起我注意的是DependencySource类，它封装了依赖性对象和依赖性属性，并分别为两个只读属性。

还有一个比较核心的类就是EffectiveValueEntry.

internal EffectiveValueEntry(DependencyProperty dp, BaseValueSourceInternal valueSource)
{
    this._propertyIndex = (short) dp.GlobalIndex;
    this._value = DependencyProperty.UnsetValue;
    this._source = (FullValueSource) valueSource;
}

FullValueSource是一个枚举，如果我没猜错的话，它就是用来标识属性的来源，它有以下几个值：

[FriendAccessAllowed]
internal enum FullValueSource : short
{
    HasExpressionMarker = 0x100,
    IsAnimated = 0x20,
    IsCoerced = 0x40,
    IsDeferredReference = 0x80,
    IsExpression = 0x10,
    ModifiersMask = 0x70,
    ValueSourceMask = 15
}

1、通过XAML标记语言来改变属性值，如：

<TextBox x:Name="txt" Text="这是一个测试" />

这里就通过XAML标记为 Text属性赋了值。

 

2、受动画影响而改变的值。比如我画一个矩形，在动画面板中我让它演示长达6秒钟的动画，这期间，矩形的X坐标从20变为80，这个值就是通过动画来设置属性值，这个值是不会提交到属性更改，只是临时更改，动画停止后，属性值将会恢复为原来的值。

 

3、强制设置值。这个概念很奇怪，可以把它理解为对属性的输入值进行类型转换，我们知道，WPF里面提供了许多XXXXConvertor，毕竟我们在XAML标记中只能输入文本值，比如颜色，我们都会输入Red这样的值，其实在后台，运行库把字符串的值转换为画刷实例，再向属性赋值。

 

4、被改变后的值，从跟踪的结果看，依赖项属性的值都有N个版本，分别为不同的变量来保存，以便做验证和对比。

 

EffectiveValueEntry里面就是保存依赖项属性的全局索引和属性值，继续反编译，发现了一个InsertEntry方法，比较长，代码我不帖，只帖签名。

private void InsertEntry(EffectiveValueEntry entry, uint entryIndex)

两个参数都很好理解，第二个参数就是数组的索引，那么，是哪个数组的索引呢？接着反编译，看到DendencyObject类有一个内部字段，定义如下：

private EffectiveValueEntry[] _effectiveValues;

对，这下找到了，就是一个EffectiveValueEntry的数组，好了，不用往下跟了，到这里基本上可以看出依赖项属性是如何保存它的值了，原理如下：

 

每个DendencyObject类的实例都会创建一个专门的数组，数组中的每个元素分别标识着该类型的一个依赖项属性，例如我定义了一个类A，A里面定义了3个依赖项属性A.kk，A.cc，A.ff，这样当A类被分配到内存中实例化的时候，创建一个EffectvieValueEntry数组，而每个EffectiveValueEntry对应着一个属性，保存着该属性的不同版本的值，A类型有3个依赖项属性，所以对应的EffectiveEntry数组就有3个元素。

那么，CLR如何知道哪个EffectiveEntry对应着哪个依赖项属性呢？前面说过，每个依赖项属性都会以哈希值的键保存到一个全局哈希表中，所以，只要查找出对应键就可以唯一地标识依赖项属性了。

 

既然知道了如何设置值，那么，对于如何获取值就更好办了，过程刚好相反。

public object GetValue(DependencyProperty dp)
{
    base.VerifyAccess();
    if (dp == null)
    {
        throw new ArgumentNullException("dp");
    }
    return this.GetValueEntry(this.LookupEntry(dp.GlobalIndex), dp, null, RequestFlags.FullyResolved).Value;
}

看到最后一行，其实返回了一个EffectiveValueEntry类型的变量，再从中取出Value属性的值，这个值其实就是对应类型的依赖项属性的值。

 

那么，EffectiveValueEntry数组中的元素是在哪儿赋值的呢？我翻遍了整个DependencyObject类也没有找到赋值的语句，这时候我突然想起刚才的SetValue方法，注意到这几行：

 if (operationType == OperationType.ChangeMutableDefaultValue)
        {
            entry = new EffectiveValueEntry(dp, BaseValueSourceInternal.Default) {
                Value = value
            };
        }
        else
        {
            entry = this.GetValueEntry(entryIndex, dp, metadata, RequestFlags.RawEntry);
        }

如果要设置的值的等于默认，还记得我们调用Register注册依赖项属性时，最后一个参数，它是一个PropertyMetaData类型，它封装了依赖项属性的默认值，也就是元数据，元数据说白了就初始值，“元”在汉语中有“首”，“开始”，“第一”等意思，如“XX元年”、“公元2002年”等。

所以，上面的代码是：如果设置的值与元数据一致，就不用赋值了，直接从元数据里面，这样可以免去了在赋值过程发生的“拆箱”和“装箱”行为消耗性能；

如果设置的值不是元数据（默认值），那么就动态创建一个EffectvieValueEntry类的实例，并保存当前值。

因此，EffectiveValueEntry数组是动态分配内存的，就是说，如果你不对属性进行赋值，那就不创建EffectiveValueEntry实例，因为依赖项属性在静态注册时就带了默认值。

 

因此，对比传统的面向对象属性系统，WPF的依赖项属性有以下优点：

1、类被实例化时不对属性进行初始化，大大节省了内存空间。

在传统的属性系统中，比如一个类B有1000个属性，每个属性都是int类型，而整型每个实例占用4个字节的内存，初台化1000个属性，就等于分配1000个整型的有效内存，也就是说，B类实例化后将占用 1000 * 4 = 4000字节的内存，如果我的类有100000个字符串的属性，而这些属性都是保存中文字符，你可想象有多么恐怖！

WPF的依赖项属性系统对每个类初始化时并不初始化属性，而是等到运行时需要设置才进行分配，这样一来，就大大节省了内存占用率。

 

2、更高的灵活性。由于依赖项属性的声明是静态的，也就是说，它存在于整个应用程序生命命周期内，它并不属于特定类，如Content属性，它可以属于Canvas类，也可以属于DockPanel类，只要在全局哈希表中键值不重复即可。

还有就是附加属性，附加属性其实也是依赖项属性，比如一个会计的职责是处理帐目和财务相关的事情，有时候质量控制部门比较忙，财务部门的职责就多了一个检测的任务，但这个职责并不是财务人员所必须的，只是在需要时才存在。

附加属性就是这样，可以把其它类的属性附加到当前类的属性列表，而这些属性并不是必须的，需要时就存在，不需要时就不存在，如DockPanel类的Dock就是附加在其子元素中，因为DockPanel可能放N个元素，你无法用一个值来固定它们的位置，可能一些元素Top，或者有些元素Left，这样一来，只能把Dock属性附加在它们身上，按具体需要来设置。

 

3、继承性。XAML中元素的属性值可以从其容器标记或父节点继承而来的属值。如路由事件的泡冒行为就是一个典型。DockPanel里面放置了4个按钮，我只需在DockPanel的XAML声明中加入Button.Click="Button_Click"，这样，子元节点在的所有按钮都会捕捉该事件，并调用同一个事件处理过程，这在传统的WinForm中是做不到的。

 

4、本地值。动画和3D变换等会改变对象的属性，但是，这些改变是临时，动画停止或删除后，该改变就不存在了。

 

5、数据绑定。依赖项自身具备实时更新功能，不需要我们手动去编写代码实现；WPF的数据绑定不仅仅在数据源，资源、样式、其它元素的属性值都可以实时更新。

 

6、资源。包括动态资源和静态资源的引用。这个我不多说了，请自行参考MSDN，上面都详细介绍了。

 

……

 

但是，依赖项属性并不是没有缺点的，它的缺点正是来自于它的优点。

由于依赖项属性是静态只读字段，所以应用程序启动时就必须创建所有的依赖项属性（注意，是创建用DependencyProperty.Register方法注册的DependencyProperty，不包括属性值），这就需要时间了，这就是为什么WPF程序启动速度慢的原因，它是用“时间”来换取“空间”，据说，微软一直在改善这问题，到了.NET3.5 SP1的时候，就有了明显的改进。