#165 – Overriding Metadata Can Result in Merged Metadata

December 24, 2010 Leave a comment

If you override metadata for a dependency property that a class inherits from its parent, you can specify one or more things to override:

  • The default value
  • The PropertyChangedCallback
  • The CoerceValueCallback
  • Other flags specified for UIPropertyMetadata or FrameworkPropertyMetadata

If you don’t specify all of these things, however, the items that you do not specify will be inherited from the parent.

For example, we created a child class of Slider and overrode metadata to provide a new default value for the Maximum property.  But the coercion behavior of Maximum in our new class behaves as it does for Slider.Maximum.  (Maximum can’t be set below Minimum).

Because we didn’t specify a CoerceValueCallback, the existing coercion logic is used.

When you do specify new metadata:

  • New default value replaces the existing one
  • PropertyChangedCallback is merged with the existing one  (both are invoked)
  • CoerceValueCallback replaces the existing one
Advertisements

Filed under Dependency Properties Tagged with , , , ,

#164 – Overriding Metadata for an Inherited Dependency Property

December 23, 2010 3 Comments

When deriving a new child class, you inherit the parent’s dependency properties.  You might also want to change the behavior of one or more of the dependency properties.  You can do this to some extent by overriding the metadata for a dependency property.

Overriding the metadata in the child class doesn’t change the behavior of the dependency property in the parent class.

In the example below, we create a new class and override metadata for several properties, changing the default values.

    public class ThermometerSlider : Slider
    {
        static ThermometerSlider()
        {
            // Defaults for standard Slider: Min = 0, Max = 10, Value = 0
            // Defaults for ThermometerSlider: Min = -40, Max = 120, Value = 70

            // Change default Minimum to -40.0
            MinimumProperty.OverrideMetadata(typeof(ThermometerSlider), new FrameworkPropertyMetadata(-40.0));

            // Change default Maximum to 120
            MaximumProperty.OverrideMetadata(typeof(ThermometerSlider), new FrameworkPropertyMetadata(120.0));

            // Change default Value to 70
            ValueProperty.OverrideMetadata(typeof(ThermometerSlider), new FrameworkPropertyMetadata(70.0));
        }
    }

The metadata type must match the type in the original property (e.g. FrameworkPropertyMetadata, UIPropertyMetadata, or PropertyMetadata).

Filed under Dependency Properties Tagged with , ,

#163 – Constructing FrameworkPropertyMetadata

December 22, 2010 Leave a comment

When you look at the metadata for a dependency property that is storing its metadata as an instance of FrameworkPropertyMetadata, you’ll see a series of boolean properties.

As a convenience, when constructing an instance of FrameworkPropertyMetadata, you don’t have to pass all of these boolean values into the constructor individually.  Instead, the constructor accepts a flags parameter that is a logical OR of a series of enumeration values.  The individual enumeration values come from the FrameworkPropertyMetadataOptions enum.

        // Register ZHeightProperty dependency property
        private static FrameworkPropertyMetadata meta = new FrameworkPropertyMetadata(1,   // default = 1
            FrameworkPropertyMetadataOptions.AffectsArrange | FrameworkPropertyMetadataOptions.AffectsMeasure |
            FrameworkPropertyMetadataOptions.AffectsParentArrange | FrameworkPropertyMetadataOptions.AffectsParentMeasure |
            FrameworkPropertyMetadataOptions.BindsTwoWayByDefault);

        public static readonly DependencyProperty ZHeightProperty =
            DependencyProperty.Register("ZHeightProperty", typeof(int), typeof(ThreeDButton), meta);

Filed under Dependency Properties Tagged with , , ,

#161 – Read a Dependency Property’s Metadata

December 20, 2010 Leave a comment

You can read a dependency property’s metadata by using the DependencyProperty.GetMetadata method.

For example, assume that we have a Dog class with a BirthYear dependency property and that the class has exposed BirthYearProperty as a public member.  We can retrieve the property’s metadata as follows:

            Dog fido = new Dog("Fido");
            PropertyMetadata meta = Dog.BirthYearProperty.GetMetadata(fido);

Filed under Dependency Properties Tagged with , ,

#160 – Be Careful When Setting Dependency Property Values from a DependencyObject Constructor

December 19, 2010 Leave a comment

You should normally avoid calling any virtual methods in a C# class constructor.  Your constructor might get called during construction of a derived class, before the derived class has finished initializing everything that it needs to initialize.  If the derived class also overrides the virtual method that you’re calling, that method could end up getting called before the derived class has finished initializing everything (in its constructor).

If you use FxCop to check your code, this will be caught by the DoNotCallOverridableMethodsInConstructors rule.

This rule applies to WPF.  If you set the value of a dependency property in a constructor, virtual methods or callbacks in the property system may end up getting called.

The best way to avoid the problem is to follow the following rule:

  • Initialize all objects that might be used by property system callbacks in your default (parameterless) constructor

See also: Safe Constructor Patterns for DependencyObjects

Filed under Dependency Properties Tagged with , , ,

#159 – Creating a Read-Only Dependency Property

December 18, 2010 Leave a comment

Creating a custom dependency property that is read-only is slightly different from creating a standard dependency property.

  • Use DependencyProperty.RegisterReadOnly, rather than Register
  • Create an internal static copy of a DependencyPropertyKey in addition to a public static DependencyProperty
  • Make the CLR property wrapper read-only

For example, assume that we want to add a read-only IQ property to our Person class.

We register the property as read-only and retrieve a DependencyPropertyKey.

        internal static readonly DependencyPropertyKey IQPropertyKey =
            DependencyProperty.RegisterReadOnly("IQ", typeof(int), typeof(Person), new PropertyMetadata(100));

Although the key is private, we make the property public.

        public static readonly DependencyProperty IQProperty =
            IQPropertyKey.DependencyProperty;

We can still set the value internally, by using the key.

public Person(string first, string last, int iq)
{
    FirstName = first;
    LastName = last;
    SetValue(IQPropertyKey, 100);
}

Finally, we provide a CLR property wrapper.

        public int IQ
        {
            get { return (int)GetValue(IQProperty); }
        }

Filed under Dependency Properties Tagged with , ,

#157 – You Can Set Standard CLR Properties from XAML

December 16, 2010 1 Comment

If you create a custom class, you can instantiate instances of that class from XAML by adding the object to a resource dictionary.

    <Window.Resources>
        <m:Person x:Key="perBill" FirstName="William" LastName="Shakespeare" />
    </Window.Resources>

You might wonder whether your properties have to be WPF dependency properties in order to set their values from XAML.  It turns out that the properties on the custom class do not have to be dependency properties in order to be set from XAML.  They can be standard CLR properties.

    public class Person
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }

        public Person()
        {
        }
    }

Filed under Dependency Properties, XAML Tagged with , , ,

← Older posts

Newer posts →