WPF学习笔记07-简析依赖属性

接下来我们对依赖属性进行一个简单的剖析,从以下几个方面入手吧。

1 - 为什么是public static

首先说下为什么是public

答:WPF有一种特殊属性,叫附加属性,需要直接访问xxxxProperty的方法才能实现,所以xxxxProperty是public 的。

其次为什么是静态static

答:和依赖属性的实现有关,也就是说,一个类,不管同一个依赖属性有多少个实例,均对应同一个DependencyProperty 。比如你创建100个Control ,每个Control 都有一个FontSize属性,但这100个FontSize均对应同一个FontSizeProperty实例

2 - DependencyProperty具体什么时候用?

比如你创建用户控件,然后呢,你需要传递到其中一些值,你怎么去处理,按照传统的方式你阔以去试试看看能否完成!所以这时候就提现出来了依赖属性的重要性

平常使用WPF已经封装好的那些的话更多时候是你拿来直接用的。

3 - DependencyProperty实现原理是什么?

实现原理的话要是解释的话很复杂。不如直接贴上源代码,自己分析去吧,哈哈

// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Threading;
using System.Globalization;
using System.ComponentModel;
using System.Windows.Markup;// For ValueSerializerAttribute
using System.Windows.Threading; // For DispatcherObject
using MS.Utility;
using MS.Internal.WindowsBase;
using System.Reflection; // for IsInstanceOfType
using MS.Internal;

pragma warning disable 1634, 1691 // suppressing PreSharp warnings

namespace System.Windows
{
/// <summary>
/// An attached dependency-based property
/// </summary>
[TypeConverter("System.Windows.Markup.DependencyPropertyConverter, PresentationFramework, Version=" + BuildInfo.WCP_VERSION + ", Culture=neutral, PublicKeyToken=" + BuildInfo.WCP_PUBLIC_KEY_TOKEN + ", Custom=null")]
[ValueSerializer(typeof(DependencyPropertyValueSerializer))]
public sealed class DependencyProperty
{
/// <summary>
/// Register a Dependency Property
/// </summary>
/// <param name="name">Name of property</param>
/// <param name="propertyType">Type of the property</param>
/// <param name="ownerType">Type that is registering the property</param>
/// <returns>Dependency Property</returns>
public static DependencyProperty Register(string name, Type propertyType, Type ownerType)
{
// Forwarding
return Register(name, propertyType, ownerType, null, null);
}

    /// &lt;summary&gt;
    ///     Register a Dependency Property
    /// &lt;/summary&gt;
    /// &lt;param name="name"&gt;Name of property&lt;/param&gt;
    /// &lt;param name="propertyType"&gt;Type of the property&lt;/param&gt;
    /// &lt;param name="ownerType"&gt;Type that is registering the property&lt;/param&gt;
    /// &lt;param name="typeMetadata"&gt;Metadata to use if current type doesn't specify type-specific metadata&lt;/param&gt;
    /// &lt;returns&gt;Dependency Property&lt;/returns&gt;
    public static DependencyProperty Register(string name, Type propertyType, Type ownerType, PropertyMetadata typeMetadata)
    {
        // Forwarding
        return Register(name, propertyType, ownerType, typeMetadata, null);
    }

    /// &lt;summary&gt;
    ///     Register a Dependency Property
    /// &lt;/summary&gt;
    /// &lt;param name="name"&gt;Name of property&lt;/param&gt;
    /// &lt;param name="propertyType"&gt;Type of the property&lt;/param&gt;
    /// &lt;param name="ownerType"&gt;Type that is registering the property&lt;/param&gt;
    /// &lt;param name="typeMetadata"&gt;Metadata to use if current type doesn't specify type-specific metadata&lt;/param&gt;
    /// &lt;param name="validateValueCallback"&gt;Provides additional value validation outside automatic type validation&lt;/param&gt;
    /// &lt;returns&gt;Dependency Property&lt;/returns&gt;
    public static DependencyProperty Register(string name, Type propertyType, Type ownerType, PropertyMetadata typeMetadata, ValidateValueCallback validateValueCallback)
    {
        RegisterParameterValidation(name, propertyType, ownerType);

        // Register an attached property
        PropertyMetadata defaultMetadata = null;
        if (typeMetadata != null &amp;&amp; typeMetadata.DefaultValueWasSet())
        {
            defaultMetadata = new PropertyMetadata(typeMetadata.DefaultValue);
        }

        DependencyProperty property = RegisterCommon(name, propertyType, ownerType, defaultMetadata, validateValueCallback);

        if (typeMetadata != null)
        {
            // Apply type-specific metadata to owner type only
            property.OverrideMetadata(ownerType, typeMetadata);
        }

        return property;
    }

    /// &lt;summary&gt;
    ///  Simple registration, metadata, validation, and a read-only property
    /// key.  Calling this version restricts the property such that it can
    /// only be set via the corresponding overload of DependencyObject.SetValue.
    /// &lt;/summary&gt;
    public static DependencyPropertyKey RegisterReadOnly(
        string name,
        Type propertyType,
        Type ownerType,
        PropertyMetadata typeMetadata )
    {
        return RegisterReadOnly( name, propertyType, ownerType, typeMetadata, null );
    }

    /// &lt;summary&gt;
    ///  Simple registration, metadata, validation, and a read-only property
    /// key.  Calling this version restricts the property such that it can
    /// only be set via the corresponding overload of DependencyObject.SetValue.
    /// &lt;/summary&gt;
    public static DependencyPropertyKey RegisterReadOnly(
        string name,
        Type propertyType,
        Type ownerType,
        PropertyMetadata typeMetadata,
        ValidateValueCallback validateValueCallback )
    {
        RegisterParameterValidation(name, propertyType, ownerType);

        PropertyMetadata defaultMetadata = null;

        if (typeMetadata != null &amp;&amp; typeMetadata.DefaultValueWasSet())
        {
            defaultMetadata = new PropertyMetadata(typeMetadata.DefaultValue);
        }
        else
        {
            defaultMetadata = AutoGeneratePropertyMetadata(propertyType,validateValueCallback,name,ownerType);
        }

        //  We create a DependencyPropertyKey at this point with a null property
        // and set that in the _readOnlyKey field.  This is so the property is
        // marked as requiring a key immediately.  If something fails in the
        // initialization path, the property is still marked as needing a key.
        //  This is better than the alternative of creating and setting the key
        // later, because if that code fails the read-only property would not
        // be marked read-only.  The intent of this mildly convoluted code
        // is so we fail securely.
        DependencyPropertyKey authorizationKey = new DependencyPropertyKey(null); // No property yet, use null as placeholder.

        DependencyProperty property = RegisterCommon(name, propertyType, ownerType, defaultMetadata, validateValueCallback);

        property._readOnlyKey = authorizationKey;

        authorizationKey.SetDependencyProperty(property);

        if (typeMetadata == null )
        {
            // No metadata specified, generate one so we can specify the authorized key.
            typeMetadata = AutoGeneratePropertyMetadata(propertyType,validateValueCallback,name,ownerType);
        }

        // Authorize registering type for read-only access, create key.
        #pragma warning suppress 6506 // typeMetadata is never null, since we generate default metadata if none is provided.

        // Apply type-specific metadata to owner type only
        property.OverrideMetadata(ownerType, typeMetadata, authorizationKey);

        return authorizationKey;
    }

    /// &lt;summary&gt;
    ///  Simple registration, metadata, validation, and a read-only property
    /// key.  Calling this version restricts the property such that it can
    /// only be set via the corresponding overload of DependencyObject.SetValue.
    /// &lt;/summary&gt;
    public static DependencyPropertyKey RegisterAttachedReadOnly(string name, Type propertyType, Type ownerType, PropertyMetadata defaultMetadata)
    {
        return RegisterAttachedReadOnly( name, propertyType, ownerType, defaultMetadata, null );
    }

    /// &lt;summary&gt;
    ///  Simple registration, metadata, validation, and a read-only property
    /// key.  Calling this version restricts the property such that it can
    /// only be set via the corresponding overload of DependencyObject.SetValue.
    /// &lt;/summary&gt;
    public static DependencyPropertyKey RegisterAttachedReadOnly(string name, Type propertyType, Type ownerType, PropertyMetadata defaultMetadata, ValidateValueCallback validateValueCallback)
    {
        RegisterParameterValidation(name, propertyType, ownerType);

        // Establish default metadata for all types, if none is provided
        if (defaultMetadata == null)
        {
            defaultMetadata = AutoGeneratePropertyMetadata( propertyType, validateValueCallback, name, ownerType );
        }

        //  We create a DependencyPropertyKey at this point with a null property
        // and set that in the _readOnlyKey field.  This is so the property is
        // marked as requiring a key immediately.  If something fails in the
        // initialization path, the property is still marked as needing a key.
        //  This is better than the alternative of creating and setting the key
        // later, because if that code fails the read-only property would not
        // be marked read-only.  The intent of this mildly convoluted code
        // is so we fail securely.
        DependencyPropertyKey authorizedKey = new DependencyPropertyKey(null);

        DependencyProperty property = RegisterCommon( name, propertyType, ownerType, defaultMetadata, validateValueCallback);

        property._readOnlyKey = authorizedKey;

        authorizedKey.SetDependencyProperty(property);

        return authorizedKey;
    }

    /// &lt;summary&gt;
    ///     Register an attached Dependency Property
    /// &lt;/summary&gt;
    /// &lt;param name="name"&gt;Name of property&lt;/param&gt;
    /// &lt;param name="propertyType"&gt;Type of the property&lt;/param&gt;
    /// &lt;param name="ownerType"&gt;Type that is registering the property&lt;/param&gt;
    /// &lt;returns&gt;Dependency Property&lt;/returns&gt;
    public static DependencyProperty RegisterAttached(string name, Type propertyType, Type ownerType)
    {
        // Forwarding
        return RegisterAttached(name, propertyType, ownerType, null, null );
    }

    /// &lt;summary&gt;
    ///     Register an attached Dependency Property
    /// &lt;/summary&gt;
    /// &lt;param name="name"&gt;Name of property&lt;/param&gt;
    /// &lt;param name="propertyType"&gt;Type of the property&lt;/param&gt;
    /// &lt;param name="ownerType"&gt;Type that is registering the property&lt;/param&gt;
    /// &lt;param name="defaultMetadata"&gt;Metadata to use if current type doesn't specify type-specific metadata&lt;/param&gt;
    /// &lt;returns&gt;Dependency Property&lt;/returns&gt;
    public static DependencyProperty RegisterAttached(string name, Type propertyType, Type ownerType, PropertyMetadata defaultMetadata)
    {
        // Forwarding
        return RegisterAttached(name, propertyType, ownerType, defaultMetadata, null );
    }

    /// &lt;summary&gt;
    ///     Register an attached Dependency Property
    /// &lt;/summary&gt;
    /// &lt;param name="name"&gt;Name of property&lt;/param&gt;
    /// &lt;param name="propertyType"&gt;Type of the property&lt;/param&gt;
    /// &lt;param name="ownerType"&gt;Type that is registering the property&lt;/param&gt;
    /// &lt;param name="defaultMetadata"&gt;Metadata to use if current type doesn't specify type-specific metadata&lt;/param&gt;
    /// &lt;param name="validateValueCallback"&gt;Provides additional value validation outside automatic type validation&lt;/param&gt;
    /// &lt;returns&gt;Dependency Property&lt;/returns&gt;
    public static DependencyProperty RegisterAttached(string name, Type propertyType, Type ownerType, PropertyMetadata defaultMetadata, ValidateValueCallback validateValueCallback)
    {
        RegisterParameterValidation(name, propertyType, ownerType);

        return RegisterCommon( name, propertyType, ownerType, defaultMetadata, validateValueCallback );
    }

    private static void RegisterParameterValidation(string name, Type propertyType, Type ownerType)
    {
        if (name == null)
        {
            throw new ArgumentNullException("name");
        }

        if (name.Length == 0)
        {
            throw new ArgumentException(SR.StringEmpty, "name");
        }

        if (ownerType == null)
        {
            throw new ArgumentNullException("ownerType");
        }

        if (propertyType == null)
        {
            throw new ArgumentNullException("propertyType");
        }
    }

    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.Format(SR.PropertyAlreadyRegistered, name, ownerType.Name));
            }
        }

        // Establish default metadata for all types, if none is provided
        if (defaultMetadata == null)
        {
            defaultMetadata = AutoGeneratePropertyMetadata( propertyType, validateValueCallback, name, ownerType );
        }
        else // Metadata object is provided.
        {
            // If the defaultValue wasn't specified auto generate one
            if (!defaultMetadata.DefaultValueWasSet())
            {
                defaultMetadata.DefaultValue = AutoGenerateDefaultValue(propertyType);
            }

            ValidateMetadataDefaultValue( defaultMetadata, propertyType, name, validateValueCallback );
        }

        // Create property
        DependencyProperty dp = new DependencyProperty(name, propertyType, ownerType, defaultMetadata, validateValueCallback);

        // Seal (null means being used for default metadata, calls OnApply)
        defaultMetadata.Seal(dp, null);

        if (defaultMetadata.IsInherited)
        {
            dp._packedData |= Flags.IsPotentiallyInherited;
        }

        if (defaultMetadata.UsingDefaultValueFactory)
        {
            dp._packedData |= Flags.IsPotentiallyUsingDefaultValueFactory;
        }


        // Map owner type to this property
        // Build key
        lock (Synchronized)
        {
            PropertyFromName[key] = dp;
        }


        if( TraceDependencyProperty.IsEnabled )
        {
            TraceDependencyProperty.TraceActivityItem(
                TraceDependencyProperty.Register,
                dp,
                dp.OwnerType );
        }


        return dp;
    }

    private static object AutoGenerateDefaultValue(
        Type propertyType)
    {
        // Default per-type metadata not provided, create
        object defaultValue = null;

        // Auto-assigned default value
        if (propertyType.IsValueType)
        {
            // Value-types have default-constructed type default values
            defaultValue = Activator.CreateInstance(propertyType);
        }

        return defaultValue;
    }

    private static PropertyMetadata AutoGeneratePropertyMetadata(
        Type propertyType,
        ValidateValueCallback validateValueCallback,
        string name,
        Type ownerType)
    {
        // Default per-type metadata not provided, create
        object defaultValue = AutoGenerateDefaultValue(propertyType);

        // If a validator is passed in, see if the default value makes sense.
        if ( validateValueCallback != null &amp;&amp;
            !validateValueCallback(defaultValue))
        {
            // Didn't work - require the caller to specify one.
            throw new ArgumentException(SR.Format(SR.DefaultValueAutoAssignFailed, name, ownerType.Name));
        }

        return new PropertyMetadata(defaultValue);
    }

    // Validate the default value in the given metadata
    private static void ValidateMetadataDefaultValue(
        PropertyMetadata defaultMetadata,
        Type propertyType,
        string propertyName,
        ValidateValueCallback validateValueCallback )
    {
        // If we are registered to use the DefaultValue factory we can
        // not validate the DefaultValue at registration time, so we
        // early exit.
        if (defaultMetadata.UsingDefaultValueFactory)
        {
            return;
        }

        ValidateDefaultValueCommon(defaultMetadata.DefaultValue, propertyType,
            propertyName, validateValueCallback, /*checkThreadAffinity = */ true);
    }

    // Validate the given default value, used by PropertyMetadata.GetDefaultValue()
    // when the DefaultValue factory is used.
    // These default values are allowed to have thread-affinity.
    internal void ValidateFactoryDefaultValue(object defaultValue)
    {
        ValidateDefaultValueCommon(defaultValue, PropertyType, Name, ValidateValueCallback, false);
    }

    private static void ValidateDefaultValueCommon(
        object defaultValue,
        Type propertyType,
        string propertyName,
        ValidateValueCallback validateValueCallback,
        bool checkThreadAffinity)
    {
        // Ensure default value is the correct type
        if (!IsValidType(defaultValue, propertyType))
        {
            throw new ArgumentException(SR.Format(SR.DefaultValuePropertyTypeMismatch, propertyName));
        }

        // An Expression used as default value won't behave as expected since
        //  it doesn't get evaluated.  We explicitly fail it here.
        if (defaultValue is Expression )
        {
            throw new ArgumentException(SR.DefaultValueMayNotBeExpression);
        }

        if (checkThreadAffinity)
        {
            // If the default value is a DispatcherObject with thread affinity
            // we cannot accept it as a default value. If it implements ISealable
            // we attempt to seal it; if not we throw  an exception. Types not
            // deriving from DispatcherObject are allowed - it is up to the user to
            // make any custom types free-threaded.

            DispatcherObject dispatcherObject = defaultValue as DispatcherObject;

            if (dispatcherObject != null &amp;&amp; dispatcherObject.Dispatcher != null)
            {
                // Try to make the DispatcherObject free-threaded if it's an
                // ISealable.

                ISealable valueAsISealable = dispatcherObject as ISealable;

                if (valueAsISealable != null &amp;&amp; valueAsISealable.CanSeal)
                {
                    Invariant.Assert (!valueAsISealable.IsSealed,
                           "A Sealed ISealable must not have dispatcher affinity");

                    valueAsISealable.Seal();

                    Invariant.Assert(dispatcherObject.Dispatcher == null,
                        "ISealable.Seal() failed after ISealable.CanSeal returned true");
                }
                else
                {
                    throw new ArgumentException(SR.Format(SR.DefaultValueMustBeFreeThreaded, propertyName));
                }
            }
        }


        // After checking for correct type, check default value against
        //  validator (when one is given)
        if ( validateValueCallback != null &amp;&amp;
            !validateValueCallback(defaultValue))
        {
            throw new ArgumentException(SR.Format(SR.DefaultValueInvalid, propertyName));
        }
    }


    /// &lt;summary&gt;
    ///     Parameter validation for OverrideMetadata, includes code to force
    /// all base classes of "forType" to register their metadata so we know
    /// what we are overriding.
    /// &lt;/summary&gt;
    private void SetupOverrideMetadata(
            Type forType,
            PropertyMetadata typeMetadata,
        out DependencyObjectType dType,
        out PropertyMetadata baseMetadata )
    {
        if (forType == null)
        {
            throw new ArgumentNullException("forType");
        }

        if (typeMetadata == null)
        {
            throw new ArgumentNullException("typeMetadata");
        }

        if (typeMetadata.Sealed)
        {
            throw new ArgumentException(SR.TypeMetadataAlreadyInUse);
        }

        if (!typeof(DependencyObject).IsAssignableFrom(forType))
        {
            throw new ArgumentException(SR.Format(SR.TypeMustBeDependencyObjectDerived, forType.Name));
        }

        // Ensure default value is a correct value (if it was supplied,
        // otherwise, the default value will be taken from the base metadata
        // which was already validated)
        if (typeMetadata.IsDefaultValueModified)
        {
            // Will throw ArgumentException if fails.
            ValidateMetadataDefaultValue( typeMetadata, PropertyType, Name, ValidateValueCallback );
        }

        // Force all base classes to register their metadata
        dType = DependencyObjectType.FromSystemType(forType);

        // Get metadata for the base type
        baseMetadata = GetMetadata(dType.BaseType);

        // Make sure overriding metadata is the same type or derived type of
        // the base metadata
        if (!baseMetadata.GetType().IsAssignableFrom(typeMetadata.GetType()))
        {
            throw new ArgumentException(SR.OverridingMetadataDoesNotMatchBaseMetadataType);
        }
    }


    /// &lt;summary&gt;
    ///     Supply metadata for given type &amp; run static constructors if needed.
    /// &lt;/summary&gt;
    /// &lt;remarks&gt;
    ///     The supplied metadata will be merged with the type's base
    ///     metadata
    /// &lt;/remarks&gt;
    public void OverrideMetadata(Type forType, PropertyMetadata typeMetadata)
    {
        DependencyObjectType dType;
        PropertyMetadata baseMetadata;

        SetupOverrideMetadata(forType, typeMetadata, out dType, out baseMetadata);

        if (ReadOnly)
        {
            // Readonly and no DependencyPropertyKey - not allowed.
            throw new InvalidOperationException(SR.Format(SR.ReadOnlyOverrideNotAllowed, Name));
        }

        ProcessOverrideMetadata(forType, typeMetadata, dType, baseMetadata);
    }

    /// &lt;summary&gt;
    ///     Supply metadata for a given type, overriding a property that is
    /// read-only.  If property is not read only, tells user to use the Plain
    /// Jane OverrideMetadata instead.
    /// &lt;/summary&gt;
    public void OverrideMetadata(Type forType, PropertyMetadata typeMetadata, DependencyPropertyKey key)
    {
        DependencyObjectType dType;
        PropertyMetadata baseMetadata;

        SetupOverrideMetadata(forType, typeMetadata, out dType, out baseMetadata);

        if (key == null)
        {
            throw new ArgumentNullException("key");
        }

        if (ReadOnly)
        {
            // If the property is read-only, the key must match this property
            //  and the key must match that in the base metadata.

            if (key.DependencyProperty != this)
            {
                throw new ArgumentException(SR.Format(SR.ReadOnlyOverrideKeyNotAuthorized, Name));
            }

            VerifyReadOnlyKey(key);
        }
        else
        {
            throw new InvalidOperationException(SR.PropertyNotReadOnly);
        }

        // Either the property doesn't require a key, or the key match was
        //  successful.  Proceed with the metadata override.
        ProcessOverrideMetadata(forType, typeMetadata, dType, baseMetadata);
    }

    /// &lt;summary&gt;
    ///     After parameters have been validated for OverrideMetadata, this
    /// method is called to actually update the data structures.
    /// &lt;/summary&gt;
    private void ProcessOverrideMetadata(
        Type forType,
        PropertyMetadata typeMetadata,
        DependencyObjectType dType,
        PropertyMetadata baseMetadata)
    {
        // Store per-Type metadata for this property. Locks only on Write.
        // Datastructure guaranteed to be valid for non-locking readers
        lock (Synchronized)
        {
            if (DependencyProperty.UnsetValue == _metadataMap[dType.Id])
            {
                _metadataMap[dType.Id] = typeMetadata;
            }
            else
            {
                throw new ArgumentException(SR.Format(SR.TypeMetadataAlreadyRegistered, forType.Name));
            }
       }

        // Merge base's metadata into this metadata
        // CALLBACK
        typeMetadata.InvokeMerge(baseMetadata, this);

        // Type metadata may no longer change (calls OnApply)
        typeMetadata.Seal(this, forType);

        if (typeMetadata.IsInherited)
        {
            _packedData |= Flags.IsPotentiallyInherited;
        }

        if (typeMetadata.DefaultValueWasSet() &amp;&amp; (typeMetadata.DefaultValue != DefaultMetadata.DefaultValue))
        {
            _packedData |= Flags.IsDefaultValueChanged;
        }

        if (typeMetadata.UsingDefaultValueFactory)
        {
            _packedData |= Flags.IsPotentiallyUsingDefaultValueFactory;
        }
    }


    [FriendAccessAllowed]   // Built into Base, also used by Core &amp; Framework.
    internal object GetDefaultValue(DependencyObjectType dependencyObjectType)
    {
        if (!IsDefaultValueChanged)
        {
            return DefaultMetadata.DefaultValue;
        }

        return GetMetadata(dependencyObjectType).DefaultValue;
    }

    [FriendAccessAllowed]   // Built into Base, also used by Core &amp; Framework.
    internal object GetDefaultValue(Type forType)
    {
        if (!IsDefaultValueChanged)
        {
            return DefaultMetadata.DefaultValue;
        }

        return GetMetadata(DependencyObjectType.FromSystemTypeInternal(forType)).DefaultValue;
    }

    /// &lt;summary&gt;
    ///     Retrieve metadata for a provided type
    /// &lt;/summary&gt;
    /// &lt;param name="forType"&gt;Type to get metadata&lt;/param&gt;
    /// &lt;returns&gt;Property metadata&lt;/returns&gt;
    public PropertyMetadata GetMetadata(Type forType)
    {
        if (forType != null)
        {
            return GetMetadata(DependencyObjectType.FromSystemType(forType));
        }
        throw new ArgumentNullException("forType");
    }

    /// &lt;summary&gt;
    ///     Retrieve metadata for a provided DependencyObject
    /// &lt;/summary&gt;
    /// &lt;param name="dependencyObject"&gt;DependencyObject to get metadata&lt;/param&gt;
    /// &lt;returns&gt;Property metadata&lt;/returns&gt;
    public PropertyMetadata GetMetadata(DependencyObject dependencyObject)
    {
        if (dependencyObject != null)
        {
            return GetMetadata(dependencyObject.DependencyObjectType);
        }
        throw new ArgumentNullException("dependencyObject");
    }

    /// &lt;summary&gt;
    /// Reteive metadata for a DependencyObject type described by the
    /// given DependencyObjectType
    /// &lt;/summary&gt;
    public PropertyMetadata GetMetadata(DependencyObjectType dependencyObjectType)
    {
        // All static constructors for this DType and all base types have already
        // been run. If no overriden metadata was provided, then look up base types.
        // If no metadata found on base types, then return default

        if (null != dependencyObjectType)
        {
            // Do we in fact have any overrides at all?
            int index = _metadataMap.Count - 1;
            int Id;
            object value;

            if (index &lt; 0)
            {
                // No overrides or it's the base class
                return _defaultMetadata;
            }
            else if (index == 0)
            {
                // Only 1 override
                _metadataMap.GetKeyValuePair(index, out Id, out value);

                // If there is overriden metadata, then there is a base class with
                // lower or equal Id of this class, or this class is already a base class
                // of the overridden one. Therefore dependencyObjectType won't ever
                // become null before we exit the while loop
                while (dependencyObjectType.Id &gt; Id)
                {
                    dependencyObjectType = dependencyObjectType.BaseType;
                }

                if (Id == dependencyObjectType.Id)
                {
                    // Return the override
                    return (PropertyMetadata)value;
                }
                // Return default metadata
            }
            else
            {
                // We have more than 1 override for this class, so we will have to loop through
                // both the overrides and the class Id
                if (0 != dependencyObjectType.Id)
                {
                    do
                    {
                        // Get the Id of the most derived class with overridden metadata
                        _metadataMap.GetKeyValuePair(index, out Id, out value);
                        --index;

                        // If the Id of this class is less than the override, then look for an override
                        // with an equal or lower Id until we run out of overrides
                        while ((dependencyObjectType.Id &lt; Id) &amp;&amp; (index &gt;= 0))
                        {
                            _metadataMap.GetKeyValuePair(index, out Id, out value);
                            --index;
                        }

                        // If there is overriden metadata, then there is a base class with
                        // lower or equal Id of this class, or this class is already a base class
                        // of the overridden one. Therefore dependencyObjectType won't ever
                        // become null before we exit the while loop
                        while (dependencyObjectType.Id &gt; Id)
                        {
                            dependencyObjectType = dependencyObjectType.BaseType;
                        }

                        if (Id == dependencyObjectType.Id)
                        {
                            // Return the override
                            return (PropertyMetadata)value;
                        }
                    }
                    while (index &gt;= 0);
                }
            }
        }
        return _defaultMetadata;
    }


    /// &lt;summary&gt;
    ///     Associate another owner type with this property
    /// &lt;/summary&gt;
    /// &lt;remarks&gt;
    ///     The owner type is used when resolving a property by name (&lt;see cref="FromName"/&gt;)
    /// &lt;/remarks&gt;
    /// &lt;param name="ownerType"&gt;Additional owner type&lt;/param&gt;
    /// &lt;returns&gt;This property&lt;/returns&gt;
    public DependencyProperty AddOwner(Type ownerType)
    {
        // Forwarding
        return AddOwner(ownerType, null);
    }

    /// &lt;summary&gt;
    ///     Associate another owner type with this property
    /// &lt;/summary&gt;
    /// &lt;remarks&gt;
    ///     The owner type is used when resolving a property by name (&lt;see cref="FromName"/&gt;)
    /// &lt;/remarks&gt;
    /// &lt;param name="ownerType"&gt;Additional owner type&lt;/param&gt;
    /// &lt;param name="typeMetadata"&gt;Optional type metadata to override on owner's behalf&lt;/param&gt;
    /// &lt;returns&gt;This property&lt;/returns&gt;
    public DependencyProperty AddOwner(Type ownerType, PropertyMetadata typeMetadata)
    {
        if (ownerType == null)
        {
            throw new ArgumentNullException("ownerType");
        }

        // Map owner type to this property
        // Build key
        FromNameKey key = new FromNameKey(Name, ownerType);

        lock (Synchronized)
        {
            if (PropertyFromName.Contains(key))
            {
                throw new ArgumentException(SR.Format(SR.PropertyAlreadyRegistered, Name, ownerType.Name));
            }
        }

        if (typeMetadata != null)
        {
            OverrideMetadata(ownerType, typeMetadata);
        }


        lock (Synchronized)
        {
            PropertyFromName[key] = this;
        }


        return this;
    }


    /// &lt;summary&gt;
    ///     Name of the property
    /// &lt;/summary&gt;
    public string Name
    {
        get { return _name; }
    }

    /// &lt;summary&gt;
    ///     Type of the property
    /// &lt;/summary&gt;
    public Type PropertyType
    {
        get { return _propertyType; }
    }

    /// &lt;summary&gt;
    ///     Owning type of the property
    /// &lt;/summary&gt;
    public Type OwnerType
    {
        get { return _ownerType; }
    }

    /// &lt;summary&gt;
    ///     Default metadata for the property
    /// &lt;/summary&gt;
    public PropertyMetadata DefaultMetadata
    {
        get { return _defaultMetadata; }
    }

    /// &lt;summary&gt;
    ///     Value validation callback
    /// &lt;/summary&gt;
    public ValidateValueCallback ValidateValueCallback
    {
        get { return _validateValueCallback; }
    }

    /// &lt;summary&gt;
    ///     Zero-based globally unique index of the property
    /// &lt;/summary&gt;
    public int GlobalIndex
    {
        get { return (int) (_packedData &amp; Flags.GlobalIndexMask); }
    }

    internal bool IsObjectType
    {
        get { return (_packedData &amp; Flags.IsObjectType) != 0; }
    }

    internal bool IsValueType
    {
        get { return (_packedData &amp; Flags.IsValueType) != 0; }
    }

    internal bool IsFreezableType
    {
        get { return (_packedData &amp; Flags.IsFreezableType) != 0; }
    }

    internal bool IsStringType
    {
        get { return (_packedData &amp; Flags.IsStringType) != 0; }
    }

    internal bool IsPotentiallyInherited
    {
        get { return (_packedData &amp; Flags.IsPotentiallyInherited) != 0; }
    }

    internal bool IsDefaultValueChanged
    {
        get { return (_packedData &amp; Flags.IsDefaultValueChanged) != 0; }
    }

    internal bool IsPotentiallyUsingDefaultValueFactory
    {
        get { return (_packedData &amp; Flags.IsPotentiallyUsingDefaultValueFactory) != 0; }
    }

    /// &lt;summary&gt;
    ///     Serves as a hash function for a particular type, suitable for use in
    ///     hashing algorithms and data structures like a hash table
    /// &lt;/summary&gt;
    /// &lt;returns&gt;The DependencyProperty's GlobalIndex&lt;/returns&gt;
    public override int GetHashCode()
    {
        return GlobalIndex;
    }

    /// &lt;summary&gt;
    ///     Used to determine if given value is appropriate for the type of the property
    /// &lt;/summary&gt;
    /// &lt;param name="value"&gt;Value to check&lt;/param&gt;
    /// &lt;returns&gt;true if value matches property type&lt;/returns&gt;
    public bool IsValidType(object value)
    {
        return IsValidType(value, PropertyType);
    }


    /// &lt;summary&gt;
    ///     Used to determine if given value is appropriate for the type of the property
    ///     and the range of values (as specified via the ValidateValueCallback) within that type
    /// &lt;/summary&gt;
    /// &lt;param name="value"&gt;Value to check&lt;/param&gt;
    /// &lt;returns&gt;true if value is appropriate&lt;/returns&gt;
    public bool IsValidValue(object value)
    {
        if (!IsValidType(value, PropertyType))
        {
            return false;
        }

        if (ValidateValueCallback != null)
        {
            // CALLBACK
            return ValidateValueCallback(value);
        }

        return true;
    }

    /// &lt;summary&gt;
    ///     Set/Value value disabling
    /// &lt;/summary&gt;
    public bool ReadOnly
    {
        get
        {
            return (_readOnlyKey != null);
        }
    }

    /// &lt;summary&gt;
    ///     Returns the DependencyPropertyKey associated with this DP.
    /// &lt;/summary&gt;
    internal DependencyPropertyKey DependencyPropertyKey
    {
        get
        {
            return _readOnlyKey;
        }
    }

    internal void VerifyReadOnlyKey( DependencyPropertyKey candidateKey )
    {
        Debug.Assert( ReadOnly, "Why are we trying to validate read-only key on a property that is not read-only?");

        if (_readOnlyKey != candidateKey)
        {
            throw new ArgumentException(SR.ReadOnlyKeyNotAuthorized);
        }
    }

    /// &lt;summary&gt;
    ///     Internal version of IsValidValue that bypasses IsValidType check;
    ///     Called from SetValueInternal
    /// &lt;/summary&gt;
    /// &lt;param name="value"&gt;Value to check&lt;/param&gt;
    /// &lt;returns&gt;true if value is appropriate&lt;/returns&gt;
    internal bool IsValidValueInternal(object value)
    {
        if (ValidateValueCallback != null)
        {
            // CALLBACK
            return ValidateValueCallback(value);
        }

        return true;
    }

    /// &lt;summary&gt;
    ///     Find a property from name
    /// &lt;/summary&gt;
    /// &lt;remarks&gt;
    ///     Search includes base classes of the provided type as well
    /// &lt;/remarks&gt;
    /// &lt;param name="name"&gt;Name of the property&lt;/param&gt;
    /// &lt;param name="ownerType"&gt;Owner type of the property&lt;/param&gt;
    /// &lt;returns&gt;Dependency property&lt;/returns&gt;
    [FriendAccessAllowed]   // Built into Base, also used by Framework.
    internal static DependencyProperty FromName(string name, Type ownerType)
    {
        DependencyProperty dp = null;

        if (name != null)
        {
            if (ownerType != null)
            {
                FromNameKey key = new FromNameKey(name, ownerType);

                while ((dp == null) &amp;&amp; (ownerType != null))
                {
                    // Ensure static constructor of type has run
                    MS.Internal.WindowsBase.SecurityHelper.RunClassConstructor(ownerType);

                    // Locate property
                    key.UpdateNameKey(ownerType);

                    lock (Synchronized)
                    {
                        dp = (DependencyProperty)PropertyFromName[key];
                    }

                    ownerType = ownerType.BaseType;
                }
            }
            else
            {
                throw new ArgumentNullException("ownerType");
            }
        }
        else
        {
            throw new ArgumentNullException("name");
        }
        return dp;
    }


    /// &lt;summary&gt;
    ///    String representation
    /// &lt;/summary&gt;
    public override string ToString()
    {
        return _name;
    }


    internal static bool IsValidType(object value, Type propertyType)
    {
        if (value == null)
        {
            // Null values are invalid for value-types
            if (propertyType.IsValueType &amp;&amp;
                !(propertyType.IsGenericType &amp;&amp; propertyType.GetGenericTypeDefinition() == NullableType))
            {
                return false;
            }
        }
        else
        {
            // Non-null default value, ensure its the correct type
            if (!propertyType.IsInstanceOfType(value))
            {
                return false;
            }
        }

        return true;
    }

    private class FromNameKey
    {
        public FromNameKey(string name, Type ownerType)
        {
            _name = name;
            _ownerType = ownerType;

            _hashCode = _name.GetHashCode() ^ _ownerType.GetHashCode();
        }

        public void UpdateNameKey(Type ownerType)
        {
            _ownerType = ownerType;

            _hashCode = _name.GetHashCode() ^ _ownerType.GetHashCode();
        }

        public override int GetHashCode()
        {
            return _hashCode;
        }

        public override bool Equals(object o)
        {
            if ((o != null) &amp;&amp; (o is FromNameKey))
            {
                return Equals((FromNameKey)o);
            }
            else
            {
                return false;
            }
        }

        public bool Equals(FromNameKey key)
        {
            return (_name.Equals(key._name) &amp;&amp; (_ownerType == key._ownerType));
        }

        private string _name;
        private Type _ownerType;

        private int _hashCode;
    }


    private DependencyProperty(string name, Type propertyType, Type ownerType, PropertyMetadata defaultMetadata, ValidateValueCallback validateValueCallback)
    {
        _name = name;
        _propertyType = propertyType;
        _ownerType = ownerType;
        _defaultMetadata = defaultMetadata;
        _validateValueCallback = validateValueCallback;

        Flags packedData;
        lock (Synchronized)
        {
            packedData = (Flags) GetUniqueGlobalIndex(ownerType, name);

            RegisteredPropertyList.Add(this);
        }

        if (propertyType.IsValueType)
        {
            packedData |= Flags.IsValueType;
        }

        if (propertyType == typeof(object))
        {
            packedData |= Flags.IsObjectType;
        }

        if (typeof(Freezable).IsAssignableFrom(propertyType))
        {
            packedData |= Flags.IsFreezableType;
        }

        if (propertyType == typeof(string))
        {
            packedData |= Flags.IsStringType;
        }

        _packedData = packedData;
    }

    // Synchronized: Covered by DependencyProperty.Synchronized
    internal static int GetUniqueGlobalIndex(Type ownerType, string name)
    {
        // Prevent GlobalIndex from overflow. DependencyProperties are meant to be static members and are to be registered
        // only via static constructors. However there is no cheap way of ensuring this, without having to do a stack walk. Hence
        // concievably people could register DependencyProperties via instance methods and therefore cause the GlobalIndex to
        // overflow. This check will explicitly catch this error, instead of silently malfuntioning.
        if (GlobalIndexCount &gt;= (int)Flags.GlobalIndexMask)
        {
            if (ownerType != null)
            {
                throw new InvalidOperationException(SR.Format(SR.TooManyDependencyProperties, ownerType.Name + "." + name));
            }
            else
            {
                throw new InvalidOperationException(SR.Format(SR.TooManyDependencyProperties, "ConstantProperty"));
            }
        }

        // Covered by Synchronized by caller
        return GlobalIndexCount++;
    }

    /// &lt;summary&gt;
    /// This is the callback designers use to participate in the computation of property
    /// values at design time. Eg. Even if the author sets Visibility to Hidden, the designer
    /// wants to coerce the value to Visible at design time so that the element doesn't
    /// disappear from the design surface.
    /// &lt;/summary&gt;
    internal CoerceValueCallback DesignerCoerceValueCallback
    {
        get {  return _designerCoerceValueCallback; }
        set
        {
            if (ReadOnly)
            {
                throw new InvalidOperationException(SR.Format(SR.ReadOnlyDesignerCoersionNotAllowed, Name));
            }

            _designerCoerceValueCallback = value;
        }
    }

    /// &lt;summary&gt; Standard unset value &lt;/summary&gt;
    public static readonly object UnsetValue = new NamedObject("DependencyProperty.UnsetValue");

    private string _name;
    private Type _propertyType;
    private Type _ownerType;
    private PropertyMetadata _defaultMetadata;
    private ValidateValueCallback _validateValueCallback;
    private DependencyPropertyKey _readOnlyKey;


    [Flags]
    private enum Flags : int
    {
        GlobalIndexMask                           = 0x0000FFFF,
        IsValueType                               = 0x00010000,
        IsFreezableType                           = 0x00020000,
        IsStringType                              = 0x00040000,
        IsPotentiallyInherited                    = 0x00080000,
        IsDefaultValueChanged                     = 0x00100000,
        IsPotentiallyUsingDefaultValueFactory     = 0x00200000,
        IsObjectType                              = 0x00400000,
        // 0xFF800000   free bits
    }

    private Flags _packedData;

    // Synchronized (write locks, lock-free reads): Covered by DependencyProperty instance
    // This is a map that contains the IDs of derived classes that have overriden metadata
    /* property */ internal InsertionSortMap _metadataMap = new InsertionSortMap();

    private CoerceValueCallback _designerCoerceValueCallback;

    // Synchronized (write locks, lock-free reads): Covered by DependencyProperty.Synchronized
    /* property */ internal static ItemStructList&lt;DependencyProperty&gt; RegisteredPropertyList = new ItemStructList&lt;DependencyProperty&gt;(768);

    // Synchronized: Covered by DependencyProperty.Synchronized
    private static Hashtable PropertyFromName = new Hashtable();

    // Synchronized: Covered by DependencyProperty.Synchronized
    private static int GlobalIndexCount;

    // Global, cross-object synchronization
    internal static object Synchronized = new object();

    // Nullable Type
    private static Type NullableType = typeof(Nullable&lt;&gt;);

    /// &lt;summary&gt;
    ///     Returns the number of all registered properties.
    /// &lt;/summary&gt;
    internal static int RegisteredPropertyCount {
        get {
            return RegisteredPropertyList.Count;
        }
    }

    /// &lt;summary&gt;
    ///     Returns an enumeration of properties that are
    ///     currently registered.
    ///     Synchronized (write locks, lock-free reads): Covered by DependencyProperty.Synchronized
    /// &lt;/summary&gt;
    internal static IEnumerable RegisteredProperties {
        get {
            foreach(DependencyProperty dp in RegisteredPropertyList.List) {
                if (dp != null) {
                    yield return dp;
                }
            }
        }
    }

}
}

4 - 依赖属性的好处怎么提现?

WPF的设计理念是:数据驱动,UI与逻辑松耦合。我们从这个上边可以去研究一下。

public class Person
{
    private string _Name;
    public string Name
    {
        get
        {
             return _Name;
         }
         set
         {
            _Name = value;
         }
     }
 }

但是呢,CLR属性有个特点,在多级继承的情况下,每次继承,父类的字段都被继承,孙孙辈对象占用内存空间不可避免的膨胀。

那么说在基于这个缺点的情况下,依赖属性呢解决了一部分问题

  • 在多级继承,大多数字段并没有被修改的情况下,如何少对象的体积。
  • 数据驱动指导思想下,数据如何保存简单一致,同步
// 1. 使类型继承DependencyObject类
public class Person : DependencyObject
{
    // 2. 声明一个静态只读的DependencyProperty 字段
    public static readonly DependencyProperty nameProperty;
    static Person()
    {
        // 3. 注册定义的依赖属性
        nameProperty = DependencyProperty.Register("Name", typeof(string), typeof(Person), 
            new PropertyMetadata("Learning Hard",OnValueChanged)); 
    }
    // 4. 属性包装器,通过它来读取和设置我们刚才注册的依赖属性
    public string Name
    {
        get { return (string)GetValue(nameProperty); }
        set { SetValue(nameProperty, value); }
    }
    private static void OnValueChanged(DependencyObject dpobj, DependencyPropertyChangedEventArgs e)
    {
        // 当只发生改变时回调的方法
    }
}

优势在那里呢?

1、解决多级继承,且大多数字段值不改变的情况下,减少内存占比

将一个DependencyProperty对象存储在一个全局的Hashtable中;通过依赖对象(DependencyObject)的GetValue和SetValue存取数据;

2、以数据为中心,当数据源改变时,所以关联的UI数据改变;

依赖属性值可以通过Binding依赖于其它对象上,这就使得数据源一变动;依赖于此数据源的依赖属性全部进行更新

这里呢贴一个链接可以参考参考:

5 - 依赖属性怎么解决内存占比问题呢?

首先呢,我们先确认一下对于依赖属性而言,到底有没有节约内存。我们写个Demo就能明显看出来

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.Navigation;
using System.Windows.Shapes;

namespace FifthWPFDemo
{
/// <summary>
/// MainWindow.xaml 的交互逻辑
/// </summary>
public partial class MainWindow : Window
{
Person per;
public MainWindow()
{
InitializeComponent();
List<Person> list = new List<Person>();
for (int i = 0; i < 10000000; i++)
{
per = new Person();
list.Add(per);
}
}
}
public class Person
{
public double Name { get; set; }
public double Name1 { get; set; }
public double Name2 { get; set; }
public double Name3 { get; set; }
public double Name4 { get; set; }
public double Name5 { get; set; }
public double Name6 { get; set; }
public double Name7 { get; set; }
public double Name8 { get; set; }
public double Name9 { get; set; }
public double Name10 { get; set; }
}
}

此时我们将普通属性换位依赖属性我们再看看

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.Navigation;
using System.Windows.Shapes;

namespace FifthWPFDemo
{
/// <summary>
/// MainWindow.xaml 的交互逻辑
/// </summary>
public partial class MainWindow : Window
{
Person per;
public MainWindow()
{
InitializeComponent();
List<Person> list = new List<Person>();
for (int i = 0; i < 10000000; i++)
{
per = new Person();
list.Add(per);
}
}
}
public class Person : DependencyObject
{
public double Name
{
get
{
return (double)GetValue(NameProperty);
}
set
{
SetValue(NameProperty, value);
}
}
public double Name1
{
get
{
return (double)GetValue(Name1Property);
}
set
{
SetValue(Name1Property, value);
}
}
public double Name2
{
get
{
return (double)GetValue(Name2Property);
}
set
{
SetValue(Name2Property, value);
}
}
public double Name3
{
get
{
return (double)GetValue(Name3Property);
}
set
{
SetValue(Name3Property, value);
}
}

    public double Name4
    {
        get
        {
            return (double)GetValue(Name4Property);
        }
        set
        {
            SetValue(Name4Property, value);
        }
    }
    public double Name5
    {
        get
        {
            return (double)GetValue(Name5Property);
        }
        set
        {
            SetValue(Name5Property, value);
        }
    }
    public double Name6
    {
        get
        {
            return (double)GetValue(Name6Property);
        }
        set
        {
            SetValue(Name6Property, value);
        }
    }

    public double Name7
    {
        get
        {
            return (double)GetValue(Name7Property);
        }
        set
        {
            SetValue(Name7Property, value);
        }
    }
    public double Name8
    {
        get
        {
            return (double)GetValue(Name8Property);
        }
        set
        {
            SetValue(Name8Property, value);
        }
    }
    public double Name9
    {
        get
        {
            return (double)GetValue(Name9Property);
        }
        set
        {
            SetValue(Name9Property, value);
        }
    }
    public double Name10
    {
        get
        {
            return (double)GetValue(Name10Property);
        }
        set
        {
            SetValue(Name10Property, value);
        }
    }
    public static readonly DependencyProperty NameProperty = DependencyProperty.Register("Name", typeof(double), typeof(Person), new PropertyMetadata((double)55.55));
    public static readonly DependencyProperty Name1Property = DependencyProperty.Register("Name1", typeof(double), typeof(Person), new PropertyMetadata((double)55.55));
    public static readonly DependencyProperty Name2Property = DependencyProperty.Register("Name2", typeof(double), typeof(Person), new PropertyMetadata((double)55.55));
    public static readonly DependencyProperty Name3Property = DependencyProperty.Register("Name3", typeof(double), typeof(Person), new PropertyMetadata((double)55.55));
    public static readonly DependencyProperty Name4Property = DependencyProperty.Register("Name4", typeof(double), typeof(Person), new PropertyMetadata((double)55.55));
    public static readonly DependencyProperty Name5Property = DependencyProperty.Register("Name5", typeof(double), typeof(Person), new PropertyMetadata((double)55.55));
    public static readonly DependencyProperty Name6Property = DependencyProperty.Register("Name6", typeof(double), typeof(Person), new PropertyMetadata((double)55.55));
    public static readonly DependencyProperty Name7Property = DependencyProperty.Register("Name7", typeof(double), typeof(Person), new PropertyMetadata((double)55.55));
    public static readonly DependencyProperty Name8Property = DependencyProperty.Register("Name8", typeof(double), typeof(Person), new PropertyMetadata((double)55.55));
    public static readonly DependencyProperty Name9Property = DependencyProperty.Register("Name9", typeof(double), typeof(Person), new PropertyMetadata((double)55.55));
    public static readonly DependencyProperty Name10Property = DependencyProperty.Register("Name10", typeof(double), typeof(Person), new PropertyMetadata((double)55.55));
}
//public class Person
//{
//    public double Name { get; set; }
//    public double Name1 { get; set; }
//    public double Name2 { get; set; }
//    public double Name3 { get; set; }
//    public double Name4 { get; set; }
//    public double Name5 { get; set; }
//    public double Name6 { get; set; }
//    public double Name7 { get; set; }
//    public double Name8 { get; set; }
//    public double Name9 { get; set; }
//    public double Name10 { get; set; }
//}

}

然后我们再循环一千万次

那么WPF的属性到底是如何节约内存的呢。因为CLR属性是在实例声明的时候就分配好了内存空间的。所以就算实例里面没有写入值,或者仍然是默认值,仍然会分配好内存空间。但是WPF的依赖属性不同。

所以依赖属性正在节约内存就在于这儿的依赖属性是一个static readonly 属性。所以不需要在对象每次实例化的时候都分配相关属性的内存空间,而是提供一个入口点。

6 - 依赖属性的回写和强制转换

 //注册依赖属性
PropertyMetadata propertyMetadata = new PropertyMetadata();
propertyMetadata.DefaultValue = Brushes.DeepSkyBlue;
//属性值改变回写
propertyMetadata.PropertyChangedCallback = ((s, e) =>
{
    Debug.WriteLine(String.Format("PropertyChanged - 属性:{0} 新值:{1} 旧值:{2}", e.Property.Name, e.NewValue, e.OldValue));
});
//强制转换
propertyMetadata.CoerceValueCallback = (s, e) =>
{
    Debug.WriteLine(String.Format("CoerceValue - {0}", e));
    return e;
};

MyColorProperty =
DependencyProperty.Register("MyColor", typeof(Brush), typeof(MyButton), propertyMetadata, (o) => {
Brush brush = o as Brush;
if (brush== Brushes.Yellow||brush== Brushes.Blue)
{
return false;
}
else
{
return true;
}
});

在写代码是都会考虑可能发生的错误。在定义属性时,也需要考虑错误设置属性的可能性。对于传统.NET属性,可以在属性的设置器中进行属性值的验证,不满足条件的值可以抛出异常。但对于依赖属性来说,这种方法不合适,因为依赖属性通过SetValue方法来直接设置其值的。然而WPF有其代替的方式,WPF中提供了两种方法来用于验证依赖属性的值。

1、ValidateValueCallback:该回调函数可以接受或拒绝新值。该值可作为DependencyProperty.Register方法的一个参数。

2、CoerceValueCallback:该回调函数可将新值强制修改为可被接受的值。例如某个依赖属性工作年龄的值范围是25到55,在该回调函数中,可以对设置的值进行强制修改,对于不满足条件的值,强制修改为满足条件的值。如当设置为负值时,可强制修改为0。该回调函数PropertyMetadata构造函数参数进行传递。

posted @ 2023-03-15 13:50  IceAmos  阅读(234)  评论(0编辑  收藏  举报