Wer kennt das nicht: Man hat eine konkrete Idee wie man etwas in WPF umsetzen möchte, weiss scheinbar auch schon welches Control man dafür verwenden möchte und stellt dann fest, dass sich das WPF Control in einem kleinen Detail doch etwas anders verhält.

Welche Möglichkeiten hat man nun?

Man kann unter Verwendung von Vererbung eine eigene Version des Controls erstellen und dieser neuen Generation das gewünschte Verhalten einprogrammieren. Diese Lösung hat jedoch einige Nachteile:

• Durch die Vererbung hat man eine hohe Koppelung, da die Vererbung den Zugriff auf die Interna der Basisklasse (protected Members) zulässt. Die Interna können sich bei Controls in späteren Versionen eher ändern als die Schnittstellen nach aussen (public Members). Alleine schon deshalb sollte man davon absehen.
• Der Aufwand, um die Interna zu verstehen, kann nicht unerheblich sein.
• Im Framework sind auch einige sealed Klassen vorhanden, bei denen eine Erweiterung mittels Vererbung sowieso nicht möglich ist.

Die beschriebenen Probleme können mit Behaviors vermieden werden. Hier wird das Problem mit Hilfe von Komposition anstatt Vererbung gelöst.
Die Klasse Behavior<T> aus dem Namespace System.Windows.Interactivity erlaubt es auf bequeme Weise, ein Verhalten an ein Control zu koppeln.

Beispiel:

Wie das funktioniert, zeigt das folgende Beispiel:

Als ich ein Linien-Diagramm mit dem Chart-Control aus dem WPF-Toolkit realisieren wollte, stand ich vor dem Problem,
dass ich eine variable Anzahl Kurven, sogenannte LineSeries, im Chart anzeigen musste.

Das folgende Klassendiagramm zeigt die gewünschte Struktur der Views und ViewModels:

Leider ist das Property Series des Chart-Controls kein Dependency Property und erlaubt somit kein Binding.

LineSeries lassen sich daher nur fest in XAML deklarieren. Dies sieht dann so aus:

Da aber eine Collection mit variabler Anzahl Kurven an Series gebunden werden soll, ist dies kein gangbarer Weg.

Behavior erstellen:

Das Problem lässt sich jedoch sehr einfach mit einem Behavior für das Chart-Control lösen.
Da Behavior<T> von DependencyObject abgeleitet ist, unterstützt es auch DependencyProperties und damit Bindings.

    public class ChartLineSeriesBehavior: Behavior
    {
        public DataTemplate LineSeriesTemplate { get; set; }

Dadurch kann einfach im Behavior ein DependencyProperty LineSeriesData für die das Binding an die ViewModels der Kurven (SerieViewModel) angelegt werden.

        public ICollection LineSeriesData
        {
            get { return (ICollection)GetValue(LineSeriesProperty); }
            set { SetValue(LineSeriesProperty, value); }
        }

        public static readonly DependencyProperty LineSeriesProperty =
            DependencyProperty.Register
            (
                "LineSeriesData",
                typeof(ICollection), 
                typeof(ChartLineSeriesBehavior),
                new UIPropertyMetadata(OnLineSeriesPropertyChanged)
            );

Beim Registrieren des LineSeriesData DpendencyProperty wird ein Event-Handler OnLineSeriesPropertyChanged festgelegt, der aufgerufen wird, wenn dem Property ein neuer Wert hinzugefügt wird.
Innerhalb von OnLineSeriesPropertyChanged wird dann geprüft, ob es sich um eine Collection handelt, die Notification unterstützt (INotifyCollectionChanged), wie es bei der ObservableCollection der Fall ist. Ist dies der Fall, wird auf der Collection ein Changed-Handler registriert (OnLineSeriesCollectionChanged).

	private static void OnLineSeriesPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            var thisObj = d as ChartLineSeriesBehavior;
            if (thisObj == null)
            {
                throw new ArgumentException("LineSeriesBehavior expected instead of " + d.GetType().Name);
            }            

            if (e.OldValue != null)
            {
                var oldCollection = e.OldValue as INotifyCollectionChanged;
                if (oldCollection != null)
                {
                    oldCollection.CollectionChanged -= thisObj.OnLineSeriesCollectionChanged;
                }
            }

            var newCollection = e.NewValue as INotifyCollectionChanged;
            if (newCollection != null)
            {
                newCollection.CollectionChanged += thisObj.OnLineSeriesCollectionChanged;
                thisObj.UpdateLineSeries();
            }
        }

	private void OnLineSeriesCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
        {
            UpdateLineSeries();
        }

In UpdateLineSeries() wird für jedes Element in der Collection, die an LineSeriesData gebunden ist, ein LineSerie-Element erstellt und an das einzelne Element in der Collection gebunden.

Das Property AssociatedObject von Behavior<T> enhält das Control, dem das Behavior zugeordnet ist.
Im Beispiel ist dies das Chart-Control. Über AssociatedObject.Series.Add(series) wir die erstellte Serie dem Chart hinzugefügt.

        private void UpdateLineSeries()
        {
            for(int i=0; i < LineSeriesData.Count; i++)
            {
                var lineSeriesBinding = BindingOperations.GetBinding(this, LineSeriesProperty);
                if (lineSeriesBinding != null)
                {
                    string viewModelPropertyName = lineSeriesBinding.Path.Path;

                    var series = (LineSeries)LineSeriesTemplate.LoadContent();
                    var binding = new Binding(viewModelPropertyName + "[" + i + "]");
                    series.SetBinding(FrameworkElement.DataContextProperty, binding);
                    AssociatedObject.Series.Add(series);
                }
            }   
        }

Behavior anwenden:

1. Referenz auf System.Windows.Interactivity dem Projekt hinzufügen.
2. Im XAML-File, in dem die Behaviors benötigt werden, den Namespace auf Interactvity hinzufügen: xmlns:i=http://schemas.microsoft.com/expression/2010/interactivity
3. Dem Chart-Control das Behavior hinzufügen:

Den Source Code gibts hier:
Source Code zu Behavior Beispiel