WPF基础到企业应用系列7――深入剖析依赖属性（四）

设计模式 前端之家
前端之家收集整理的这篇文章主要介绍了WPF基础到企业应用系列7――深入剖析依赖属性（四），前端之家小编觉得挺不错的，现在分享给大家，也给大家做个参考。

十一. 依赖属性元数据

前面我们看到一个依赖属性的注册最全的形式是下面这样子的：

public static DependencyProperty Register(string name,Type propertyType,175);">Type ownerType,175);">PropertyMetadata typeMetadata,175);">ValidateValueCallback validateValueCallback);

　　第一个参数是该依赖属性的名字，第二个参数是依赖属性的类型，第三个参数是该依赖属性的所有者的类型，第五个参数就是一个验证值的回调委托，那么最使我们感兴趣的还是这个可爱的 PropertyMetadata ，也就是我们接下来要讲的元数据。 提到WPF属性元数据，大家可能第一想到的是刚才的PropertyMetadata，那么这个类到底是怎样的呢？我们应该怎样使用它呢？首先我们看它的构造函数（我们选参数最多的来讲）：

public PropertyMetadata(object defaultValue,175);">PropertyChangedCallback propertyChangedCallback,CoerceValueCallback coerceValueCallback);

　　其中的第一个参数是默认值，最后两个分别是PropertyChanged（变化通知）以及Coerce（强制）的两个委托变量，我们在实例化的时候，只需要把这两个委托变量关联到具体的方法上即可。

　　事实上，除了PropertyMetadata以外，常见的还有 FrameworkPropertyMetadata，UIPropertyMetadata。他们的继承关系是F->U->P。其中以 FrameworkPropertyMetadata参数最多，亦最为复杂。

FrameworkPropertyMetadata的构造函数提供了很多重载，我们挑选最为复杂的重载来看它到底有哪些参数以及提供了哪些功能：

public FrameworkPropertyMetadata(object defaultValue,175);">FrameworkPropertyMetadataOptions flags,PropertyChangedCallback propertyChangedCallback,CoerceValueCallback coerceValueCallback,bool isAnimationProhibited,UpdateSourceTrigger defaultUpdateSourceTrigger);

　　其中第一个参数是默认值，最后两个参数分别是是否允许动画，以及绑定时更新的策略（在Binding当中相信大家并不陌生），这个不详细解释 了。重点看一下里第三、四两个参数，两个 CallBack的委托。结合前面Register的时候提到的ValidateValueCallback共组成三大”金刚“，这三个Callback 分别代表Validate（验证），PropertyChanged（变化通知）以及Coerce（强制）。当然，作为 Metadata，FrameworkPropertyMetadata只是储存了该依赖属性的策略信息，WPF属性系统会根据这些信息来提供功能并在适 当的时机回调传入的delegate，所以最重要的还是我们定义的这些方法，通过他们传入委托才能起到真正的作用。

上面讲了元数据暴露给我们的构造函数，其实在其内部还提供了两个方法，这个在做自定义控件的时候，也很值得注意:

protected virtual void Merge(PropertyMetadata baseMetadata,175);">DependencyProperty dp)
{
    // 实现元数据继承之间的合并
}

protected virtual void OnApply(DependencyProperty dependencyProperty,175);">Type targetType)
{
    // 当元数据被这个属性应用，OnApply就会被触发，在此时元数据也将被密封起来。
}

前面讲了这么多，那么我们现在就来看看依赖属性回调、验证及强制值到底是怎么使用的呢？大家千万要坚持住，后面内容更加精彩！

十二. 依赖属性回调、验证及强制值

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

2010-8-26 15-20-38

  • 第一步，基础值就是上面“六.依赖属性的优先级”提供的那些显示设置，所以它的优先级比较好确定，但有些不会按常规出牌，所以也需要注意总结。
  • 第二步，如果依赖属性值是计算表达式 (如前面示例中的绑定等语法特性)，这个时候就会计算表达式的结果作为第二步的值。
  • 第三步，动画是一种优先级很高的特殊行为，很多时候，我们都会听到动画优先的声音，所以它的优先级高于其他基础设置；
  • 第四步，强制则是注册时提供的 CoerceValueCallback 委托，它负责验证属性值是否在允许的限制范围之内，和我们对属性的验证一样，比如强制设置该值必须大于于0小于10等等；
  • 第五步，验证是指我们注册依赖属性所提供的 ValidateValueCallback 委托方法，它最终决定了属性值设置是否有效，当数据无效时会抛出异常来通知。

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

namespace SampleProcess_DPs
{
    class Program
    {
        static void Main(string[] args)
        {
            SimpleDPClass sDPClass = new SimpleDPClass();
            sDPClass.SimpleDP = 8;
            Console.ReadLine();
        }
    }

    public class SimpleDPClass : DependencyObject
    {
        public static readonly DependencyProperty SimpleDPProperty =
            DependencyProperty.Register("SimpleDP",typeof(double),typeof(SimpleDPClass),new FrameworkPropertyMetadata((double)0.0,175);">FrameworkPropertyMetadataOptions.None,175);">PropertyChangedCallback(OnValueChanged),175);">CoerceValueCallback(CoerceValue)),175);">ValidateValueCallback(IsValidValue));

        public double SimpleDP
        {
            get { return (double)GetValue(SimpleDPProperty); }
            set { SetValue(SimpleDPProperty,value); }
        }

        private static void OnValueChanged(DependencyObject d,175);">DependencyPropertyChangedEventArgs e)
        {
            Console.WriteLine("当值改变时，我们可以做的一些操作，具体可以在这里定义： {0}",e.NewValue);
        }

        private static object CoerceValue(object value)
        {
            "对值进行限定，强制值： {0}",value);
            return value;
        }

        private static bool IsValidValue(object value)
        {
            "验证值是否通过，返回bool值，如果返回True表示严重通过，否则会以异常的形式暴露： {0}",value);
            return true;
        }

    }
}

结果如下：

2010-8-26 1-29-16

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

　　上面简单介绍了处理流程，下面我们就以一个案例来具体看一看上面的流程到底有没有出入，这个例子改编于Sacha Barber 的Dependency Properties代码示例，我相信通过这段代码你会对这个上面讲的概念有更清晰地认识。

　　UI很简单，黄色部分显示当前值，我们在初始化的时候把它设置为100，然后它的最小值和最大值分别设置为0和500，按钮”设置为-100 “企图把当前值设为-100，按钮”设置为1000“试图把当前值设为1000。具体大家看代码(我都写了注释，很容易理解的).

2010-8-26 0-51-57

依赖属性代码文件如下：

namespace Callback_Validation_DPs
{
    public class Gauge : Control
    {
        public Gauge() : base() { }
        //注册CurrentReading依赖属性，并添加PropertyChanged、CoerceValue、ValidateValue的回调委托
        public static readonly DependencyProperty CurrentReadingProperty = DependencyProperty.Register(
            "CurrentReading",175);">Gauge),175);">FrameworkPropertyMetadata(
                Double.NaN,175);">PropertyChangedCallback(OnCurrentReadingChanged),175);">CoerceValueCallback(CoerceCurrentReading)
            ),175);">ValidateValueCallback(IsValidReading)
        );

        //属性包装器，通过它来暴露CurrentReading的值
        public double CurrentReading
        {
            get { return (double)GetValue(CurrentReadingProperty); }
            set { SetValue(CurrentReadingProperty,value); }
        }

        //注册MinReading依赖属性，并添加PropertyChanged、CoerceValue、ValidateValue的回调委托
        public static readonly DependencyProperty MinReadingProperty = DependencyProperty.Register(
        "MinReading",175);">FrameworkPropertyMetadata(
            double.NaN,175);">PropertyChangedCallback(OnMinReadingChanged),175);">CoerceValueCallback(CoerceMinReading)
        ),175);">ValidateValueCallback(IsValidReading));

        //属性包装器，通过它来暴露MinReading的值
        public double MinReading
        {
            get { return (double)GetValue(MinReadingProperty); }
            set { SetValue(MinReadingProperty,value); }
        }

        //注册MaxReading依赖属性，并添加PropertyChanged、CoerceValue、ValidateValue的回调委托
        public static readonly DependencyProperty MaxReadingProperty = "MaxReading",175);">FrameworkPropertyMetadata(
                double.NaN,175);">PropertyChangedCallback(OnMaxReadingChanged),175);">CoerceValueCallback(CoerceMaxReading)
            ),175);">ValidateValueCallback(IsValidReading)
        );

        //属性包装器，通过它来暴露MaxReading的值
        public double MaxReading
        {
            get { return (double)GetValue(MaxReadingProperty); }
            set { SetValue(MaxReadingProperty,value); }
        }

        //在CoerceCurrentReading加入强制判断赋值
        private static object CoerceCurrentReading(Gauge g = (Gauge)d;
            double current = (double)value;
            if (current < g.MinReading) current = g.MinReading;
            if (current > g.MaxReading) current = g.MaxReading;
            return current;
        }


        //当CurrentReading值改变的时候，调用MinReading和MaxReading的CoerceValue回调委托
        private static void OnCurrentReadingChanged(DependencyPropertyChangedEventArgs e)
        {
            d.CoerceValue(MinReadingProperty);  
            d.CoerceValue(MaxReadingProperty); 
        }

        //当OnMinReading值改变的时候，调用CurrentReading和MaxReading的CoerceValue回调委托
        private static void OnMinReadingChanged(DependencyPropertyChangedEventArgs e)
        {
            d.CoerceValue(MaxReadingProperty);
            d.CoerceValue(CurrentReadingProperty);
        }

        //在CoerceMinReading加入强制判断赋值
        private static object CoerceMinReading(Gauge)d;
            double min = (double)value;
            if (min > g.MaxReading) min = g.MaxReading;
            return min;
        }

        //在CoerceMaxReading加入强制判断赋值
        private static object CoerceMaxReading(Gauge)d;
            double max = (double)value;
            if (max < g.MinReading) max = g.MinReading;
            return max;
        }

        //当MaxReading值改变的时候，调用MinReading和CurrentReading的CoerceValue回调委托
        private static void OnMaxReadingChanged(DependencyPropertyChangedEventArgs e)
        {
            d.CoerceValue(MinReadingProperty);  
            d.CoerceValue(CurrentReadingProperty); 
        }

        //验证value是否有效，如果返回True表示验证通过，否则会提示异常
        public static bool IsValidReading(object value)
        {
            Double v = (Double)value;
            return (!v.Equals(Double.NegativeInfinity) && !v.Equals(Double.PositiveInfinity));
       }
    }
}

XAML代码如下：

<Window x:Class="Callback_Validation_DPs.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="clr-namespace:Callback_Validation_DPs" 
    WindowStartupLocation="CenterScreen" 
    Title="Callback_Validation_DPs" Height="400" Width="400">
    <StackPanel Orientation="Vertical">
        <local:Gauge x:Name="gauge1" MaxReading="100" MinReading="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=gauge1,Path=CurrentReading}" Height="25" VerticalAlignment="Top" />
        </StackPanel>
        <Button x:Name="btnSetBelowMin" Content="设置为 -100" 
                Click="btnSetBelowMin_Click"/>
        <Button x:Name="btnSetAboveMax" Content="设置为 1000" 
                Click="btnSetAboveMax_Click"/>
    </StackPanel>
</Window>

XAML的后台代码如下：

public partial class Window1 : Window
{
    public Window1()
    {
        InitializeComponent();
        //设置CurrentReading的值，这个时候会触发哪些变化？调试代码吧！
        gauge1.CurrentReading = 100;
    }

    private void btnSetBelowMin_Click(object sender,175);">RoutedEventArgs e)
    {
        //设置CurrentReading的值，这个时候会触发哪些变化？调试代码吧！
        gauge1.CurrentReading = -100;
    }

    private void btnSetAboveMax_Click(object sender,175);">RoutedEventArgs e)
    {
        //设置CurrentReading的值，这个时候会触发哪些变化？调试代码吧！
        gauge1.CurrentReading = 10000;

    }
}

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

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

原文链接：https://www.f2er.com/javaschema/287479.html

猜你在找的设计模式相关文章

适配器模式-让不兼容的接口得以适配
适配器模式将一个类的接口转换成客户期望的另一个接口，使得原本接口不兼容的类可以相互合...
策略模式-定义一个算法族
策略模式定义了一系列算法族，并封装在类中，它们之间可以互相替换，此模式让算法的变化独...
设计模式之高质量代码
设计模式讲的是如何编写可扩展、可维护、可读的高质量代码，它是针对软件开发中经常遇到的...
模板方法模式-封装一套算法流程
模板方法模式在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中，使得子类可以在...
迭代器模式-统一集合的遍历方式
迭代器模式提供了一种方法，用于遍历集合对象中的元素，而又不暴露其内部的细节。
单例模式的五种实现方式及优缺点
单例模式（Singleton Design Pattern）保证一个类只能有一个实例，并提供一个全局访问点。
组合模式-统一的处理个别对象与组合对象
组合模式可以将对象组合成树形结构来表示“整体-部分”的层次结构，使得客户可以用一致的方...
装饰者模式-动态的包装原有对象的行为
装饰者模式能够更灵活的，动态的给对象添加其它功能，而不需要修改任何现有的底层代码。
观察者模式-将消息通知给观察者
观察者模式（Observer Design Pattern）定义了对象之间的一对多依赖，当对象状态改变的时候...
代理模式-访问对象的代理而非其本身
代理模式为对象提供一个代理，来控制对该对象的访问。代理模式在不改变原始类代码的情况下...
算法设计模式多媒体技术正则表达式ElasticsearchFlinkHadoopIDE
受约束摘*day25Java常用类库置信lamda留存持续录入年后正则表达式303.17regularexpre匹多模适20130322基础理论pathmunge涵义reectok需要转义的特资源分享validationex简明魔法里弄形如源码实现完备actionscript