24.4 Daten konvertieren

Haben Sie sich schon einmal darüber Gedanken gemacht, wie die folgende Angabe umgesetzt wird?

<Button Background="Blue" />

Wir übergeben der Eigenschaft Background eine Zeichenfolge, obwohl die Eigenschaft vom Typ Brush ist. Die Zeichenfolge wird anscheinend in ein Objekt vom Typ Brush umgewandelt. Dabei spielen Klassen eine wichtige Rolle, die als Konvertierungsklassen oder ValueConverter bezeichnet werden.

Konvertierungsklassen kommen zum Einsatz, wenn man Objekteigenschaften anders anzeigen möchte, als es die ToString-Methode vorgibt. Darüber hinaus können Sie auch Konvertierungsklassen bereitstellen, die Werte berechnen, beispielsweise

<TextBlock Text="{Binding Nettopreis*1.19}"

oder

<TextBlock Text="{Binding Vorname} {Binding Zuname}" />

Konvertierungsklassen werden durch Klassen beschrieben, die das Interface IValueConverter implementieren. Die Schnittstelle, die zum Namespace System.Windows.Data gehört, erzwingt die Bereitstellung der beiden Methoden Convert und ConvertBack. Convert beschreibt dabei eine Konvertierung der Daten aus der Datenquelle in Richtung Datenziel, ConvertBack die entgegengesetzte Richtung – falls das überhaupt möglich oder notwendig ist.

Das Interface ist wie folgt definiert:

public interface IValueConverter {
  public object Convert(object value, Type targetType, 
                        object parameter, CultureInfo culture);
  public object ConvertBack(object value, Type targetType, 
                            object parameter, CultureInfo culture)
}

Listing 24.27 Die Definition des Interfaces »IValueConverter«

Der erste Parameter beschreibt jeweils den Wert der Bindungsquelle, der zweite den Typ der Zieleigenschaft. Benötigt der Konverter weitere Parameter, können diese dem dritten Parameter übergeben werden. Mit dem vierten Parameter vom Typ CultureInfo kann der Konverter für eine bestimmte Kultur spezifiziert werden.

Stellen wir uns vor, wir hätten die folgende Klasse Aktie geschrieben:

public class Aktie {
  public string Unternehmen { get; set; }
  public double Wert { get; set; }
}

Listing 24.28 Die Klasse »Aktie«

Im Windows.Resources-Abschnitt soll ein Objekt dieses Typs angelegt werden. Dazu ist zuerst der Namespace, in dem sich die Klassendefinition befindet, auf ein Namespace-Präfix abzubilden, z. B.:

<Window ...
        xmlns:local="clr-namespace:ConverterSample">
<Window.Resources>
  <local:Aktie x:Key="aktie" Unternehmen="Tollsoft" Wert="211.73536"/>
</Window.Resources>

Listing 24.29 Erzeugen eines »Aktie«-Objekts im XAML-Code

Der Wert der Aktie und der des Unternehmens sollen in einem Window angezeigt werden. Allerdings sollen vom Aktienpreis nur die ersten beiden Nachkommastellen berücksichtigt werden – ein Fall für einen Konverter.

[ValueConversion(typeof(Double), typeof(String))]
class NumberConverter : IValueConverter {
  public object Convert(object value, Type targetType, 
                        object parameter, CultureInfo culture)
  {
    string param = parameter as string;
    return ((double)value).ToString(param);
  }
  public object ConvertBack(object value, Type targetType, 
                            object parameter, CultureInfo culture)
  {
    string amount = value as string;
    return System.Convert.ToDouble(amount);
  }
}

Listing 24.30 Konverter, um eine bestimmte Anzahl Nachkommastellen anzuzeigen

Die Klasse implementiert natürlich die erforderliche Schnittstelle IValueConverter mit den beiden Methoden Convert und ConvertBack.

Die Idee, die sich hinter der Konvertierungsmethode Convert verbirgt, ist, eine Überladung der ToString-Methode des Typs Double zu benutzen, um mit einer numerischen Formatierungszeichenfolge das Ausgabeformat festzulegen. Die Formatierungszeichenfolge erwarten wir im dritten Parameter der Methode Convert. Da dieser Parameter vom Typ Object ist, müssen wir zuerst in einen String konvertieren. Anschließend wird der Übergabeparameter value in den Typ Double konvertiert und dann mit der Methode ToString unter Übergabe der Formatierungszeichenfolge als String an den Aufrufer zurückgeliefert.

Darüber hinaus ziert die Klasse das Attribut ValueConversionAttribute. Sie müssen das Attribut nicht unbedingt angeben, alles funktioniert auch ohne Attribut. Aber es ist ein guter Stil, weil es dadurch möglich ist, von »außen« zu erkennen, welche Konvertierung der Konverter durchführt. Der erste Typ im Attribut beschreibt übrigens den Datentyp der Quelle, der zweite den Datentyp des Ziels.

Den Konverter geben wir ebenfalls im Abschnitt Window.Resources an. Natürlich dürfen wir auch hier nicht vergessen, den Namespace bekannt zu geben, zu dem die Konverterklasse gehört (es sei denn, der CLR-Namespace ist bereits auf einen XML-Namespace gemappt).

<Window.Resources>
  <local:NumberConverter x:Key="converter" />
  <local:Aktie x:Key="aktie" Unternehmen="Tollsoft" Wert="211.73536"  />
</Window.Resources>

Listing 24.31 Konverterobjekt im Abschnitt »Window.Resources« erzeugen

Was wir noch nicht behandelt haben, ist, wie wir die Bindung dazu bringen, den Konverter zu benutzen. Das ist sehr einfach, denn das Binding-Objekt hat zu diesem Zweck die Eigenschaft Converter, der wir das Konverterobjekt übergeben. Dazu benötigen wir erneut eine Markup-Erweiterung und greifen mit StaticResource auf das Konverterobjekt zu. Zur Übergabe der erforderlichen Parameter geben wir diese der ConverterParameter-Eigenschaft des Binding-Objekts an.

Zum Schluss bleibt mir noch, Ihnen den XAML-Code zu zeigen.

<Window ...
        xmlns:local="clr-namespace:ConverterSample" >
  <Window.Resources>
    <local:NumberConverter x:Key="converter" />
    <local:Aktie x:Key="aktie" Unternehmen="Tollsoft" Wert="211.73536"  />
  </Window.Resources>
  <StackPanel> 
    <TextBox Margin="10" 
        Text="{Binding Source={StaticResource aktie}, 
                       Path=Wert, 
                       Converter={StaticResource converter}, 
                       ConverterParameter='#.##'}" />
    <TextBox Margin="10" Text="{Binding Source={StaticResource aktie}, 
                                        Path=Unternehmen}" />
  </StackPanel>
</Window>

Listing 24.32 Nutzung der Konverterklasse im XAML-Code

24.4.1 Mehrfachbindungen und Konverterklassen

Bisher haben wir nur mit Datenbindungen gearbeitet, die es zuließen, eine Steuerelementeigenschaft mit genau einer Eigenschaft eines Datenobjekts zu binden. Liegt der Datenbindung ein Objekt der Klasse Person mit den beiden Eigenschaften Vorname und Zuname zugrunde, müssen wir deren Werte mit dem derzeitigen Kenntnisstand in zwei separaten Steuerelementen anzeigen lassen, beispielsweise:

<Window.Resources>
  <local:Person x:Key="pers" Vorname="Peter" Zuname="Holzschuh" />
</Window.Resources>
<StackPanel> 
  <TextBox Text="{Binding Source={StaticResource pers}, Path=Vorname}"/>
  <TextBox Text=", " />
  <TextBox Text="{Binding Source={StaticResource pers}, Path=Zuname}"/>
</StackPanel>

Listing 24.33 Einfache Datenbindung von zwei Objekteigenschaften

Unsere Zielsetzung lautet nun aber, beide Angaben in einer TextBox zusammenzufassen. Für solche Anwendungsfälle bietet die WPF mit der Klasse MultiBinding eine einfache Lösung an, die wie folgt aussehen könnte:

<TextBlock>
  <TextBlock.Text>
    <MultiBinding>
      <Binding Source="{StaticResource person}" Path="Zuname" />
      <Binding Source="{StaticResource person}" Path="Vorname" />
    </MultiBinding>
  </TextBlock.Text>
</TextBlock>

Listing 24.34 Mehrfache Bindung an eine Elementeigenschaft

Tippen Sie diesen Code in den Code-Editor, gibt es eine Fehlermeldung. Der Grund ist, dass das MultiBinding-Objekt nicht weiß, wie es die Daten verarbeiten soll. Dazu ist auch in diesem Fall ein Konverter notwendig. Da mehrere Daten an den Konverter übertragen werden müssen, eignet sich ein Konverter vom Typ IValueConverter nicht mehr. Stattdessen kommt jetzt die Schnittstelle IMultiValueConverter ins Spiel.

Die Schnittstelle IMultiValueConverter ist der Schnittstelle IValueConverter sehr ähnlich. Der Unterschied bei der Methode Convert ist im ersten Übergabeparameter zu finden, der vom Typ object[] ist und somit mehrere Werte empfangen kann. Bei ConvertBack ist es dementsprechend der zweite Parameter, der vom Typ Type[] ist.

[ValueConversion(typeof(String), typeof(String))]
class PersonConverter : IMultiValueConverter {
  public object Convert(object[] values, Type targetType, object parameter,
                        CultureInfo culture) {
    return (string)values[0] + ", " + (string)values[1];
  }
  public object[] ConvertBack(object value, Type[] targetTypes, 
                   object parameter, CultureInfo culture) {
    throw new NotSupportedException();
  }
}

Listing 24.35 Die Konverterklasse »PersonConverter«

Zum Schluss bleibt noch, das MultiBinding-Element um den entsprechenden Konverter zu ergänzen. Dafür stellt uns das Objekt die Eigenschaft Converter bereit.

<Window ...
        xmlns:local="clr-namespace:MultiBindingSample">
  <Window.Resources>
    <local:PersonConverter x:Key="converter" />
    <local:Person x:Key="pers" Vorname="Peter" Zuname="Holzschuh" />
  </Window.Resources>
  <StackPanel> 
    <TextBox>
      <TextBox.Text>
        <MultiBinding Converter="{StaticResource converter}">
          <Binding Source="{StaticResource pers}" Path="Zuname" />
          <Binding Source="{StaticResource pers}" Path="Vorname" />
        </MultiBinding>
      </TextBox.Text>
    </TextBox>
  </StackPanel>
</Window>

Listing 24.36 Multiple Bindung im XAML-Code

Ihre Meinung

Wie hat Ihnen das Openbook gefallen? Wir freuen uns immer über Ihre Rückmeldung. Schreiben Sie uns gerne Ihr Feedback als E-Mail an kommunikation@rheinwerk-verlag.de.