WPF 依赖属性前言

WPF 依赖属性前言

​ 在.net中,我们可以属性来获取或设置字段的值,不需要在编写额外的get和set方法,但这有一个前提,那就是需要在对象中拥有一个字段,才能在此字段的基础上获取或设置字段的值,比如:

// 字段
private int _age = 23;

// 属性
public int Age
{
	get { return _age; }
  	set { _age = value; }
}

​ 但在wpf中,微软引入了一种依赖属性的方法来获取或者设置控件的值,之所以叫做依赖,是因为这个值能够从其他数据源中获取值(依赖在别人身上)而在控件对象上不保存这个值,所以依赖属性能有效地较少内存开销。

依赖属性先简单说到这里,有时我们往往只是记住了结论而忽略了推导过程,下面的我对推到过程的一些思考:

**如果让我们自己来实现依赖属性,我们该怎么实现呢? **

首先能确定的是,我们不能定义控件拥有的所有字段,如果定义了,那么控件对象被创建时,所有字段都会被初始化,都会有一个初始值,内存就会被浪费,这样不行,所以我就想到了用字典Dictionary<int,object>的方式来存储需要的值。用int来存储一个索引值,保证控件中的每个属性索引值都不一样;用object来存储属性的值。

由于每种控件都需要此字典来存储值,所以控件要有一个基类,这里我取名MyDependencyObject,它的结构大致应该是这样:

	/// <summary>
    /// 依赖对象
    /// </summary>
    public class MyDependencyObject
    {
        private Dictionary<int, object> _keyValue = new Dictionary<int, object>();

        public object GetValue(int index)
        {
            return _keyValue[index];
        }

        public void SetValue(int index, object value)
        {
            _keyValue[index] = value;
        }
    }

然后我们应该确定的是,控件的每个属性都应该有个索引值啊,这样才能在_keyValue字典中找到对应的值。然后又想到这个索引值应该是和对象无关的,是和类相关的,所以应该是一种静态的方式来得到这个索引值,所以实现的方式大概是这样:

	/// <summary>
    /// 依赖对象
    /// </summary>
    public class MyDependencyObject
    {
        private Dictionary<int, object> _keyValue = new Dictionary<int, object>();

        public object GetValue(int index)
        {
            return _keyValue[index];
        }

        public void SetValue(int index, object value)
        {
            _keyValue[index] = value;
        }

        // 某种算法根据属性名获取一个索引值
        protected static int GetIndex(string propertyName)
        {
            // ...
        }

    }

	/// <summary>
    /// 按钮控件
    /// </summary>
    public class MyButton : MyDependencyObject
    {

        /// <summary>
        /// 按钮内容属性索引
        /// </summary>
        public int ContentProperty = MyDependencyObject.GetIndex("Content");

        /// <summary>
        /// 按钮内容属性 
        /// </summary>
        public string Content
        {
            get
            {
                return (string)base.GetValue(ContentProperty);
            }
            set
            {
                base.SetValue(ContentProperty, value);
            }
        }
    }

在基类MyDependencyObject中定义一个静态方法GetIndex,子类根据属性的名字来获取唯一的索引,然后在根据索引值来获取和设置值。

虽然上面的方式已经可以达到节省内存的目的,但是对于属性更多的控制,比如属性的默认值、值变化回调、是否是只读的等等这些都达不到要求,所以属性应该被定义成更复杂的类型以完成更多的功能,而不是是用一个int的索引就完成了,所以我把这个更复杂的类型定义为MyDependencyProperty,它的结构如下:

	/// <summary>
    /// 依赖属性
    /// </summary>
    public class MyDependencyProperty
    {
        /// <summary>
        /// 索引和属性数据字典
        /// </summary>
        public static Dictionary<int, MyDependencyProperty> _indexProperty = new Dictionary<int, MyDependencyProperty>();

        /// <summary>
        /// 注册依赖属性
        /// </summary>
        /// <param name="propertyName">属性名</param>
        /// <param name="ownType">拥有者类型</param>
        /// <param name="propertyData">属性数据</param>
        /// <returns></returns>
        public static MyDependencyProperty Register(string propertyName, Type ownType, MyPropertyMetadata propertyData)
        {
            MyDependencyProperty property = new MyDependencyProperty(propertyName, ownType, propertyData);
            int index = GetIndex(propertyName, ownType);
            _indexProperty[index] = property;
            return property;
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        public MyDependencyProperty(string propertyName, Type ownType, MyPropertyMetadata data)
        {
            Name = propertyName;
            OwnType = ownType;
            DefaultMetaData = data;
        }

        /// <summary>
        ///属性名 
        /// </summary>
        public string Name { get; private set; }

        /// <summary>
        /// 拥有者类型
        /// </summary>
        public Type OwnType { get; private set; }

        /// <summary>
        /// 属性数据
        /// </summary>
        public MyPropertyMetadata DefaultMetaData { get; private set; }

        /// <summary>
        /// 使用某种算法按照属性名获取一个索引值 
        /// </summary>
        /// <param name="propertyName"></param>
        /// <param name="ownType"></param>
        /// <returns></returns>
        private static int GetIndex(string propertyName, Type ownType)
        {
            // ...
            return 0;
        }
    }

    /// <summary>
    /// 属性数据
    /// </summary>
    public class MyPropertyMetadata
    {
        public MyPropertyMetadata(object defaultValue)
        {
            DefaultValue = defaultValue;
        }

        /// <summary>
        /// 默认值
        /// </summary>
        public object DefaultValue { get; set; }

        // 其他的值 ...
    }

MyDependencyProperty中包含了静态字段Dictionary<int, MyDependencyProperty> _indexProperty,它保存了索引-依赖属性的集合,整个应用程序只包含一个集合。通过静态方法GetIndex(string propertyName, Type ownType)计算索引值,计算索引值需要属性名和拥有者类型,这样可以计算出唯一的索引。

像下面这样使用上面的依赖属性:

	/// <summary>
    /// 依赖对象
    /// </summary>
    public class MyDependencyObject
    {
        private Dictionary<int, object> _keyValue = new Dictionary<int, object>();

        public object GetValue(MyDependencyProperty dp)
        {
            int index = MyDependencyProperty.GetIndex(dp.Name, dp.OwnType);
            // 如果字典的Key中不包含索引 那么返回属性的默认值
            if(!_keyValue.ContainsKey(index))
            {
                return dp.DefaultMetaData.DefaultValue;
            }
            else
            {
                return _keyValue[index];
            }
        }

        public void SetValue(MyDependencyProperty dp, object value)
        {
            int index = MyDependencyProperty.GetIndex(dp.Name, dp.OwnType);
            _keyValue[index] = value;
        }

    }


    /// <summary>
    /// 按钮控件
    /// </summary>
    public class MyButton : MyDependencyObject
    {

        /// <summary>
        /// 按钮内容依赖属性
        /// </summary>
        public MyDependencyProperty ContentProperty 
            = MyDependencyProperty.Register("Content", typeof(MyButton), new MyPropertyMetadata("Hello world"));

        /// <summary>
        /// 按钮内容属性 
        /// </summary>
        public string Content
        {
            get
            {
                return (string)base.GetValue(ContentProperty);
            }
            set
            {
                base.SetValue(ContentProperty, value);
            }
        }
    }

简单的实现方式想到的也就这么多了,感觉算是有了依赖属性的雏形啦,WPF中的依赖属性下一篇在说吧。

posted @ 2017-05-14 23:22  niechangxu  阅读(152)  评论(0编辑  收藏  举报