知识回顾

接上篇,回顾这三篇讲了什么东西

首先说明了属性的现存问题,然后介绍了依赖属性的基本用法及其解决方案,由于依赖属性以静态属性的方式存在,进而又介绍了可重写的属性元数据的使用.这是以上三篇所说明的问题.当然依赖属性的特性依然没有说完整.这两天也一直在想依赖属性,然后就是头疼,呵呵.由于WPF的依赖属性系统与整体功能都有关联,所以接下来等讲到某个特性的时候然后再来讲依赖属性.这篇我们来个简单的实践,增加点乐趣.

定义RadioButtonList和CheckBoxList

WPF内置没有这两个控件,但实际开发时,用到的会比较多.下面我们一起来创建这两个控件.

1. 明确控件需求
2. 定义依赖属性
3. 重写默认样式属性元数据
4. 用xaml定义控件样式

一.明确控件需求

控件功能如下:

1. 可以垂直,水平排列
2. 可以分行,列
3. 为子项设置Margin

二.定义依赖属性

为避免重复定义属性，为两个控件定义公共类ListControl,从ListBox继承

然后定义依赖属性

namespace WPF.Controls
{
    /// <summary>
    /// this is a base class for CheckBoxList and RadioButtonList
    /// this class define some common property
    /// </summary>
    public abstract class ListControl : ListBox
    {

        #region Orientation

        /// <summary>
        /// Gets or sets a value that indicates the dimension by which child elements are stacked.
        /// This is a dependency property.
        /// </summary>
        public Orientation Orientation
        {
            get { return (Orientation)GetValue(OrientationProperty); }
            set { SetValue(OrientationProperty, value); }
        }


        public static readonly DependencyProperty OrientationProperty =
            DependencyProperty.Register("Orientation", typeof(Orientation), typeof(ListControl),
            new UIPropertyMetadata(Orientation.Vertical, new PropertyChangedCallback(OrientationChangedCallback)));

        public static void OrientationChangedCallback(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            ListControl control = d as ListControl;
            if (control.Orientation == Orientation.Horizontal)
            {
                control.Columns = 0;
                control.Rows = 1;
            }
            else if (control.Orientation == Orientation.Vertical)
            {
                control.Rows = 0;
                control.Columns = 1;
            }
        }

        #endregion

        #region Columns

        /// <summary>
        /// Get or set a value that indicates which Columns list item should appear in.
        /// This is a dependency property.
        /// </summary>
        public int Columns
        {
            get { return (int)GetValue(ColumnsProperty); }
            set { SetValue(ColumnsProperty, value); }
        }

        public static readonly DependencyProperty ColumnsProperty =
            DependencyProperty.Register("Columns", typeof(int), typeof(ListControl), new UIPropertyMetadata(1));

        #endregion

        #region Rows

        /// <summary>
        /// Get or set a value that indicates which Rows list item should appear in.
        /// This is a dependency property.
        /// </summary>
        public int Rows
        {
            get { return (int)GetValue(RowsProperty); }
            set { SetValue(RowsProperty, value); }
        }

        public static readonly DependencyProperty RowsProperty =
            DependencyProperty.Register("Rows", typeof(int), typeof(ListControl), new UIPropertyMetadata(0));

        #endregion

        public Thickness SubMargin
        {
            get { return (Thickness)GetValue(SubMarginProperty); }
            set { SetValue(SubMarginProperty, value); }
        }

        public static readonly DependencyProperty SubMarginProperty =
            DependencyProperty.Register("SubMargin", typeof(Thickness), typeof(ListControl), 
            new UIPropertyMetadata(new Thickness(2,2,2,0)));

    }
}

以上依赖属性定义的非常简单,之所以定义成依赖属性是因为可以进行属性绑定操作.

三.重写默认样式属性元数据

/// <summary>
/// Represents a control that a user can choose one from list options in a group radiobutton
/// </summary>
public class RadioButtonList : ListControl
{
    static RadioButtonList()
    {
        DefaultStyleKeyProperty.OverrideMetadata(typeof(RadioButtonList)
            , new FrameworkPropertyMetadata(typeof(RadioButtonList)));
    }
}

/// <summary>
/// Contains a list of selectable CheckBox items 
/// Represents a control that a user can choose from a list options in a group of CheckBox
/// </summary>
public class CheckBoxList : ListControl
{
    static CheckBoxList()
    {
        DefaultStyleKeyProperty.OverrideMetadata(typeof(CheckBoxList)
            , new FrameworkPropertyMetadata(typeof(CheckBoxList)));
    }
}

四.用xaml定义控件样式

默认项目中会有一个Generic.xaml文件,我们要把样式定义在此文件中

控件样式定义

(1)ListControl

<Style TargetType="{x:Type local:ListControl}" BasedOn="{StaticResource {x:Type ListBox}}">
    <Setter Property="ItemsPanel">
        <Setter.Value>
            <ItemsPanelTemplate>
                <UniformGrid HorizontalAlignment="Left" VerticalAlignment="Top"
                    Rows="{Binding Path=Rows,RelativeSource={RelativeSource FindAncestor,AncestorType={x:Type local:ListControl}}}" 
                    Columns="{Binding Path=Columns,RelativeSource={RelativeSource FindAncestor,AncestorType={x:Type local:ListControl}}}"></UniformGrid>
            </ItemsPanelTemplate>
        </Setter.Value>
    </Setter>
    <Setter Property="BorderThickness" Value="0" />
    <Setter Property="Background" Value="Transparent" />
</Style>

<Style TargetType="{x:Type local:RadioButtonList}" BasedOn="{StaticResource {x:Type local:ListControl}}">
    <Style.Resources>
        <Style TargetType="ListBoxItem">
            <Setter Property="Margin" Value="2, 2, 2, 0" />
            <Setter Property="Template">
                <Setter.Value>
                    <ControlTemplate TargetType="ListBoxItem">
                            <RadioButton 
                                Margin="{Binding Path=SubMargin,RelativeSource={RelativeSource FindAncestor,AncestorType={x:Type local:RadioButtonList}}}"
                                IsChecked="{Binding IsSelected, RelativeSource={RelativeSource TemplatedParent},Mode=TwoWay}">
                                <RadioButton.Content>
                                    <ContentPresenter/>
                                </RadioButton.Content>
                            </RadioButton>
                    </ControlTemplate>
                </Setter.Value>
            </Setter>
        </Style>
    </Style.Resources>
</Style>

<Style TargetType="{x:Type local:CheckBoxList}" BasedOn="{StaticResource {x:Type local:ListControl}}">
    <Setter Property="SelectionMode" Value="Multiple"></Setter>
    <Style.Resources>
        <Style TargetType="ListBoxItem">
            <Setter Property="Margin" Value="2, 2, 2, 0" />
            <Setter Property="Template">
                <Setter.Value>
                    <ControlTemplate TargetType="ListBoxItem">
                            <CheckBox
                                Margin="{Binding Path=SubMargin,RelativeSource={RelativeSource FindAncestor,AncestorType={x:Type local:RadioButtonList}}}"
                                IsChecked="{Binding IsSelected, RelativeSource={RelativeSource TemplatedParent},Mode=TwoWay}">
                                <CheckBox.Content>
                                    <ContentPresenter/>
                                </CheckBox.Content>
                            </CheckBox>
                    </ControlTemplate>
                </Setter.Value>
            </Setter>
        </Style>
    </Style.Resources>
</Style>

OK,到这里就完事了.我们发现我们并不需要写多少代码,就可以实现一个控件.而且RadioButtonList和CheckBoxList几乎没有代码,仅仅只是重写了样式而已,这也是WPF定义控件的基本概念,一些变的都是如此简单.

Demo下载

评论: 4　查看评论　发表评论

最新新闻：
· Yahoo脑震荡 关闭服务汇总贴(2010-02-10 12:06)
· 2003年微软遭遇iTunes：我们彻底晕头转向了(2010-02-10 12:06)
· 百度数据能被“作弊”软件篡改？百度:追究侵权(2010-02-10 11:52)
· Ksplice为Linux提供永远不用重启服务(2010-02-10 11:51)
· 视频网站2010年格局之变：七成企业将被淘汰(2010-02-10 11:48)

编辑推荐：Google社会化产品Buzz发布会实录

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

知识回顾

接上篇,上篇我们真正接触到了依赖属性的用法,以及依赖属性的属性元数据的用法,并且也实实在在地解决了之前第二篇提到的一系列问题.来回顾一下

1. 属性默认值
2. 属性变更通知
3. 属性强制回调

本篇将继续讨论上一篇提到的问题,主题依然是属性元数据.

内容概要

1. 属性值验证
2. 默认值问题
3. 依赖属性的不变与可变
4. 属性元数据的唯一性
5. 重写属性元数据
6. 改写属性元数据

一.属性值验证

依赖属性具备属性验证的功能,其也会对依赖属性默认值进行验证,在DependencyProperty的Register方法中最后一个参数为ValidateValueCallback,用于属性值验证,如下代码

public static readonly DependencyProperty AgeProperty =
    DependencyProperty.Register("Age", typeof(int), typeof(DPCustomPeople),
    new PropertyMetadata(1), new ValidateValueCallback(AgeValidateValueCallback));

public virtual int Age
{
    get { return (int)GetValue(AgeProperty); }
    set { SetValue(AgeProperty, value); }
}

public static bool AgeValidateValueCallback(object value)
{
    int age=(int)value;
    if (age < 1) return false;
    return true;
}

ValidateValueCallback有一个传入的参数(即依赖属性值)和一个返回值(表示属性值是否是正确的).

注意:
1.当返回值为false的时候,将会抛出异常
2.不要试图在该回调方法中校正传入的值类型(即使引用类型也不符合逻辑),其主要职责在于验证.

此功能用的不是很频繁,因为返回false会抛异常,还要额外处理.再说强制回调方法也可以处理.

二.默认值问题

上一篇有讲到依赖属性的默认值问题

在构造函数里给属性赋值并不能解决问题(这是依赖属性默认值带来的额外问题,因为其是静态属性)

类继承带来的默认值重写问题,看以下代

public class RootClass
{
    public RootClass()
    {
        this.Name = "RootClass";
    }
    public string Name { get; set; }
}

public class SubClass : RootClass
{
    public SubClass()
    {
        this.Name = "SubClass";
    }
}

上面代码应该没问题,但如果这样就有问题了

public class RootClass
{
    public RootClass()
    {
        Name = "RootClass";
    }
    public static string Name { get; set; }
}

public class SubClass : RootClass
{
    public SubClass()
    {
        Name = "SubClass";
    }
}

如果是静态属性的话,子类一旦改写就会改变父类,破坏内部逻辑

那么就需要保证属性在每个类默认值的唯一性.

三.依赖属性的不变与可变

上篇有提到过这样一句话

(依赖属性)属性名字,属性类型,属性所有者类型一经注册将无法更改

这便不可变的地方,即使在子类重写也不行.
但依赖属性的默认值是可以修改的,修改的前提是保证父类的属性默认值不被影响,上篇我们有提出疑问,给默认值为什么需要属性元数据(PropertyMetadata),以下的代码也应该走的通

    public static readonly DependencyProperty NameProperty =
DependencyProperty.Register("Name", typeof(string), typeof(DPCustomPeople),
string.Empty);

是的,若依赖属性内部有一个列表维护默认值,也保证了在不同类型中默认值不会发生错误.这样的代码是没问题的,但不要忘了,还有属性变更通知和属性强制回调.PropertyMetadata把依赖属性可变的行为全部抽取出来了,我想这样做的原因可以保持依赖属性功能的清晰程度(个人猜想,但确实有这样的效果).那么就意味着我们可以重写属性元数据.

四.属性元数据的唯一性

DependencyProperty提供了OverrideMetadata方法重写属性元数据,但一个依赖属性在同一个类中不允许重写,即在同一类型中,保证属性元数据在依赖属性中的唯一性,如下代码是错误的

public class DPCategory : DependencyObject
{
    public static readonly DependencyProperty NameProperty =
           DependencyProperty.Register("Name", typeof(string), typeof(DPCategory),
           new PropertyMetadata(string.Empty));

    public void TestOverrideMetadata()
    {
        //wrong
        NameProperty.OverrideMetadata(typeof(DPCategory), new PropertyMetadata("WPF"));
    }
}

将会抛出异常

五.重写属性元数据

继承的子类允许重写属性元数据,如下代码

public class DPWPFCategory : DPCategory
{
    public void TestOverrideMetadata()
    {
        NameProperty.OverrideMetadata(typeof(DPWPFCategory), new PropertyMetadata("WPF"));
        Console.WriteLine(NameProperty.GetMetadata(typeof(DPWPFCategory)).DefaultValue);
        //output 30
    }
}

注意:在重写属性元数据时,应该要知道一下规则.
1.重写元数据是一个以重写元数据为主的合并的过程,即子类的重写后的元数据会与父类的进行合并

我们在父类定义一个Group的依赖属性

public string Group
{
    get { return (string)GetValue(GroupProperty); }
    set { SetValue(GroupProperty, value); }
}
public static readonly DependencyProperty GroupProperty =
    DependencyProperty.Register("Group", typeof(string), typeof(DPCategory), 
    new PropertyMetadata(string.Empty,new PropertyChangedCallback(GroupPropertyChangedCallback)));

public static void GroupPropertyChangedCallback(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
    Console.WriteLine(e.NewValue);
}

然后在子类重写此依赖属性的元数据

public void TestOverrideMergeMetadata()
{
    GroupProperty.OverrideMetadata(typeof(DPWPFCategory), new PropertyMetadata("Computer Technology"));
    Console.WriteLine(this.Group);
    this.Group = "Technology";
}

输出结果,当属性值发生变化时,父类的属性变更通知回调方法就会触发

2.实例匹配(Type.IsAssignableFrom 返回为true)

注意:要重写的父类属性元数据类型必须要是重写的属性元数据的父类或者与之类型相同.如下为属性元数据的继承关系

可以看出如果用FrameworkPropertyMetadata来重写的话是最保险的

如下示例

public int Order
{
    get { return (int)GetValue(OrderProperty); }
    set { SetValue(OrderProperty, value); }
}

public static readonly DependencyProperty OrderProperty =
    DependencyProperty.Register("Order", typeof(int), typeof(DPCategory), new UIPropertyMetadata(0));
//UIPropertyMetadata

注意父类的属性元数据为UIPropertyMetadata,以下子类重写的属性元数据类型为PropertyMetadata 即会报错.

public void TestOverrideDriveMetadata()
{
    OrderProperty.OverrideMetadata(typeof(DPWPFCategory), new PropertyMetadata(1));
    //wrong
    //must >=UIPropertyMetadata
}

输出

六.改写属性元数据

改写与重写有几点不同.

1. 改写是将已存在的依赖属性添加到不同类型当中
2. 改写不是一个合并属性元数据的过程,改写后的是全新的

如下:
为一个全新的类型添加已有依赖属性,并重写属性元数据,重写后将不会触发DPCategory类型的GroupProperty属性变更通知,不会影响原依赖属性逻辑

public class DPGroup:DependencyObject
{
    public static readonly DependencyProperty GroupProperty =
    DPCategory.GroupProperty.AddOwner(typeof(DPGroup),
    new PropertyMetadata("Technology"));
    public string Group
    {
        get { return (string)GetValue(GroupProperty); }
        set { SetValue(GroupProperty, value); }
    }

    public void TestAddOwnerMetadata()
    {
        Console.WriteLine(Group);
        this.Group = "Computer Technology";
    }
}

注意:如果在子类进行此操作，将与重写效果一样

本篇主要讲到了属性元数据的一些特点及注意点.FrameworkPropertyMetadata还有许多特性,但必须有实际场景结合.所以这里无法展开.讲了这么多貌似都没触及到WPF什么事,这部分也是比较枯燥,但却非常重要.下篇继续,然后依赖属性就告一段落.

Demo下载

评论: 5　查看评论　发表评论

最新新闻：
· Yahoo脑震荡 关闭服务汇总贴(2010-02-10 12:06)
· 2003年微软遭遇iTunes：我们彻底晕头转向了(2010-02-10 12:06)
· 百度数据能被“作弊”软件篡改？百度:追究侵权(2010-02-10 11:52)
· Ksplice为Linux提供永远不用重启服务(2010-02-10 11:51)
· 视频网站2010年格局之变：七成企业将被淘汰(2010-02-10 11:48)

编辑推荐：Google社会化产品Buzz发布会实录

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

    上篇说明了属性存在的一系列问题.

1. 属性默认值,可以保证属性的有效性.
2. 属性验证有效性,可以对输入的属性进行校验
3. 属性强制回调, 即不管属性有无发生变化,都要做出通知.
4. 属性变更通知,当属性发生变化可以通知程序作出一系列的处理.

这里还没WPF什么事,我们来看看依赖属性是如何解决以上问题的.

内容概要

• 定义第一个最简单的依赖属性
• 依赖属性值基本操作
• 属性包装器
• 属性元数据(PropertyMetadata)
• 属性元数据基本行为

MSDN的原话虽然生硬,但准确定性毋庸置疑.当理解后再来看别有一番体会.

一.定义第一个最简单的依赖属性

MSDN原话:Windows Presentation Foundation (WPF) 提供了一组服务，这些服务可用于扩展公共语言运行时 (CLR) 属性的功能。这些服务通常统称为 WPF 属性系统。由 WPF 属性系统支持的属性称为依赖项属性。
我们来定义一个Age依赖属性,如下代码

public class DPCustomPeople
{
    public static readonly DependencyProperty AgeProperty =
        DependencyProperty.Register("Age", typeof(int), typeof(DPCustomPeople));

    public void DisplayAgeProperty()
    {
        Console.WriteLine("DPName:" + DPCustomPeople.AgeProperty.Name);
        Console.WriteLine("DPPropertyType:" + DPCustomPeople.AgeProperty.PropertyType);
        Console.WriteLine("DPOwnerType:" + DPCustomPeople.AgeProperty.OwnerType);
    }
}

然后调用输出结果

class Program
{
    static void Main(string[] args)
    {
        DPCustomPeople people = new DPCustomPeople();
        people.DisplayAgeProperty();
    }
}

你可能对DependencyProperty类比较陌生,DependencyProperty类提供了依赖属性的一些基本特征

注册依赖属性的方法是调用DependencyProperty的静态Register方法,其提供了多个重载方法,但以下三个步骤是必须的.注册完毕是其是一个静态属性

1. 提供注册的名字(Name)"Age"
2. 注册属性类型(PropertyType)typeof(int)
3. 注册该依赖属性的所有者类型(OwnerType)typeof(DPCustomPeople)

注意:属性名字,属性类型,属性所有者类型一经注册将无法更改

以下为输出结果

二.依赖属性值基本操作(取值与赋值)

定义了Age依赖属性以后,那么我们理应可以对属性进行取值,赋值操作.DependencyProperty本身并不提供这些操作,而是由DependencyObject来负责

DependencyObject 表示一个参与依赖项属性系统的对象.

所以要求定义的类要继承自DependencyObject,那么改写DPCustomPeople

public class DPCustomPeople:System.Windows.DependencyObject
{
}

基本的取值赋值操作GetValue和SetValue方法

public void DPPropertyBasicOperator()
{
    Console.WriteLine("Age:" + this.GetValue(DPCustomPeople.AgeProperty));
    this.SetValue(DPCustomPeople.AgeProperty, 24);
    Console.WriteLine("ChangedAge:" + this.GetValue(DPCustomPeople.AgeProperty));
}

输出结果

三.属性包装器

用GetValue和SetValue方法对值操作不大美观,所以我们可以对其包装一下,定义Age属性

public int Age
{
    get { return (int)GetValue(AgeProperty); }
    set { SetValue(AgeProperty, value); }
}

注意:依赖属性包装命名规是把后面的Property去掉

public void DPPropertyBasicOperatorUsingProperty()
{
    Console.WriteLine("Age:" + this.Age);
    this.Age=24;
    Console.WriteLine("ChangedAge:" + this.Age);
}

以上的代码看起来是不是更加的简洁呢

四.属性元数据(PropertyMetadata)

MSDN原话:Windows Presentation Foundation (WPF) 属性系统包括一个元数据报告系统，该系统不局限于可以通过反射或常规公共语言运行时 (CLR) 特征报告的关于某个属性的内容。

说到属性元数据,第一个让人想到的就是.net的Attribute

public class Person
{
    [DefaultValue(200),Category("Layout")]
    public int Width { get; set; }
}

Attribute需要借助Visual Studio的力量,使得IDE对Attribute进行很友好的支持,或者依靠反射来赋值.

但离开这些技术的,通过正常途径,new出一个新的实例,加了Attribute的属性毫无效果.我们不能依赖这些Attribute来保证属性的一些基本特性(如默认值).依赖属性的属性元数据与上述描述的元数据不同.

依赖项属性的元数据

1. 可以由定义依赖项属性的类来唯一地指定
2. 可以在依赖项属性添加到另一个类时进行更改
3. 可以由所有从定义基类继承依赖项属性的派生类来明确地重写

以上语言很生硬，但却说明了意图.但我们总无法第一时间领会设计者的想法.暂且先知道有这个概念的存在

五.属性元数据基本行为

属性元数据基本行为为依赖属性提供了3个功能,这也是本文刚提出来的问题.

1. 默认属性
2. 属性通知
3. 属性强制回调

先来看一看一个完整PropertyMetadata的构造函数,如果没有为依赖属性设置默认的PropertyMetadata的话,内部会为依赖属性自动创建一个PropertyMetadata对象.

public PropertyMetadata(object defaultValue, PropertyChangedCallback propertyChangedCallback, CoerceValueCallback coerceValueCallback)

依赖属性借用属性元数据的概念来完成属性默认值,属性通知,强制回调等行为

1.属性默认值

public static readonly DependencyProperty NameProperty =
    DependencyProperty.Register("Name", typeof(string), typeof(DPCustomPeople), 
    new PropertyMetadata(string.Empty));

大部分人看到此处都会产生一个疑问,设置一个默认值为什么要用PropertyMetadata,为什么不直接在Register方法中直接注册呢?如下代码

public static readonly DependencyProperty NameProperty =
    DependencyProperty.Register("Name", typeof(string), typeof(DPCustomPeople),
    string.Empty);

当然这个疑问一直伴随着我很久,解不开也是没办法,先放着.

注意点:当在PropertyMetadata给属性赋默认值时,是无法检测类型正确性的

如这样的定义,因为vs中的dp代码段默认值是0,这是值得注意的地方

public static readonly DependencyProperty NameProperty =
    DependencyProperty.Register("Name", typeof(string), typeof(DPCustomPeople), 
    new UIPropertyMetadata(0));

2.属性默认值恢复操作

当属性赋值以后可以通过DependencyObject的ClearValue方法恢复默认值,如下代码

public string Name
{
    get { return (string)GetValue(NameProperty); }
    set { SetValue(NameProperty, value); }
}

public static readonly DependencyProperty NameProperty =
    DependencyProperty.Register("Name", typeof(string), typeof(DPCustomPeople), 
    new UIPropertyMetadata(string.Empty));

public void DPPropertyClearOperator()
{
    Console.WriteLine("Name:" + this.Name);
    this.Name="Terry";
    Console.WriteLine("ChangedName:" + this.Name);
    this.ClearValue(NameProperty);
    Console.WriteLine("Name:" + this.Name);
}

输出结果

注意点:区分默认赋值与默认值

默认赋值一般在构造函数中进行,但这却不是默认值(在依赖属性出现之前这的确是),特别是在派生类重写属性的时候

public class Student : DPCustomPeople
{
    public Student()
    {
        this.Name = "Sky";
    }

    public void TestSubDefaultDpValue()
    {
        Console.WriteLine("Clear Before:"+this.Name);
        this.ClearValue(Student.NameProperty);
        Console.WriteLine("Clear After:" + this.Name);
    }
}

输出结果

3.属性变更通知

这项功能是最常用的.当属性值发生变化时,会触发PropertyChangedCallback回调

public bool IsBoy
{
    get { return (bool)GetValue(IsBoyProperty); }
    set { SetValue(IsBoyProperty, value); }
}

public static readonly DependencyProperty IsBoyProperty =
    DependencyProperty.Register("IsBoy", typeof(bool), typeof(Student), 
    new UIPropertyMetadata(false,new PropertyChangedCallback(IsBoyPropertyChangedCallback)));

public static void IsBoyPropertyChangedCallback(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
    Student st = d as Student;
    if (st.IsBoy)
    {
        Console.WriteLine("Hello,Boy");
    }
    else
    {
        Console.WriteLine("Hello,Girl");
    }
}

public void TestPropertyChangedCallback()
{
    this.IsBoy = false;
    this.IsBoy = true;
    this.IsBoy = true; 
}

可以通过DependencyPropertyChangedEventArgs来查看旧值和新值
输出结果

注意点:

(1).通过上面的输出结果,你是否已经看出依赖属性的默认值是不会触发属性变更通知的

(2).手动触发属性变更通知

如果你希望默认值也能触发一次属性变更(其实有时候真的需要),你就不等不手动进行触发了

private void RaiseIsBoyPropertyChangedCallback()
{
    IsBoyPropertyChangedCallback(this,new DependencyPropertyChangedEventArgs
        (Student.IsBoyProperty, Student.IsBoyProperty.DefaultMetadata.DefaultValue, null));
}

(3).当有属性变更通知时,一定要保证属性默认值类型的正确性

我们知道值类型都有是默认值的,引用类型则没有(即可以赋值为null),一个类型是否有默认类型可以用default关键字查看.如下图

我们将上面定义的依赖属性默认值改写null,在没有PropertyChangedCallback的时候可以很好的运行,但在有属性变更通知的时候灾难发生了,程序将出现异常,说类型不匹配.

public static readonly DependencyProperty IsBoyProperty =
    DependencyProperty.Register("IsBoy", typeof(bool), typeof(Student), 
    new UIPropertyMetadata(null,new PropertyChangedCallback(IsBoyPropertyChangedCallback)));

再来看看引用类型,默认值为null则相安无事

public IList LovedGirl
{
    get { return (IList)GetValue(LovedGirlProperty); }
    set { SetValue(LovedGirlProperty, value); }
}

public static readonly DependencyProperty LovedGirlProperty =
    DependencyProperty.Register("LovedGirl", typeof(IList), typeof(Student),
    new UIPropertyMetadata(null, new PropertyChangedCallback(LovedGirlChangedCallback)));

public static void LovedGirlChangedCallback(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
    Student st = d as Student;
    foreach (var item in e.NewValue as IList)
    {
        Console.WriteLine(item);
    }
}

public void TestReferenceDpType()
{
    List<string> list = new List<string>();
    list.Add("girl 1");
    list.Add("girl 2");
    this.LovedGirl = list;
}

4.强制属性回调

首先默认值还是不会触发回调方法.

强制回调方法即不管属性值有无发生变化,都会进入回调方法

public int Score
{
    get { return (int)GetValue(ScoreProperty); }
    set { SetValue(ScoreProperty, value); }
}

public static readonly DependencyProperty ScoreProperty =
    DependencyProperty.Register("Score", typeof(int), typeof(Student), 
    new UIPropertyMetadata(0,null,new CoerceValueCallback(ScoreCoerceValueCallback)));

public static object ScoreCoerceValueCallback(DependencyObject d, object baseValue)
{
    Console.WriteLine(baseValue);
    return baseValue;
}

public void TestCoerceValueCallback()
{
    this.Score = 0;
    this.Score = 0;
    this.Score = 0;
}

好了,本篇主要介绍了依赖属性的注册方法以及依赖属性的属性元数据用法.下篇继续

Demo下载

评论: 0　查看评论　发表评论

最新新闻：
· Yahoo脑震荡 关闭服务汇总贴(2010-02-10 12:06)
· 2003年微软遭遇iTunes：我们彻底晕头转向了(2010-02-10 12:06)
· 百度数据能被“作弊”软件篡改？百度:追究侵权(2010-02-10 11:52)
· Ksplice为Linux提供永远不用重启服务(2010-02-10 11:51)
· 视频网站2010年格局之变：七成企业将被淘汰(2010-02-10 11:48)

编辑推荐：Google社会化产品Buzz发布会实录

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

     距离上篇写的时间有1年多了.wpf太大,写的东西实在太多,我将依然围绕着自定义控件来展开与其相关的技术点. 也欢迎大家参与讨论.这篇我们将要讨论的是WPF依赖属性,接触过的朋友应该对其有所了解,但在我们讲WPF依赖属性之前,我们来看看在WPF出现之前.net中的属性是如何使用的.

普遍存在的属性问题

• c#基本属性
• ASP.NET自定义控件属性
• WinForm自定义控件属性
• Javascript自定义控件属性

c#基本属性

namespace WPFControlTutorialPart2_Basic
{
    public class Person
    {
        private string _name;
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }
        //自动属性
      public int Age { get; set; }
    }
}

上面应该算是c#的最基础的属性,大家都很熟悉.

注意点:默认属性没有初始化,不然可能会发生很多未知的错误.

(以下可以选看,如果你接触过以下技术的话,其实也很简单)

ASP.NET自定义控件属性

namespace WPFControlTutorialPart2_WebApp
{
    public class WebFromControl : WebControl
    {
        private string _controlName;
        public string ControlName
        {
            get
            {
                return _controlName;
            }
            set
            {
                _controlName = value;
            }
        }

        protected override void RenderContents(HtmlTextWriter output)
        {
            output.Write("控件名字是:"+ControlName);
        }
    }
}

上面是一个简单的自定义的Web服务器控件.

asp.net控件着重在于呈现,每次刷新页面都将会调用RenderContents方法,这样就不管属性有没发生变化,都将得到重新呈现.即此处不需要属性发生变化,进行UI重绘通知.

注意点:如果强制要求ControlName属性必须是有值的,以保证输入结果的有效性,那么可以在get方法里处理

get
{
    if (_controlName == null) _controlName = string.Empty;
    return _controlName;
}

WinForm自定义控件属性

当属性发生变化时并未重绘,必须手动调用Invalidate方法以进入OnPaint方法重绘

注意点:如果要重绘界面的话,必须手动调用方法

JavaScript自定义控件属性

<div id="demoDiv" style="background-color: Red">hello</div>

<script>
    function ElementControl(elementName) {
        this.element = document.getElementById(elementName);
    }
    ElementControl.prototype.setWidth = function(width) {
        this.element.style.width = width;
    }
    var obj = new ElementControl("demoDiv");
    obj.setWidth("hello");
   
</script>

javascript的变量类型没有强类型,比如设置dom的宽度,其类型只能是整型,如果以字符串进行传值的话将会出错(当然这是人为的).

(不知道做过js前端控件的人有没这种感觉,定义了一个属性然后重新赋值重绘控件是一件痛苦的事,必须手动调动,而且会影响整个控件设计.)

注意点:要对于属性的赋值的有效性进行验证.

从以上几个例子,我们可以看出单纯的属性是无法满足程序需求的.
既以上的需求是有必要的,并且常常发生,而且非常频繁.

标准化解决方案

以上介绍了属性存在的一系列问题,那么有问题就会有简化的方案.

以下是个人总结的话

1. 当一项技术比较复杂的时候,就会有人出来定义一套标准,以简化技术,提高生产效率.
2. 不管设计者考虑的如何周密,一旦标准定义下来,就会丧失灵活性.
3. 标准可能与你个人习惯想冲突,你必须去学会接受标准

回到WPF话题,那么在WPF中这个解决方案就是依赖属性(DependencyProperty)

好了,这篇只是一个引子,如果你在使用属性时,遇到过这些问题,那么你将有所感触.

如果你有认识到属性真实存在以上问题,那么这篇文章就算完成任务了.

这篇并不打算展开.下篇将再次介绍WPF依赖属性系统

欢迎大家展开讨论.

Demo下载

评论: 2　查看评论　发表评论

最新新闻：
· Yahoo脑震荡 关闭服务汇总贴(2010-02-10 12:06)
· 2003年微软遭遇iTunes：我们彻底晕头转向了(2010-02-10 12:06)
· 百度数据能被“作弊”软件篡改？百度:追究侵权(2010-02-10 11:52)
· Ksplice为Linux提供永远不用重启服务(2010-02-10 11:51)
· 视频网站2010年格局之变：七成企业将被淘汰(2010-02-10 11:48)

编辑推荐：Google社会化产品Buzz发布会实录

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

   只为记忆更加深刻

如果程序变的不是非常枯燥乏味,学的人就会有兴趣很多,学ui就是一种.虽然学ui只是起步,但足够增加对学习的信心,也为后续打下基础.

有些人喜欢先探秘,比如先看深入浅出浅出MFC,我一直以来的想法是先学后用,如果连用都用不好，我想我也并不具备设计框架的能力.只有知道框架要做什么事情以后,自然自己心中会提出疑问.

Hello World程序

// Define a window class derived from CFrameWnd
class CHelloWindow : public CFrameWnd
{
public:
    CHelloWindow()
        { Create(NULL, _T("Hello World!"), WS_OVERLAPPEDWINDOW, rectDefault); }
};

#endif

// Define an application class derived from CWinApp
class CHelloApp : public CWinApp
{
public:
    virtual BOOL InitInstance()
    {
        m_pMainWnd = new CHelloWindow();
        m_pMainWnd->ShowWindow(SW_SHOWNA);
        m_pMainWnd->UpdateWindow();
        return TRUE;
    }
};

CHelloApp HelloApp;  // HelloApp's constructor initializes and runs the app

上面这段程序,实现了一个最简单的MFC程序,作为.net程序员,总是喜欢与.net中winfrom或者wpf进行比较.

CFrameWnd可以理解为窗体的基类

CWinApp 程序入口点,用于管理应用程序

virtual BOOL Create(
   LPCTSTR lpszClassName,
   LPCTSTR lpszWindowName,
   DWORD dwStyle = WS_OVERLAPPEDWINDOW,
   const RECT& rect = rectDefault,
   CWnd* pParentWnd = NULL,
   LPCTSTR lpszMenuName = NULL,
   DWORD dwExStyle = 0,
   CCreateContext* pContext = NULL 
);

一个最简单的窗体需要在构造函数中调用Create方法用于创建和初始化窗体的一些参数,即必须提供基本窗体参数,c++具备函数默认参数功能,所以最简单的只需要提供两个参数即可,其他参数随着时间的增长自然会熟悉,不需要去强记.

c++风格的参数选择

在c#中,习惯于使用枚举进行同一项的参数选择,但c++则喜欢定义常量,当然其实其他语言也这么做,相对而言,个人认为枚举的做法更加优雅.所以看c++程序需要接受这种风格,而且将会大量出现

注意new

写c#程序new一个对象是非常正常的,c++的new就是申请内存,必须要删除掉的,没有GC,一看到new就要注意了。默认情况下,一个对象的初始化是不需要用new的，只需要声明,这是最大的区别,刚开始会看起来不习惯,看多了就好了，这是最大的注意点.

初始化程序

InitInstance方法提供了接口进行程序初始化,声明了一个窗体,并显示.

m_pMainWnd = new CHelloWindow();
m_pMainWnd->ShowWindow(SW_SHOWNA);
m_pMainWnd->UpdateWindow();

ShowWindow用于设定窗体初始化的状态，并不是真正Show,奇怪为何不命名SetShowWindowState这样的方法,让人误解.来看下参数的定义,均是这种风格.不查文档或者不熟悉源码，基本就不知道他们的存在…如果改成枚举就可以SW.xxxx了.很厌恶…

/*
 * ShowWindow() Commands
 */
#define SW_HIDE             0
#define SW_SHOWNORMAL       1
#define SW_NORMAL           1
#define SW_SHOWMINIMIZED    2
#define SW_SHOWMAXIMIZED    3
#define SW_MAXIMIZE         3
#define SW_SHOWNOACTIVATE   4
#define SW_SHOW             5
#define SW_MINIMIZE         6
#define SW_SHOWMINNOACTIVE  7
#define SW_SHOWNA           8
#define SW_RESTORE          9
#define SW_SHOWDEFAULT      10
#define SW_FORCEMINIMIZE    11
#define SW_MAX              11

UpdateWindow方法将会重绘窗体,呈现窗体.调用此方法将会触发ON_WM_PAINT消息.

注意c#很容易捕获一个事件,MFC与win32则称这些事件为消息，因为windows事件就是基于消息.所以两者概念上几乎是相同,说法不同,当然我更喜欢说事件.但不得不说消息:).

消息映射

在没有封装的情况下,默认捕获消息是用switch来判断的,很不方便,MFC通过消息映射机制来简化了这一操作.比如下面代码

BEGIN_MESSAGE_MAP( CMainWindow, CFrameWnd )
    //{{AFX_MSG_MAP( CMainWindow )
    ON_WM_PAINT()
    //}}AFX_MSG_MAP
END_MESSAGE_MAP()

BEGIN_MESSAGE_MAP和END_MESSAGE_MAP用于声明消息的触发回调方法,(.net则更简单,直接重写即可)然后重写方法

void CMainWindow::OnPaint()
{
    CRect rect;
    GetClientRect(rect);

    CPaintDC dc(this);

    dc.DrawText (_T ("Hello, MFC"), -1, rect,
        DT_SINGLELINE | DT_CENTER | DT_VCENTER);
    
}

以上用GDI在窗体中间画了一段文字

对象获取方法

在.net中若获取一个对象则,直接调函数返回,如 IList list=object.GetList();

到了c++这里则变成 IList list;GetLisht(&list);这种风格也非常的多,这可能就是语言特性决定的做法.需要特别的注意.

这样一个简单的MFC程序就完成了

评论: 0　查看评论　发表评论

最新新闻：
· Yahoo脑震荡 关闭服务汇总贴(2010-02-10 12:06)
· 2003年微软遭遇iTunes：我们彻底晕头转向了(2010-02-10 12:06)
· 百度数据能被“作弊”软件篡改？百度:追究侵权(2010-02-10 11:52)
· Ksplice为Linux提供永远不用重启服务(2010-02-10 11:51)
· 视频网站2010年格局之变：七成企业将被淘汰(2010-02-10 11:48)

编辑推荐：Google社会化产品Buzz发布会实录

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

  菜单以资源的形式出现,并以框架内置固定的位置出现

首先在资源面板里创建菜单

载入菜单

1.在Create方法中传入菜单

IDR_MAINFRAME为资源的Id,MAKEINTRESOURCE用于转换资源

this->Create(NULL,_T("Hello MFC"),WS_POPUPWINDOW,rectDefault,NULL,MAKEINTRESOURCE(IDR_MAINFRAME));

2.也可以用LoadFrame方法载入资源并创建窗体,资源ID是可以重复的,若在字符串中定义IDR_MAINFRAME，则成为标题.

注意:两方法不能同时使用,也不知道做了啥封装

3.编程方式

CMenu menu;
menu.LoadMenu(IDR_MAINFRAME);
SetMenu(&menu);
menu.Detach();

声明CMenu对象,然后手动根据ID号载入,然后调用SetMenu方法设置

4.重绘菜单

当有两个菜单的时候,替换的时候必须调用DrawMenuBar以重新绘制菜单

CMenu menu;
menu.LoadMenu(IDR_MENU1);
SetMenu(&menu);
menu.Detach();
DrawMenuBar();

5.菜单命令映射,用ON_COMMAND消息映射,ID_APP_ABOUT为菜单Id,OnAbout为对应的触发方法

ON_COMMAND(ID_APP_ABOUT, OnAbout)

6.更新菜单项

可以用GetMenu方法当前选择的Menu,通过ON_UPDATE_COMMAND_UI消息映射,来更新菜单

评论: 0　查看评论　发表评论

最新新闻：
· Yahoo脑震荡 关闭服务汇总贴(2010-02-10 12:06)
· 2003年微软遭遇iTunes：我们彻底晕头转向了(2010-02-10 12:06)
· 百度数据能被“作弊”软件篡改？百度:追究侵权(2010-02-10 11:52)
· Ksplice为Linux提供永远不用重启服务(2010-02-10 11:51)
· 视频网站2010年格局之变：七成企业将被淘汰(2010-02-10 11:48)

编辑推荐：Google社会化产品Buzz发布会实录

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

   http://caliburn.codeplex.com/wikipage?title=Dependent%20Actions&referringTitle=Documentation

   这一部分功能也属于过滤器.再来看两个接口

FilterManager会在构造函数中,对实现该接口的Filter进行初始化

public interface IInitializable : IFilter
{
    /// <summary>
    /// Initializes the filter.
    /// </summary>
    /// <param name="targetType">Type of the target.</param>
    /// <param name="metadataContainer">The metadata container.</param>
    /// <param name="serviceLocator">The serviceLocator.</param>
    void Initialize(Type targetType, IMetadataContainer metadataContainer, IServiceLocator serviceLocator);
}

public FilterManager(Type targetType, IMetadataContainer metadataContainer, IServiceLocator serviceLocator)
{
…
    filters.OfType<IInitializable>()
        .Apply(x => x.Initialize(targetType, metadataContainer, serviceLocator));

…
}

IHandlerAware用来实现对事件的监听

public interface IHandlerAware : IFilter
{
    /// <summary>
    /// Makes the filter aware of the <see cref="IRoutedMessageHandler"/>.
    /// </summary>
    /// <param name="messageHandler">The message handler.</param>
    void MakeAwareOf(IRoutedMessageHandler messageHandler);

    /// <summary>
    /// Makes the filter aware of the <see cref="IMessageTrigger"/>.
    /// </summary>
    /// <param name="messageHandler">The message handler.</param>
    /// <param name="trigger">The trigger.</param>
    void MakeAwareOf(IRoutedMessageHandler messageHandler, IMessageTrigger trigger);
}

如DependenciesAttribute的实现,DependencyObserver对实现INotifyPropertyChanged的对象进行了监听.

public void MakeAwareOf(IRoutedMessageHandler messageHandler)
{
    var notifier = messageHandler.Unwrap() as INotifyPropertyChanged;
    if (notifier == null) return;

    var helper = messageHandler.GetMetadata<DependencyObserver>();
    if (helper != null) return;

    helper = new DependencyObserver(messageHandler, notifier);
    messageHandler.AddMetadata(helper);
}

然后在wpf元素初始化后,再次调用,添加事件

public void MakeAwareOf(IRoutedMessageHandler messageHandler, IMessageTrigger trigger)
{
    var helper = messageHandler.GetMetadata<DependencyObserver>();
    if (helper == null) return;

    if(trigger.Message.RelatesTo(_target))
        helper.MakeAwareOf(trigger, _dependencies);
}

DependencyObserver的MakeAwareOf.本质上海还是添加了MessageTrigger

public void MakeAwareOf(IMessageTrigger trigger, IEnumerable<string> dependencies)
{
    foreach (var dependency in dependencies)
    {
        IList<IMessageTrigger> triggers;
       
        if(!_triggersToNotify.TryGetValue(dependency, out triggers))
        {
            triggers = new List<IMessageTrigger>();
            _triggersToNotify[dependency] = triggers;
        }       
        if(!triggers.Contains(trigger))
            triggers.Add(trigger);
    }
}

评论: 0　查看评论　发表评论

最新新闻：
· Yahoo脑震荡 关闭服务汇总贴(2010-02-10 12:06)
· 2003年微软遭遇iTunes：我们彻底晕头转向了(2010-02-10 12:06)
· 百度数据能被“作弊”软件篡改？百度:追究侵权(2010-02-10 11:52)
· Ksplice为Linux提供永远不用重启服务(2010-02-10 11:51)
· 视频网站2010年格局之变：七成企业将被淘汰(2010-02-10 11:48)

编辑推荐：Google社会化产品Buzz发布会实录

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

     过滤器用于装饰对象本身和对象中的方法.如下图

具体介绍可见此

http://caliburn.codeplex.com/wikipage?title=Filters&referringTitle=Documentation

IFilterManager

IFilterManager接口为过滤器管理器,用于存放过滤器接口,每个Action都有一个过滤器管理器

1.IRescue

捕获错误

public class Calculator
{

    [Rescue(Priority=1)]
    public int Divide(int left, int right)
    {
        throw new Exception("error");
        return left / right;
    }
}

2.IPreProcessor

在Action触发之前触发或阻止Action触发

3.IPostProcessor

在Action触发之后触发

public class PreProcessorAttribute : Attribute, IPreProcessor
   {
       #region IPreProcessor Members

       public bool AffectsTriggers
       {
           get { return true; }
       }

       public bool Execute(IRoutedMessage message, IInteractionNode handlingNode, object[] parameters)
       {
           Console.WriteLine("PreProcessor");
           return true;
       }

       #endregion

       #region IFilter Members

       public int Priority
       {
           get { return 1; }
       }

       #endregion
   }

   public class PostProcessorAttribute : Attribute, IPostProcessor
   {

       #region IPostProcessor Members

       public void Execute(IRoutedMessage message, IInteractionNode handlingNode, MessageProcessingOutcome outcome)
       {
           Console.WriteLine("PostProcessor");
       }

       #endregion

       #region IFilter Members

       public int Priority { get; set; }

       #endregion
   }

看下执行结果

[PreProcessorAttribute()]
[PostProcessorAttribute()]
public int Divide(int left, int right)
{
    Console.WriteLine("Action");
    return left / right;
}

过滤器与Action是密切相关的,我们可以来看下Action内部的实现,看下面代码,上面的流程就非常的清晰了

public override void Execute(ActionMessage actionMessage, IInteractionNode handlingNode, object context)
{
    try
    {
        var parameters = _messageBinder.DetermineParameters(
            actionMessage,
            _requirements,
            handlingNode,
            context
            );

        foreach (var filter in _filters.PreProcessors)
        {
            if (!filter.Execute(actionMessage, handlingNode, parameters)) return;
        }

        var outcome = new MessageProcessingOutcome(
            _method.Invoke(handlingNode.MessageHandler.Unwrap(), parameters),
            _method.Info.ReturnType,
            false
            );

        foreach (var filter in _filters.PostProcessors)
        {
            filter.Execute(actionMessage, handlingNode, outcome);
        }

        HandleOutcome(actionMessage, handlingNode, outcome);
    }
    catch (Exception ex)
    {
        if(!TryApplyRescue(actionMessage, handlingNode, ex))
            throw;
        OnCompleted();
    }
}

可以使用以上特性定义自己需要的过滤器,建议不要重新定义Action,若要这么做的话就需要管理好过滤器的生命周期,或者有意更改生命周期

评论: 0　查看评论　发表评论

最新新闻：
· Yahoo脑震荡 关闭服务汇总贴(2010-02-10 12:06)
· 2003年微软遭遇iTunes：我们彻底晕头转向了(2010-02-10 12:06)
· 百度数据能被“作弊”软件篡改？百度:追究侵权(2010-02-10 11:52)
· Ksplice为Linux提供永远不用重启服务(2010-02-10 11:51)
· 视频网站2010年格局之变：七成企业将被淘汰(2010-02-10 11:48)

编辑推荐：Google社会化产品Buzz发布会实录

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

参考与此http://caliburn.codeplex.com/wikipage?title=Auto-Registering%20Components&referringTitle=Documentation

    此为基础,看了没用,不看不行…了解下注册流程.

注册组件,差不多离不开这几种模式

1. 手动注册
2. 元数据标签注册
3. 外部dll加载注册

1.内置服务则用手动注册.

2.挂元数据标签,如下

[PerRequest(typeof(IHomePresenter))]
public class HomePresenter : Presenter, IHomePresenter
{
}

以前不是推荐此种做法的,标签会产生框架耦合,但框架用都用了，内置demo使用此方法最多,之前用的是手动注册,框架会去dll中寻找挂此标签的对象然后自动注册.

3.外部dll加载

重写CaliburnApplication的SelectAssemblies方法

protected override System.Reflection.Assembly[] SelectAssemblies()
{
    return new[] { Assembly.GetEntryAssembly(),typeof(Caliburn.WPF.ApplicationFramework.Bind).Assembly};
}

private void InspectAssembly(Assembly assembly, ICollection<ComponentInfo> componentList, ICollection<Type> configs)
{
    var types = assembly.GetExportedTypes();

    foreach (var type in types)
    {
        foreach (var attribute in type.GetCustomAttributes(true).OfType<RegisterAttribute>())
            componentList.Add(attribute.GetComponentInfo(type));
    }

    foreach (var type in types)
    {
        if(_configType.IsAssignableFrom(type) && !type.IsAbstract)
            configs.Add(type);
    }
}

总的来说，我们只要加载dll，挂上标签就可以自动注册了

内置服务+自定义服务注册好以后,接下来的任务就是注册实例.即组件的生命周期状况.内置都为Singleton

/// <summary>
/// The lifetime of a Caliburn component.
/// </summary>
public enum ComponentLifetime
{
    /// <summary>
    /// One instance per application.
    /// </summary>
    Singleton,
    /// <summary>
    /// A new instance is created on each request.
    /// </summary>
    PerRequest,
    /// <summary>
    /// A new instance is created per custom lifetime rules.
    /// </summary>
    Custom
}

可以通过重写ConfigureWith方法,使用第三方容器来注册服务,当然其内置也提供了一个较为简单的容器

新版本可能会更新,所以不去研究它了

评论: 0　查看评论　发表评论

最新新闻：
· Yahoo脑震荡 关闭服务汇总贴(2010-02-10 12:06)
· 2003年微软遭遇iTunes：我们彻底晕头转向了(2010-02-10 12:06)
· 百度数据能被“作弊”软件篡改？百度:追究侵权(2010-02-10 11:52)
· Ksplice为Linux提供永远不用重启服务(2010-02-10 11:51)
· 视频网站2010年格局之变：七成企业将被淘汰(2010-02-10 11:48)

编辑推荐：Google社会化产品Buzz发布会实录

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

http://caliburn.codeplex.com/wikipage?title=Action%20Basics&referringTitle=Documentation

public void Demo()
{
    MessageBox.Show("hello");
}

1.传递方法

<Button Content="Demo"
        cal:Message.Attach="Demo" />

2.使用事件传递

(1)

<Button Content="Demo"
        cal:Message.Attach="[Event Click] = [Action Demo]" />

(2)附加事件(好像有bug)

<StackPanel cal:Message.Attach="[AttachedEvent Button.Click] = [Action Demo]">
    <Button Content="Divide (Stack)" />
    <Button Content="Divide (Stack)" />
</StackPanel>

3.事件连写(分号相隔)

<Button Content="Demo"
        cal:Message.Attach="[Event Click] = [Action Demo];[Event Loaded] = [Action Demo]" />

其他事件请参考此处

http://caliburn.codeplex.com/wikipage?title=Message%20Triggers&referringTitle=Documentation

4.参数传递

(1)

public void Demo(string str)
{
    MessageBox.Show(str);
}

<Button Content="Demo"
        cal:Message.Attach="Demo('hello')" />

(2)支持元素对象获取

<TextBox x:Name="demoBox" />
<Button Content="Demo"
        cal:Message.Attach="Demo(demoBox.Text)" />

(3)支持内置参数解析

public void Demo(object sender,EventArgs args)
{
   
}

<Button Content="Demo"
        cal:Message.Attach="Demo($source,$eventArgs)" />

(4)支持返回值传递

public int Demo()
{
    return 1;
}

<TextBox x:Name="demoBox" />
<Button Content="Demo"
        cal:Message.Attach="[Action Demo : demoBox.Text]" />

(5)支持绑定模式

<TextBox x:Name="demoBox" />
<Button Content="Demo"
        cal:Message.Attach="[Action Demo(demoBox.Text:TwoWay)]" />

评论: 0　查看评论　发表评论

最新新闻：
· Yahoo脑震荡 关闭服务汇总贴(2010-02-10 12:06)
· 2003年微软遭遇iTunes：我们彻底晕头转向了(2010-02-10 12:06)
· 百度数据能被“作弊”软件篡改？百度:追究侵权(2010-02-10 11:52)
· Ksplice为Linux提供永远不用重启服务(2010-02-10 11:51)
· 视频网站2010年格局之变：七成企业将被淘汰(2010-02-10 11:48)

编辑推荐：Google社会化产品Buzz发布会实录

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库