XAML - Dependency Properties


In XAML application a dependency property is a specific type of property which extends the CLR property and it takes advantage of specific functionality available to you in the CLR property system. The purpose of dependency properties is to provide a way to compute the value of a property based on the value of other inputs.

Dependency property gives you all kinds of cool benefits when you use it in your application. Dependency Property can used over a CLR property in the following scenarios

  • If you want to set the style
  • If you want data binding
  • If you want to set with a resource (a static or a dynamic resource)
  • If you want to support animation

Many of the UI control classes which are used in XAML are derived from the DependencyObject class and support dependency properties.e.g. Button class is derived from DependencyObject class which has the IsMouseOver dependency property. The following XAML code creates a button with IsMouseOver dependency property and some CLR properties.

<Window x:Class = "XAMLDependencyProperty.MainWindow"
   xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation"
   xmlns:x = "http://schemas.microsoft.com/winfx/2006/xaml"
   xmlns:local = "clr-namespace:XAMLDependencyProperty"
   Title = "MainWindow" Height = "350" Width = "604">
      <Button Height = "40" Width = "175" Margin = "10" Content = "Dependency Property">
            <Style TargetType = "{x:Type Button}">
                  <Trigger Property = "IsMouseOver" Value = "True">
                     <Setter Property = "Foreground" Value = "Red" />

The x:Type markup extension in XAML has a similar functionality like typeof() in C#. It is used when attributes are specified that take the type of the object such as <Style TargetType = "{x:Type Button}">

When you compile and execute the above code, it will produce the following MainWindow. When the mouse is over the button, it will change the foreground color of the button. When the mouse leaves the button, it will change back to its original color.

Dependency Property

The main difference between dependency properties and other CLR properties are −

  • CLR properties can directly read/write from the private member of a class by using getter and setter. In case of dependency properties, it is not stored in a local object.

  • Dependency properties are stored in a dictionary of key/value pairs which is provided by the DependencyObject class.

  • It also saves a lot of memory because it stores the property when changed.

  • It can be bound in XAML as well.

In .NET framework, custom dependency properties can also be defined. Here are the steps to define custom dependency property in C#.

  • Declare and register your dependency property with system call register.

  • Provide the setter and getter for the property.

  • Define a static handler to handle any changes that occur globally.

  • Define an instance handler to handle any changes that occur to that particular instance.

Given below is the code in C# for dependency property which defined to set the SetText property of the user control.

using System; 
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

namespace WpfApplication3 {
   /// <summary> 
      /// Interaction logic for UserControl1.xaml 
   /// </summary> 
   public partial class UserControl1 : UserControl {
      public UserControl1() {
      public static readonly DependencyProperty
         SetTextProperty = DependencyProperty.Register("SetText", typeof(string), 
         typeof(UserControl1), new PropertyMetadata("", new PropertyChangedCallback(OnSetTextChanged)));
      public string SetText {
         get {return(string) GetValue(SetTextProperty); }
         set {SetValue(SetTextProperty, value);}
      private static void OnSetTextChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) {
         UserControl1 UserControl1Control = d as UserControl1;
      private void OnSetTextChanged(DependencyPropertyChangedEventArgs e) {
         tbTest.Text = e.NewValue.ToString();

Here is the XAML file in which the TextBlock is defined as a user control and the Text property will be assigned to it by the SetText dependency property.

The following XAML code creates a user control with initializing its SetText dependency property and some other properties.

<Window x:Class = "WpfApplication3.MainWindow"
   xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation"
   xmlns:x = "http://schemas.microsoft.com/winfx/2006/xaml"
   xmlns:views = "clr-namespace:WpfApplication3" 
   Title = "MainWindow" Height = "350" Width = "604">
      <views:UserControl1 SetText = "Hellow World" />

Let's run this application and you can see immediately in our MainWindow that dependency property for user control has been successfully used as a Text.

Hello World Example