Pushing read-only GUI properties back into ViewModel

Yes, I've done this in the past with the ActualWidth and ActualHeight properties, both of which are read-only. I created an attached behavior that has ObservedWidth and ObservedHeight attached properties. It also has an Observe property that is used to do the initial hook-up. Usage looks like this:

<UserControl ...    SizeObserver.Observe="True"    SizeObserver.ObservedWidth="{Binding Width, Mode=OneWayToSource}"    SizeObserver.ObservedHeight="{Binding Height, Mode=OneWayToSource}"

So the view model has Width and Height properties that are always in sync with the ObservedWidth and ObservedHeight attached properties. The Observe property simply attaches to the SizeChanged event of the FrameworkElement. In the handle, it updates its ObservedWidth and ObservedHeight properties. Ergo, the Width and Height of the view model is always in sync with the ActualWidth and ActualHeight of the UserControl.

Perhaps not the perfect solution (I agree - read-only DPs should support OneWayToSource bindings), but it works and it upholds the MVVM pattern. Obviously, the ObservedWidth and ObservedHeight DPs are not read-only.

UPDATE: here's code that implements the functionality described above:

public static class SizeObserver{    public static readonly DependencyProperty ObserveProperty = DependencyProperty.RegisterAttached(        "Observe",        typeof(bool),        typeof(SizeObserver),        new FrameworkPropertyMetadata(OnObserveChanged));    public static readonly DependencyProperty ObservedWidthProperty = DependencyProperty.RegisterAttached(        "ObservedWidth",        typeof(double),        typeof(SizeObserver));    public static readonly DependencyProperty ObservedHeightProperty = DependencyProperty.RegisterAttached(        "ObservedHeight",        typeof(double),        typeof(SizeObserver));    public static bool GetObserve(FrameworkElement frameworkElement)    {        frameworkElement.AssertNotNull("frameworkElement");        return (bool)frameworkElement.GetValue(ObserveProperty);    }    public static void SetObserve(FrameworkElement frameworkElement, bool observe)    {        frameworkElement.AssertNotNull("frameworkElement");        frameworkElement.SetValue(ObserveProperty, observe);    }    public static double GetObservedWidth(FrameworkElement frameworkElement)    {        frameworkElement.AssertNotNull("frameworkElement");        return (double)frameworkElement.GetValue(ObservedWidthProperty);    }    public static void SetObservedWidth(FrameworkElement frameworkElement, double observedWidth)    {        frameworkElement.AssertNotNull("frameworkElement");        frameworkElement.SetValue(ObservedWidthProperty, observedWidth);    }    public static double GetObservedHeight(FrameworkElement frameworkElement)    {        frameworkElement.AssertNotNull("frameworkElement");        return (double)frameworkElement.GetValue(ObservedHeightProperty);    }    public static void SetObservedHeight(FrameworkElement frameworkElement, double observedHeight)    {        frameworkElement.AssertNotNull("frameworkElement");        frameworkElement.SetValue(ObservedHeightProperty, observedHeight);    }    private static void OnObserveChanged(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs e)    {        var frameworkElement = (FrameworkElement)dependencyObject;        if ((bool)e.NewValue)        {            frameworkElement.SizeChanged += OnFrameworkElementSizeChanged;            UpdateObservedSizesForFrameworkElement(frameworkElement);        }        else        {            frameworkElement.SizeChanged -= OnFrameworkElementSizeChanged;        }    }    private static void OnFrameworkElementSizeChanged(object sender, SizeChangedEventArgs e)    {        UpdateObservedSizesForFrameworkElement((FrameworkElement)sender);    }    private static void UpdateObservedSizesForFrameworkElement(FrameworkElement frameworkElement)    {        // WPF 4.0 onwards        frameworkElement.SetCurrentValue(ObservedWidthProperty, frameworkElement.ActualWidth);        frameworkElement.SetCurrentValue(ObservedHeightProperty, frameworkElement.ActualHeight);        // WPF 3.5 and prior        ////SetObservedWidth(frameworkElement, frameworkElement.ActualWidth);        ////SetObservedHeight(frameworkElement, frameworkElement.ActualHeight);    }}

I use a universal solution which works not only with ActualWidth and ActualHeight, but also with any data you can bind to at least in reading mode.

The markup looks like this, provided ViewportWidth and ViewportHeight are properties of the view model

<Canvas>    <u:DataPiping.DataPipes>         <u:DataPipeCollection>             <u:DataPipe Source="{Binding RelativeSource={RelativeSource AncestorType={x:Type Canvas}}, Path=ActualWidth}"                         Target="{Binding Path=ViewportWidth, Mode=OneWayToSource}"/>             <u:DataPipe Source="{Binding RelativeSource={RelativeSource AncestorType={x:Type Canvas}}, Path=ActualHeight}"                         Target="{Binding Path=ViewportHeight, Mode=OneWayToSource}"/>          </u:DataPipeCollection>     </u:DataPiping.DataPipes><Canvas>

Here is the source code for the custom elements

public class DataPiping{    #region DataPipes (Attached DependencyProperty)    public static readonly DependencyProperty DataPipesProperty =        DependencyProperty.RegisterAttached("DataPipes",        typeof(DataPipeCollection),        typeof(DataPiping),        new UIPropertyMetadata(null));    public static void SetDataPipes(DependencyObject o, DataPipeCollection value)    {        o.SetValue(DataPipesProperty, value);    }    public static DataPipeCollection GetDataPipes(DependencyObject o)    {        return (DataPipeCollection)o.GetValue(DataPipesProperty);    }    #endregion}public class DataPipeCollection : FreezableCollection<DataPipe>{}public class DataPipe : Freezable{    #region Source (DependencyProperty)    public object Source    {        get { return (object)GetValue(SourceProperty); }        set { SetValue(SourceProperty, value); }    }    public static readonly DependencyProperty SourceProperty =        DependencyProperty.Register("Source", typeof(object), typeof(DataPipe),        new FrameworkPropertyMetadata(null, new PropertyChangedCallback(OnSourceChanged)));    private static void OnSourceChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)    {        ((DataPipe)d).OnSourceChanged(e);    }    protected virtual void OnSourceChanged(DependencyPropertyChangedEventArgs e)    {        Target = e.NewValue;    }    #endregion    #region Target (DependencyProperty)    public object Target    {        get { return (object)GetValue(TargetProperty); }        set { SetValue(TargetProperty, value); }    }    public static readonly DependencyProperty TargetProperty =        DependencyProperty.Register("Target", typeof(object), typeof(DataPipe),        new FrameworkPropertyMetadata(null));    #endregion    protected override Freezable CreateInstanceCore()    {        return new DataPipe();    }}

If anyone else is interested, I coded up an approximation of Kent's solution here:

class SizeObserver{    #region " Observe "    public static bool GetObserve(FrameworkElement elem)    {        return (bool)elem.GetValue(ObserveProperty);    }    public static void SetObserve(      FrameworkElement elem, bool value)    {        elem.SetValue(ObserveProperty, value);    }    public static readonly DependencyProperty ObserveProperty =        DependencyProperty.RegisterAttached("Observe", typeof(bool), typeof(SizeObserver),        new UIPropertyMetadata(false, OnObserveChanged));    static void OnObserveChanged(      DependencyObject depObj, DependencyPropertyChangedEventArgs e)    {        FrameworkElement elem = depObj as FrameworkElement;        if (elem == null)            return;        if (e.NewValue is bool == false)            return;        if ((bool)e.NewValue)            elem.SizeChanged += OnSizeChanged;        else            elem.SizeChanged -= OnSizeChanged;    }    static void OnSizeChanged(object sender, RoutedEventArgs e)    {        if (!Object.ReferenceEquals(sender, e.OriginalSource))            return;        FrameworkElement elem = e.OriginalSource as FrameworkElement;        if (elem != null)        {            SetObservedWidth(elem, elem.ActualWidth);            SetObservedHeight(elem, elem.ActualHeight);        }    }    #endregion    #region " ObservedWidth "    public static double GetObservedWidth(DependencyObject obj)    {        return (double)obj.GetValue(ObservedWidthProperty);    }    public static void SetObservedWidth(DependencyObject obj, double value)    {        obj.SetValue(ObservedWidthProperty, value);    }    // Using a DependencyProperty as the backing store for ObservedWidth.  This enables animation, styling, binding, etc...    public static readonly DependencyProperty ObservedWidthProperty =        DependencyProperty.RegisterAttached("ObservedWidth", typeof(double), typeof(SizeObserver), new UIPropertyMetadata(0.0));    #endregion    #region " ObservedHeight "    public static double GetObservedHeight(DependencyObject obj)    {        return (double)obj.GetValue(ObservedHeightProperty);    }    public static void SetObservedHeight(DependencyObject obj, double value)    {        obj.SetValue(ObservedHeightProperty, value);    }    // Using a DependencyProperty as the backing store for ObservedHeight.  This enables animation, styling, binding, etc...    public static readonly DependencyProperty ObservedHeightProperty =        DependencyProperty.RegisterAttached("ObservedHeight", typeof(double), typeof(SizeObserver), new UIPropertyMetadata(0.0));    #endregion}

Feel free to use it in your apps. It works well. (Thanks Kent!)