Inside Dependency Properties
Inside Dependency Properties
Written by Alex Armstrong   
Thursday, 30 July 2015
Article Index
Inside Dependency Properties
Custom Dependency Properties

Banner

Custom Dependency Properties

With these thoughts in mind we can now put together a complete class definition:

public class MyClass:DependencyObject
{
 public static readonly
      DependencyProperty MyDPProperty
          = DependencyProperty.Register(
                              "MyDP",
                              typeof(double),
                              typeof(MyClass));
}

 

The class now has a static DependencyProperty as a field but we now have another small problem.

The DependencyObject provides a setter and getter method but these infer the instance of the class from the current context. That is:

GetValue(MyDPProperty)

and

SetValue(MyDPProperty, value)

use "this" to determine the instance of the property that they should get or set. If you think about this you will realise that this means that you can only get and set a dependency property within the class or object that it belongs to.

That is, an object cannot use them to access the dependency property on another object.

The solution is to use the dependency property to back a standard CLR property. For example:

public class MyClass:DependencyObject
{
 public double MyProp
 {
  get
  {
   return (double) GetValue(MyDPProperty);
  }
  set
  {
   SetValue(MyDPProperty, value);
  }
 }

 public static readonly 
      DependencyProperty MyDPProperty
          = DependencyProperty.Register(
                              "MyDP",
                              typeof(double),
                              typeof(MyClass));
}

 

Now when we assign or access MyProp it's actually MyDPProperty that is used.

For example:

MyClass MyObject=new MyClass();
MyObject.MyProp = 3.141;
double pie = MyObject.MyProp;

stores the value 3.141 in MyDPProperty and retrieves the same value into pie. Notice that it is the dependency property that is storing the value the get and set CLR property simply provides access to it.

You can think of the CLR property as a "wrapper" for the dependency property if it helps.

This is the usual pattern for implementing a custom dependency property.

Also notice that now we have three "names" for the property

  • MyProp the CLR property,

  • MyDP the Dependency property name you registered

and

  • MyDPProperty the static variable referencing the DependencyProperty object.

In most cases the CLR property would be given the same name as the dependency property. That is MyDP in this instance.

So for example a Slider object uses the name"Value" - as a CLR property, as the name of a dependency property and uses ValueProperty as the static variable referencing the DependencyProperty object.

 

Banner

Binding

So far you have no proof that the MyProp CLR property really is backed by a dependency property - so let's demonstrate that it can be bound to a slider control.

It is assumed that you know the basics of data binding using code but don't worry if you don’t because it's easy and follows the XAML as long as you remember the XAML is just an object instantiator and initializer.

First we need to create a binding object initialised to the source object, i.e. MyObject in this case:

Binding myBinding = new Binding("MyDP");
myBinding.Source = MyObject;

The Binding object is "bound" to the MyDP dependency property but you also have to specify the instance of the object that has the dependency property that you want to use. 

Notice that the name of the property, i.e. MyDP is used rather than the static variable MyDPProperty. One of the problems with working with dependency objects is trying to guess which name or reference is required.

The binding object defines and controls the source of the data and all that remains is to connect it to the target using the SetBinding method, assuming the target provides one:

slider1.SetBinding(Slider.ValueProperty,
                                myBinding);

and assuming that there is a Slider control on the form called slider1.

Notice that in this case you have to provide not the name of the property but the static variable referencing it, i.e. ValueProperty rather than Value.

Also notice that the WPF framework doesn't use the get/set methods to access the property but goes straight to the dependency property. If you need to intercept a WPF update to a dependency property you can add a call back function to the metadata in the Register method.

If the object doesn't provide a SetBinding method you have to do the job using the BindingOperations static object:

BindingOperations.SetBinding(
                         slider1,
                         Slider.ValueProperty,
                         myBinding);

The result is the same.

Now MyDP dependency property is bound to slider1's ValueProperty dependency property. If you now do:

MyObject.MyProp = 3.141;

you will see the slider move on the form to a position that corresponds to 3.141.

You can also do the job the other way round with MyObject as the source and slider1 as the target:

Binding myBinding = new Binding("Value");
myBinding.Source = slider1;
BindingOperations.SetBinding(
                       MyObject,
                       MyClass.MyDPProperty,
                       myBinding);

but in this case you have to use BindingOperations because the property doesn't implement a SetBinding method - but it could. Now when you change the slider's position the value of MyDP is changed accordingly.

Of course you could set a two-way data binding using the Mode property and then which is the source and which is the target doesn’t make a lot of difference.

Can you use the MyClass and its MyDP dependency property in XAML?

Yes of course - but that is another story.

XAML

 

Banner


WPF The Easy 3D Way

WPF provides a full 3D graphics experience without the need to master DirectX. It really is the easy 3D approach.



How XAML works - Creating Objects With XAML

XAML can be confusing - especially if you think it is a markup language like HTML - it isn't. XAML is a general purpose object instantiation language and to find out what this means - read on. 



Custom Bitmap Effects - Getting started

The simplest possible custom effects project is enough for you to see how it all works and to move on to building your own effects that do something useful. This is an introduction to using HLSL in WP [ ... ]



BitmapSource: WPF Bitmaps

Although bitmap graphics are not a main focus of WPF it does offer some useful facilities



ISupportInitialize and XAML

For a class to be instantiated by XAML it has to have a parameter-less constructor. This means that properties that might be essential to creating the instance can be initialized in any order and this [ ... ]


Other Articles

 

blog comments powered by Disqus

 

<ASIN:1590599551>



Last Updated ( Friday, 31 July 2015 )
 
 
Banner

   
RSS feed of all content
I Programmer - full contents
Copyright © 2015 i-programmer.info. All Rights Reserved.
Joomla! is Free Software released under the GNU/GPL License.