Binding to ActualWidth does not work

Question

In a Silverlight 3.0 application I'm attempting to create a rectangle in a canvas and have it stretch the whole width of the canvas. I have attempted to do this by binding to the ActualWidth property of a parent container (seem sample below), however while I don't see any binding errors the value is not being bound. The rectangle is not visible as its width is zero. In addition tried binding to the ActualWidth of the canvas that contains my rectangle but this made no difference.

I did find this bug logged on Microsoft Connect but there were no workarounds listed.

Has anyone been able to solve this issue or can they point to solution?

Edit: The original code sample was not accurate of what I'm trying to achieve, updated for more clarity.

<UserControl>     <Border BorderBrush="White"             BorderThickness="1"             CornerRadius="4"             HorizontalAlignment="Center">         <Grid x:Name="GridContainer">             <Rectangle Fill="Aqua"                        Width="150"                        Height="400" />             <Canvas>                 <Rectangle Width="{Binding Path=ActualWidth, ElementName=GridContainer}"                            Height="30"                            Fill="Red" />             </Canvas>              <StackPanel>                 <!-- other elements here -->             </StackPanel>         </Grid>     </Border> </UserControl> 

Answer 1

What are you trying to do that requires you to databind to the ActualWidth property? This is a known issue with Silverlight, and there is no simple workaround.

One thing that could be done is to set up the visual tree in such a way that you do not need to actually set the Width of the Rectangle, and just allow it to stretch to the appropriate size. So in the example above, if you remove the Canvas (or change the Canvas to some other Panel) and leave the Rectangle's HorizontalAlignment set to Stretch, it will take up all of the available width (effectively the Width of the Grid).

However, this may not be possible in your particular case, and it may really be necessary to set up the databinding. It has already been established that this is not possible directly, but with the help of a proxy object, we can set up the required binding. Consider this code:

public class ActualSizePropertyProxy : FrameworkElement, INotifyPropertyChanged {     public event PropertyChangedEventHandler PropertyChanged;      public FrameworkElement Element     {         get { return (FrameworkElement)GetValue(ElementProperty); }         set { SetValue(ElementProperty, value); }     }      public double ActualHeightValue     {         get{ return Element == null? 0: Element.ActualHeight; }     }      public double ActualWidthValue     {         get { return Element == null ? 0 : Element.ActualWidth; }     }      public static readonly DependencyProperty ElementProperty =         DependencyProperty.Register("Element", typeof(FrameworkElement), typeof(ActualSizePropertyProxy),                                      new PropertyMetadata(null,OnElementPropertyChanged));      private static void OnElementPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)     {         ((ActualSizePropertyProxy)d).OnElementChanged(e);     }      private void OnElementChanged(DependencyPropertyChangedEventArgs e)     {         FrameworkElement oldElement = (FrameworkElement)e.OldValue;         FrameworkElement newElement = (FrameworkElement)e.NewValue;          newElement.SizeChanged += new SizeChangedEventHandler(Element_SizeChanged);         if (oldElement != null)         {             oldElement.SizeChanged -= new SizeChangedEventHandler(Element_SizeChanged);         }         NotifyPropChange();     }      private void Element_SizeChanged(object sender, SizeChangedEventArgs e)     {         NotifyPropChange();     }      private void NotifyPropChange()     {         if (PropertyChanged != null)         {             PropertyChanged(this, new PropertyChangedEventArgs("ActualWidthValue"));             PropertyChanged(this, new PropertyChangedEventArgs("ActualHeightValue"));         }     } } 

We can use this in xaml as follows:

<Grid x:Name="LayoutRoot">     <Grid.Resources>         <c:ActualSizePropertyProxy Element="{Binding ElementName=LayoutRoot}" x:Name="proxy" />     </Grid.Resources>     <TextBlock x:Name="tb1" Text="{Binding ActualWidthValue, ElementName=proxy}"  /> </Grid> 

So we are Binding TextBlock.Text to the ActualWidthValue on the proxy object. The proxy object in turn provides the ActualWidth of the Element, which is provided by another Binding.

This is not a simple solution to the problem, but it is the best that I can think of for how to databind to ActualWidth.

If you explained your scenario a bit more, it may be possible to come up with a simpler solution. DataBinding may not be required at all; would it be possible to just set the property from code in a SizeChanged event handler?

Answer 2

Using the mechanism of attached properties, properties which represent ActualHeight and ActualWidth and are updated by SizeChanged event can be defined. Its usage will look like the following.

<Grid local:SizeChange.IsEnabled="True" x:Name="grid1">...</Grid>  <TextBlock Text="{Binding ElementName=grid1,                          Path=(local:SizeChange.ActualHeight)}"/> 

Technical details can be found at the following:

http://darutk-oboegaki.blogspot.com/2011/07/binding-actualheight-and-actualwidth.html

The advantage of this solution compared to others is in that the attached properties defined in the solution (SizeChange.ActualHeight and SizeChange.ActualWidth) can be used for any FrameworkElement without creating any sub class. This solution is reusable and less invasive.

---

In the event that the link becomes stale, here is the SizeChange Class as shown on the link:

// Declare SizeChange class as a sub class of DependencyObject  // because we need to register attached properties. public class SizeChange : DependencyObject  {      #region Attached property "IsEnabled"      // The name of IsEnabled property.     public const string IsEnabledPropertyName = "IsEnabled";      // Register an attached property named "IsEnabled".     // Note that OnIsEnabledChanged method is called when     // the value of IsEnabled property is changed.     public static readonly DependencyProperty IsEnabledProperty          = DependencyProperty.RegisterAttached(              IsEnabledPropertyName,              typeof(bool),              typeof(SizeChange),              new PropertyMetadata(false, OnIsEnabledChanged));      // Getter of IsEnabled property. The name of this method     // should not be changed because the dependency system     // uses it.     public static bool GetIsEnabled(DependencyObject obj)      {          return (bool)obj.GetValue(IsEnabledProperty);      }      // Setter of IsEnabled property. The name of this method     // should not be changed because the dependency system     // uses it.     public static void SetIsEnabled(DependencyObject obj, bool value)      {          obj.SetValue(IsEnabledProperty, value);      }       #endregion       #region Attached property "ActualHeight"      // The name of ActualHeight property.     public const string ActualHeightPropertyName = "ActualHeight";      // Register an attached property named "ActualHeight".     // The value of this property is updated When SizeChanged     // event is raised.     public static readonly DependencyProperty ActualHeightProperty          = DependencyProperty.RegisterAttached(              ActualHeightPropertyName,              typeof(double),              typeof(SizeChange),              null);      // Getter of ActualHeight property. The name of this method     // should not be changed because the dependency system     // uses it.     public static double GetActualHeight(DependencyObject obj)      {          return (double)obj.GetValue(ActualHeightProperty);      }      // Setter of ActualHeight property. The name of this method     // should not be changed because the dependency system     // uses it.     public static void SetActualHeight(DependencyObject obj, double value)      {          obj.SetValue(ActualHeightProperty, value);      }       #endregion       #region Attached property "ActualWidth"      // The name of ActualWidth property.     public const string ActualWidthPropertyName = "ActualWidth";      // Register an attached property named "ActualWidth".     // The value of this property is updated When SizeChanged     // event is raised.     public static readonly DependencyProperty ActualWidthProperty          = DependencyProperty.RegisterAttached(              ActualWidthPropertyName,              typeof(double),              typeof(SizeChange),              null);      // Getter of ActualWidth property. The name of this method     // should not be changed because the dependency system     // uses it.     public static double GetActualWidth(DependencyObject obj)      {          return (double)obj.GetValue(ActualWidthProperty);      }      // Setter of ActualWidth property. The name of this method     // should not be changed because the dependency system     // uses it.     public static void SetActualWidth(DependencyObject obj, double value)      {          obj.SetValue(ActualWidthProperty, value);      }       #endregion      // This method is called when the value of IsEnabled property     // is changed. If the new value is true, an event handler is     // added to SizeChanged event of the target element.     private static void OnIsEnabledChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)      {         // The given object must be a FrameworkElement instance,         // because we add an event handler to SizeChanged event         // of it.         var element = obj as FrameworkElement;           if (element == null)          {             // The given object is not an instance of FrameworkElement,             // meaning SizeChanged event is not available. So, nothing             // can be done for the object.             return;          }          // If IsEnabled=True         if (args.NewValue != null && (bool)args.NewValue == true)          {              // Attach to the element.              Attach(element);          }          else          {              // Detach from the element.              Detach(element);          }      }       private static void Attach(FrameworkElement element)      {         // Add an event handler to SizeChanged event of the element          // to take action when actual size of the element changes.         element.SizeChanged += HandleSizeChanged;      }       private static void Detach(FrameworkElement element)      {         // Remove the event handler from the element.         element.SizeChanged -= HandleSizeChanged;      }      // An event handler invoked when SizeChanged event is raised.     private static void HandleSizeChanged(object sender, SizeChangedEventArgs args)      {          var element = sender as FrameworkElement;           if (element == null)          {              return;          }          // Get the new actual height and width.         var width  = args.NewSize.Width;          var height = args.NewSize.Height;          // Update values of SizeChange.ActualHeight and          // SizeChange.ActualWidth.         SetActualWidth(element, width);          SetActualHeight(element, height);      }  }