<rant>

Thought I’d share with you some of my gripes with the ObservableCollection<T> class that forms the basis of just about all data-bindable domain models in WPF and Silverlight.

Firstly why does it not support an AddRange(IEnumerable<T> items) method like other collections?

The EventHandler signature looks like:

private void OnCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)

and NotifyCollectionChangedEventArgs has a property NewItems of type IList.  This implies that you should be able to add multiple items, but the API doesn’t support it.  Infuriating!

More importantly, when you Clear an ObservableCollection you get called on the CollectionChanged event with NotifyCollectionChangedAction.Reset.  However when you look at e.OldItems you’d expect to find the list of items that were cleared, right?  Sadly not.  I often find that I hook into various event handlers in the OnCollectionChanged method.  In order to clear these subscriptions on reset it means that I have to hold a parallel collection of the items in the ObservableCollection.  Not good.

Also, why is there not an ObservableDictionary<TKey, TValue>?  Various people have attempted to implement this, but it should really be part of the framework and understood by data binding.

I’m hopeful that these issues will go away with the BCL changes for the very groovy System.Reactive framework.

</rant>

So I’m working on a ChartingLibrary at the moment that has to compile for both Silverlight and WPF.  I can across a particularly nasty problem with axis tick labels.  So the requirement is that the tick labels can be rotated.  In WPF this is a doddle – you just use a RotateTransform and set it as the LayoutTransform in a TextBlock.  In Silverlight, however, you only have the RenderTransform to play with.  This is the solution I came up with:

    [TemplatePart(Name = PART_TEXT_BLOCK, Type = typeof(TextBlock))]
    public class TickLabel : Control
    {
        #region Private Fields
        private TextBlock _textBlock;
        private RotateTransform _rotateTransform;
#if SILVERLIGHT
        private TranslateTransform _translateTransform;
#endif
        #endregion

        #region Ctor
        public TickLabel()
        {
            base.DefaultStyleKey = typeof(TickLabel);
        }
        #endregion

        #region Dependency Properties

        #region Text
        public static readonly DependencyProperty TextProperty = DependencyProperty.Register(
            "Text", typeof(string), typeof(TickLabel), null);

        public string Text
        {
            get { return base.GetValue(TextProperty) as string; }
            set { base.SetValue(TextProperty, value); }
        }
        #endregion

        #region Angle
        public static readonly DependencyProperty AngleProperty = DependencyProperty.Register(
            "Angle", typeof(double), typeof(TickLabel),
            new PropertyMetadata(0.0, OnAngleChanged));

        public double Angle
        {
            get { return (double)base.GetValue(AngleProperty); }
            set { base.SetValue(AngleProperty, value); }
        }

        private static void OnAngleChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            var instance = (TickLabel) d;
            var angle = (double) e.NewValue;
            instance.OnAngleChanged(angle);
        }

        private void OnAngleChanged(double angle)
        {
            _rotateTransform.Angle = angle;
#if SILVERLIGHT
            // Have to manually translate for Silverlight
            var width = _textBlock.ActualWidth;
            var height = _textBlock.ActualHeight;
            var sourceCenter = new Point(width / 2, height / 2);
            var destinationCenter = _rotateTransform.Transform(sourceCenter);
            var sourceRect = new Rect { Width = width, Height = height };
            var destinationRect = _rotateTransform.TransformBounds(sourceRect);
            _translateTransform.X = destinationRect.Width/2 - destinationCenter.X;
            _translateTransform.Y = destinationRect.Height/2 - destinationCenter.Y;
            base.InvalidateMeasure();
#endif
        }
        #endregion

        #endregion

        #region FrameworkElement Members
        public override void OnApplyTemplate()
        {
            base.OnApplyTemplate();
            _textBlock = base.GetTemplateChild(PART_TEXT_BLOCK) as TextBlock;
            if (_textBlock == null)
            {
                throw new Exception(string.Format("TemplatePart: {0} missing.", PART_TEXT_BLOCK));
            }

            _rotateTransform = new RotateTransform { Angle = this.Angle };
#if SILVERLIGHT
            // No LayoutTransform in Silverlight so we have to use RenderTransform
            var transformGroup = new TransformGroup();
            transformGroup.Children.Add(_rotateTransform);
            _translateTransform = new TranslateTransform();
            transformGroup.Children.Add(_translateTransform);
            _textBlock.RenderTransform = transformGroup;
#else
            _textBlock.LayoutTransform = _rotateTransform;
#endif
        }

#if SILVERLIGHT
        protected override Size MeasureOverride(Size constraint)
        {
            var width = _textBlock.ActualWidth;
            var height = _textBlock.ActualHeight;
            var sourceRect = new Rect { Width = width, Height = height };
            var destinationRect = _rotateTransform.TransformBounds(sourceRect);
            return new Size(destinationRect.Width, destinationRect.Height);
        }
#endif
        #endregion

        #region Constants
        private const string PART_TEXT_BLOCK = "PART_TextBlock";
        #endregion
    }

And the default control template looks like this:

<Style TargetType="local:TickLabel>
<Setter Property="Template">
<Setter.Value>
<ControlTemplate TargetType="local:TickLabel">
  <Canvas>
    <TextBlock Name="PART_TextBlock" Text="{TemplateBinding Text}" />
  </Canvas>
</ControlTemplate>
</Setter.Value>
</Setter>
</Style>

Note that you have to include the TextBlock in a Canvas otherwise it will clip.

Works like a treat!

I’ve just been checking out some of the asynchronous programming stuff that will be shipped with .Net 4.0.  I managed to obtain a preview copy of the System.Reactive.dll by downloading the lates Silverlight Toolkit source.  This seems like very exciting stuff indeed.  Basically turning the whole .Net event infrastructure on its head.  This is based on the observation that we can think of the observer pattern as being the dual of the enumerable pattern.  The power of this is that we can use Linq to enumerate over events just as we do over objects in an enumerable.  Or, in other words, Linq of pushed rather than pulled data.

Check this out for more information:

http://themechanicalbride.blogspot.com/2009/07/introducing-rx-linq-to-events.html

My one criticism of this so far is:

Say you want to create an observer on the MouseMove event on a control.  You’d do something like this:

var mouseEventSource = Observable.FromEvent<MouseEventArgs>(this, “MouseMove”);
var mouseMoveSubscription = mouseEventSource.Subscribe(mea => Debug.WriteLine(“Mouse Moved”));

And this works perfectly.  The only problem… that pesky “MouseMove” parameter when converting the event into and IObservable.  I noticed that there’s an overload of the same method that takes Actions to add and remove the EventHandler.  This would look something like this:

var mouseEventSource = Observable.FromEvent<MouseEventArgs>(eh=>this.MouseMove += eh, eh=>this.MouseMove -= eh);

This looks much nicer as I’m not passing in that ‘orrible string and therefore have compile-time checking of the event.  Only problem with this is that it requires the MouseMove event handler to be a generic EventHandler<MouseEventArgs>.  Sadly, the MouseEventHandler is a delegate in its own right rather than deriving from the generic EventHandler.

This leads me to the following conclusion.  This looks like really interesting technology, but it’ll require a massive overhauling of the .Net base class libraries to be truely useful.