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

Schon öfters wurde ich bezüglich eines nicht richtig funktionierenden WPF Data-Binding zur Hilfe gebeten. Ebenfalls tauchen auch immer wieder auf verschiedenen Foren wie Stackoverflow.com Fragen dazu auf.

Hier ein paar Tipps zum Debuggen von Data-Binding Fehlern:

TraceLevel erhöhen

Normalerweise erscheinen im Debug Output Window nur sehr wenige Infos bezüglich Data-Bindings. Um detaillierte Informationen (z.B. auch Value-Änderungeng bei einem funktionierenden Binding) zu erhalten kann man ganz einfach den TraceLevel auf ‘High’setzen.

Beispiel:

<TextBox Text=“{Binding Path=TextA, PresentationTraceSources.TraceLevel=High}”/>

Die meisten Binding-Fehler werden damit sehr schnell ersichtlich.

Ps.: Nicht vergessen das TraceLevel- Property wieder zu löschen. Erstens werden sonst später Unmengen unnötiger Outputs generiert und zweitens wird der Debugger merklich langsamer.

Falsch initialisierte Dependency Properties

Dieser Error bezieht sich zwar nicht direkt auf Data-Bindings, führt aber sehr oft zu nicht funktionierenden Bindings. Ein Auge sollte man auf die Registrierung des DependencyProperties werfen.

Beispiel:

internal class TestClass
{
public static readonly DependencyProperty SomeStringProperty = DependencyProperty.Register(“SomeString”, typeof (string), typeof (TestClass), new UIPropertyMetadata(null));
}

Als dritten Parameter der oben beschriebenen Register Methode muss der OwnerType übergeben werden. Mit wenigen Ausnahmen ist dies wie der Name schon sagt der Typ in welchem das Property definiert wurde (wie hier TestClass).

In Folge von Flüchtigkeitsfehlern (Copy-Paste, Verschieben des Dependency Properties von einer Klasse in eine andere) passiert es nun leider öfters, dass der OwnerType falsch gesetzt ist. Oftmals tritt erst zur Laufzeit ein Problem auf und die geworfenen Exceptions deuten nicht immer auf das wirkliche Problem hin.

Ps.: Visual Studio oder Programme wie ReSharper geben keine Warning aus.<!> Ich hab mir ein kleines Programm geschrieben, welches alle Klassen nach Dependency Properties durchforstet die den falschen “OwnerType” haben.

Binding Chains

Als letztes noch einen Tipp zu einem Problem welches zwar eher selten auftritt, jedoch auch ganz hilfreich für das Verständnis bezüglich Data-Bindings ist.

Nehmen wir an, wir haben ein TextBox-Control als Eingabefeld (tb1).

XAML:

<TextBox x:Name=“tb1″/>

Nun möchten wir den Value des TextBox.Text- Properties mit zwei weiteren Properties über Data-Binding verbinden. Die Bindings sollen aber nicht im XAML gemacht werden sondern mittels Code:

internal class TestClass
{
public static readonly DependencyProperty StringAProperty = DependencyProperty.Register(“StringA”, typeof (string), typeof (TestClass), new UIPropertyMetadata(null));
public static readonly DependencyProperty StringBProperty = DependencyProperty.Register(“StringB”, typeof (string), typeof (TestClass), new UIPropertyMetadata(null));

public TestClass()
{
// Binding für das erste Property:
var binding1 = new Binding(“StringA”) { Source = this, Mode = BindingMode.OneWay };
tb1.SetBinding(TextBox.TextProperty, binding1);

// Binding für das zweite Property:
var binding2 = new Binding(“StringB”) { Source = this, Mode = BindingMode.OneWay };
tb1.SetBinding(TextBox.TextProperty, binding2);
}
}

Wenn wir das Beispiel nun laufen lassen, stellen wir fest, dass die Bindings nicht funktionieren. Aber warum?

Grundsätzlich kann einem Dependency Property nur ein Data-Binding attached werden. Oben im Code wird aber dem TextProperty der TextBox tb1 zweimal ein Binding gesetzt. Ein SetBinding() löscht aber als erstes immer das schon bestehende Binding.

Deklariert man die Bindings stattdessen im XAML ist es offensichtlich, dass nicht zwei Bindings gesetzt werden können:

<!–Es kann nur ein Property für das Binding verwendet werden–>
<TextBox x:Name=”tb1″ Text=“{Binding StringA}“/>

Lösung:

In diesem speziellen Beispiel könnte man natürlich ein MultiBinding verwenden. Als alternativen Weg könnte man nun aber das eine Binding ‘verdrehen’ (was zu einer sogenannten ‘Binding Chain’ führt):

// Binding für das erste Property:
var binding1 = new Binding(“StringA”) { Source = this, Mode = BindingMode.OneWay };
tb1.SetBinding(TextBox.TextProperty, binding1);

// Binding für das zweite Property:
var binding2 = new Binding(“Text”) { Source = tb1, Mode = BindingMode.OneWay };
SetBinding(TestClass.StringBProperty, binding2);

Somit haben wir jetzt nur noch je ein Binding ‘attached’.

Ps.: Zu beachten gilt es hier, dass dieser Weg nur funktioniert, wenn die Properties (hier StringPropertyA und StringPropertyB) Dependency Properties sind, da dies für Bindings zwingend erforderlich ist.