Inside dependency property

依赖属性的定义，分为3步（以PresentationFramework中的System.Windows.Controls.Button为例）

1.  声明依赖属性

　　public static readonly DependencyProperty IsDefaultProperty

2. 调用DependencyProperty.Register创建依赖属性实例

　　IsDefaultProperty = DependencyProperty.Register("IsDefault", typeof(bool), typeof(Button), new FrameworkPropertyMetadata(BooleanBoxes.FalseBox, new PropertyChangedCallback(Button.OnIsDefaultChanged)));

此例中，第一个参数是依赖属性名称，第一个参数是依赖属性的值类型，第三个参数为依赖属性所在的类型，第四个参数是可选的为依赖属性提供元数据。

3. 为依赖属性添加传统的CLR属性封装

　　

    public bool IsDefault
    {
        get
        {
            return (bool) base.GetValue(IsDefaultProperty);
        }
        set
        {
            base.SetValue(IsDefaultProperty, BooleanBoxes.Box(value));
        }
    }

为什么

1. 声明依赖属性时为什么是public、static和readonly

按照惯例所有的依赖属性通常都是public, static并且以Property结尾。因为是public的所以需要使用readonly来防止第三方代码对依赖属性的意外修改。

2. DependencyProperty.Register的第一和第二个参数

第一个参数和第二个参数用来惟一确定一个依赖属性，换句话说WPF为每个依赖属性创建一个实例，该实例由依赖属性名称和其所在类型所决定，并由DependencyProperty.Register返回，可以从DependencyProperty的反编译代码中得到证实

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 }));
        }
    }

你可以在上面的代码中看到PropertyFromName（第二行红色），PropertyFromName是一个私有的静态哈希表，用来存放使用DependencyProperty.Register注册到WPF对象层次结构中的所有（包括贡献依赖属性的所有类）依赖属性实例的静态引用。从上面代码可以看出，当name（第一个参数，依赖属性名称）和ownerType（第二参数，贡献依赖属性的类）确定时，惟一对应PropertyFromName中的一个值（即为依赖对象实例静态引用）。

3. DependencyProperty.Register的第四个参数

第四个参数包含描述依赖属性的元数据，定制WPF处理依赖属性的行为，提供属性值改变时的回调函数和属性值的有效性验证等。

4. 传统.Net属性封装

这一步并不是必须的， 应为GetValue和SetValue（后面将说明）是publish的，所以在代码中可以直接调用这两个函数（必须继承DependencyObject）。但是提供该封装可以在编程时方便使用，如果要用XAML属性中使用该依赖属性就一定要提供该封装。

它们是如何工作的

1. DependencyProperty.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

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 }));
        }
    }
    if (defaultMetadata == null)
    {
        defaultMetadata = AutoGeneratePropertyMetadata(propertyType, validateValueCallback, name, ownerType);
    }
    else
    {
        if (!defaultMetadata.DefaultValueWasSet())
        {
            defaultMetadata.DefaultValue = AutoGenerateDefaultValue(propertyType);
        }
        ValidateMetadataDefaultValue(defaultMetadata, propertyType, name, validateValueCallback);
    }
    DependencyProperty dp = new DependencyProperty(name, propertyType, ownerType, defaultMetadata, validateValueCallback);
    defaultMetadata.Seal(dp, null);
    if (defaultMetadata.IsInherited)
    {
        dp._packedData |= Flags.IsPotentiallyInherited;
    }
    if (defaultMetadata.UsingDefaultValueFactory)
    {
        dp._packedData |= Flags.IsPotentiallyUsingDefaultValueFactory;
    }
    lock (Synchronized)
    {
        PropertyFromName[key] = dp;
    }
    if (TraceDependencyProperty.IsEnabled)
    {
        TraceDependencyProperty.TraceActivityItem(TraceDependencyProperty.Register, dp, dp.OwnerType);
    }
    return dp;
}

在RegisterCommon函数中第一行红色代码使用接收的依赖属性名称和所在类的名称创建了FromNameKey实例key；第二行红色代码检测key是否在PropertyFromName中，如果存在则抛异常（WPF只为类的每个依赖属性创建一个实例）；如果key不存在，也即类的某个惟一命名依赖属性不存在，则第三行红色代码调用DependencyProperty的private构造函数为该依赖属性创建实例；最后第四行红色代码把创建的依赖属性加入到PropertyFromName中。

2. DependencyProperty的私有构造函数

private DependencyProperty(string name, Type propertyType, Type ownerType, PropertyMetadata defaultMetadata, ValidateValueCallback validateValueCallback)
{
    Flags uniqueGlobalIndex;
    this._metadataMap = new InsertionSortMap();
    this._name = name;
    this._propertyType = propertyType;
    this._ownerType = ownerType;
    this._defaultMetadata = defaultMetadata;
    this._validateValueCallback = validateValueCallback;
    lock (Synchronized)
    {
        uniqueGlobalIndex = (Flags) GetUniqueGlobalIndex(ownerType, name);
        RegisteredPropertyList.Add(this);
    }
    if (propertyType.IsValueType)
    {
        uniqueGlobalIndex |= Flags.IsValueType;
    }
    if (propertyType == typeof(object))
    {
        uniqueGlobalIndex |= Flags.IsObjectType;
    }
    if (typeof(Freezable).IsAssignableFrom(propertyType))
    {
        uniqueGlobalIndex |= Flags.IsFreezableType;
    }
    if (propertyType == typeof(string))
    {
        uniqueGlobalIndex |= Flags.IsStringType;
    }
    this._packedData = uniqueGlobalIndex;
}

internal static int GetUniqueGlobalIndex(Type ownerType, string name)
{
    if (GlobalIndexCount < 0xffff)
    {
        return GlobalIndexCount++;
    }
    if (ownerType != null)
    {
        throw new InvalidOperationException(SR.Get("TooManyDependencyProperties", new object[] { ownerType.Name + "." + name }));
    }
    throw new InvalidOperationException(SR.Get("TooManyDependencyProperties", new object[] { "ConstantProperty" }));
}

从上面两段代码可以看出WPF为每个DependencyProperty实例创建了一个自增的索引uniqueGlobalIndex，并把该索引和DependencyProperty值类型（使用Flags枚举来表示）一起封装在_packedData中。从上面代码可以看出WPF至多支持同时创建0xffff(65535)个依赖属性。

3.  DependencyObject

使用依赖属性的所有类都必须继承DependencyObject，该类定义了操作依赖属性的相关方法，如下面介绍的SetValue和GetValue。DependencyObject具有一个私有的实例字段_effectiveValues用于存放依赖属性值和对应的依赖属性索引，换句话说继承自DependencyObject的类的每个实例均维护着用于存放该类定义的通过DependencyProperty.Register注册到WPF基础结构的依赖属性值（注意不是依赖属性实例）的数组。该数组的元素为EffectiveValueEntry类型，包含依赖属性实例索引（上面已经说明所有的类实例共享一个依赖属性实例）和依赖属性值（因类的实例的不同而不同）的对应关系。

aaarticlea/png;base64,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" alt="" />

依赖属性和依赖属性值的存储方案如下图：

aaarticlea/png;base64,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" alt="" />

3.1 SetValue

这是由DependencyObject提供的实例方法，用于设置DependencyProperty在类实例的值。调用SetValue时WPF创建EffectiveValueEntry实例用于存放依赖属性值和依赖属性实例索引的对象关系并插入到_effectiveValues数组中，依赖属性值在_effectiveValues中是按照依赖属性的索引从小到大有序存放的（详细实现可查看DependencyObject类成员函数InsertEntry的反编译代码）。

3.2 GetValue

这是由DependencyObject提供的实例方法，用于获取DependencyProperty在类实例的值。调用GetValue时WPF根据提供的依赖属性实例索引在_effectiveValues中搜索对应的属性值，由于_effectiveValues是有序的，所以实现中使用二分法来提高搜索性能（详细实现可查看DependencyObject类成员函数LookupEntry的反编译代码）。

总结

将依赖属性从依赖属性的值上剥离，主要是为了性能上的考虑。一个WPF类可能使用几十上百个字段，并且在一次窗体呈现中该类可能被实例化不只一次（如一个Button包含有96个字段，且在一个窗体中可能包含很多个Button），如果使用传统CLR属性方式，则将为附加到字段实例上的本地化数据分配存储空间。假设控件每个字段的本地化数据大小平均为m，包含的字段数为f，控件被创建的次数为n，则需要的总空间为M = m * f * n，消耗的空间是直线上升的。使用依赖属性，由于依赖属性实例引用是静态的，且WPF只为依赖属性创建一个实例，所以实际所需要的空间只剩下为每个控件实例保存依赖属性值的空间（即M=0）。

引用

《Windows.Presentation.Foundation.Unleashed》

http://www.abhisheksur.com/2011/07/internals-of-dependency-property-in-wpf.html?_sm_au_=iVVjWL1ZNjHpkVpM