Galileo Computing < openbook > Galileo Computing - Professionelle Bücher. Auch für Einsteiger.
Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
Vorwort zur 5. Auflage
1 Allgemeine Einführung in .NET
2 Grundlagen der Sprache C#
3 Klassendesign
4 Vererbung, Polymorphie und Interfaces
5 Delegates und Ereignisse
6 Weitere .NET-Datentypen
7 Weitere Möglichkeiten von C#
8 Auflistungsklassen (Collections)
9 Fehlerbehandlung und Debugging
10 LINQ to Objects
11 Multithreading und die Task Parallel Library (TPL)
12 Arbeiten mit Dateien und Streams
13 Binäre Serialisierung
14 Einige wichtige .NET-Klassen
15 Projektmanagement und Visual Studio 2010
16 XML
17 WPF – Die Grundlagen
18 WPF-Containerelemente
19 WPF-Steuerelemente
20 Konzepte der WPF
21 Datenbindung
22 2D-Grafik
23 ADO.NET – verbindungsorientierte Objekte
24 ADO.NET – Das Command-Objekt
25 ADO.NET – Der SqlDataAdapter
26 ADO.NET – Daten im lokalen Speicher
27 ADO.NET – Aktualisieren der Datenbank
28 Stark typisierte DataSets
29 LINQ to SQL
30 Weitergabe von Anwendungen
Stichwort

Buch bestellen
Ihre Meinung?

Spacer
<< zurück
Visual C# 2010 von Andreas Kühnel
Das umfassende Handbuch
Buch: Visual C# 2010

Visual C# 2010
geb., mit DVD
1295 S., 49,90 Euro
Rheinwerk Computing
ISBN 978-3-8362-1552-7
Pfeil 21 Datenbindung
Pfeil 21.1 Wichtige Klassen
Pfeil 21.1.1 Die Klasse »Binding«
Pfeil 21.1.2 Die Klasse »DataContext«
Pfeil 21.2 Einfache Datenbindung
Pfeil 21.2.1 Bindung mit Code erzeugen
Pfeil 21.2.2 Bindungsrichtung
Pfeil 21.2.3 Änderung der Datenquelle
Pfeil 21.2.4 Weitere Möglichkeiten im Zusammenhang mit der Datenbindung
Pfeil 21.2.5 Die Ereignisse »SourceUpdated« und »TargetUpdated«
Pfeil 21.3 Verschiedene Datenbindungsquellen
Pfeil 21.3.1 Bindung an einfache Objekte
Pfeil 21.3.2 Auflistungen binden
Pfeil 21.4 DataTemplates festlegen
Pfeil 21.4.1 Trigger
Pfeil 21.5 Daten konvertieren
Pfeil 21.5.1 Beispielprogramm
Pfeil 21.5.2 Mehrfachbindungen und »Converter«-Klassen
Pfeil 21.6 Die Klasse »ObjectDataProvider«
Pfeil 21.7 WPF und ADO.NET
Pfeil 21.7.1 Ausgabe in einer ListBox
Pfeil 21.7.2 Eine Tabelle im DataGrid-Steuerelement
Pfeil 21.7.3 WPF und LINQ to SQL


Galileo Computing - Zum Seitenanfang

21.5 Daten konvertieren Zur nächsten ÜberschriftZur vorigen Überschrift

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 Value Converter bezeichnet werden.

Konvertierungsklassen kommen zum Einsatz, wenn man gewisse Eigenschaften eines Objekts anders anzeigen möchte, als es die ToString-Methode vorgibt. Darüber hinaus kann man auch Konvertierungsklassen bereitstellen, die darzustellende Werte berechnen, beispielsweise


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

oder:


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

Wie schon die Bezeichnung zum Ausdruck bringt, wird eine Konvertierung durch eine Klassendefinition beschrieben. Die Klasse muss die Schnittstelle IValueConverter implementieren. Die Schnittstelle, die zum Namespace System.Windows.Data gehört, erzwingt die Implementierung der beiden Methoden Convert und ConvertBack. Convert beschreibt hierbei die Konvertierung der Quelle in Richtung Ziel, ConvertBack die entgegengesetzte Richtung.

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)
}

Der erste Parameter beschreibt den Wert der Bindungsquelle, der zweite den Typ der Bindungsziel-Eigenschaft. 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.

Haben Sie die Konvertierungsklasse geschrieben (z. B. die Klasse MyConverter), müssen Sie den Namespace, zu dem die Klasse gehört, dem Window bekannt geben:


<Window x:Class="WpfApplication.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:local="clr-namespace:WpfApplication"
        Title="MainWindow" Height="350" Width="525">

Danach erstellen Sie im Resources-Abschnitt des Window ein Objekt des Konverters:


<Window.Resources>
  <local:MyConverter x:Key="converter" />
</Window.Resources>

Und von nun an können Sie den Converter überall dort einsetzen, wo Datenbindung verwendet wird, z. B. hier:


<Button Content="{Binding SomeFunction, 
                  Converter={StaticResource converter}}" />


Galileo Computing - Zum Seitenanfang

21.5.1 Beispielprogramm Zur nächsten ÜberschriftZur vorigen Überschrift

Sehen wir uns noch die Theorie anhand eines Beispiels an. Dem Programm liegt die Klasse Aktie zugrunde, die mit den beiden Eigenschaften Unternehmen und Wert die notdürftigsten Elemente aufweist.


// ---------------------------------------------------------
// Beispiel: ...\Kapitel 21\ConverterSample
// ---------------------------------------------------------
class Aktie {
  public string Unternehmen { get; set; }
  public double Wert { get; set; }
}

Der Wert der Aktie soll in einem WPF-Window als Zahl mit zwei Stellen hinter dem Komma dargestellt werden. Hierzu ist eine Konverterklasse notwendig, die wie folgt definiert ist:


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

Die Klasse implementiert die Schnittstelle IValueConverter mit den beiden Methoden Convert und ConvertBack. Auf die Beschreibung des Codes der beiden Methoden sei an dieser Stelle verzichtet. Darüber hinaus ist die Klasse mit dem Attribut ValueConversionAttribute verknüpft. Das Attribut ist generell nicht zwingend notwendig, es zu verwenden, ist aber guter Programmierstil, um den Entwicklungstools die Datentypen anzuzeigen.

Was zum Schluss noch bleibt, ist der XAML-Code.


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

Im ersten Moment scheint die Angabe des oberen TextBocks schwer verständlich. Doch gehen wir der Reihe nach die Angaben zu der Eigenschaft Text durch. Zuerst wird die Text-Eigenschaft an die statische Ressource aktie gebunden. Dazu bedienen wir uns eines Binding-Objekts. Binding-Objekte haben aber nicht nur die schon bekannten Eigenschaft ElementName und Path, sondern weisen mit Converter, ConverterParameter und auch ConverterCulture weitere auf. Über Converter wird der Konverter als StaticResource genannt. Soll das Converter-Objekt auch nicht mit einem Parameter »gefüttert« werden oder mit zusätzlichen Informationen zur Kultur, dann werden die Eigenschaften ConverterParameter und ConverterCulture berücksichtigt.


Anmerkung

Weiter unten in diesem Kapitel finden Sie das Beispielprogramm WPF_ADOSample2, in dem ebenfalls eine Converter-Klasse zum Einsatz kommt.



Galileo Computing - Zum Seitenanfang

21.5.2 Mehrfachbindungen und »Converter«-Klassen topZur vorigen Überschrift

Bisher haben wir nur mit Datenbindungen gearbeitet, die eine Steuerelementeigenschaft mit genau einer Eigenschaft des Datenobjekts zuließen. Liegt der Datenbindung ein Objekt der Klasse Person zugrunde, müssen wir mit dem derzeitigen Kenntnisstand den Vor- und den Zunamen in zwei separaten Steuerelementen anzeigen lassen, beispielsweise:


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

Wir möchten aber die Angaben in einem TextBlock-Element zusammenfassen. Für solche Anwendungsfälle bietet die WPF mit dem Multiple Binding eine Lösung an. Die Klasse, die uns diese Möglichkeit eröffnet, heißt MultiBinding. Grundsätzlich könnte die Lösung wie folgt aussehen:


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

Tippen Sie diesen Code in den Code-Editor, wird eine Fehlermeldung auftauchen. Der Grund ist sehr einfach: Das MultiBinding-Objekt weiß nicht, wie es die Daten verarbeiten soll. Dazu ist 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, um mehrere Daten empfangen zu können. 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();
  }
}


Hinweis

Es ist nicht unüblich, dass die Methode ConvertBack nicht implementiert wird. Sie sollten in einem solchen Fall eine Ausnahme vom Typ NotSupportedException auslösen.


Zum Schluss müssen wir noch das MultiBinding-Element um den entsprechenden Konverter ergänzen.


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



Ihr Kommentar

Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen. >> Zum Feedback-Formular
<< zurück
  Zum Katalog
Zum Katalog: Visual C# 2010

Visual C# 2010
Jetzt bestellen


 Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen?
Ihre Meinung

 Buchempfehlungen
Zum Katalog: Professionell entwickeln mit Visual C# 2012






 Professionell
 entwickeln mit
 Visual C# 2012


Zum Katalog: Windows Presentation Foundation






 Windows Presentation
 Foundation


Zum Katalog: Schrödinger programmiert C++






 Schrödinger
 programmiert C++


Zum Katalog: C++ Handbuch






 C++ Handbuch


Zum Katalog: C/C++






 C/C++


 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
InfoInfo




Copyright © Rheinwerk Verlag GmbH 2010
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.


Nutzungsbestimmungen | Datenschutz | Impressum

Rheinwerk Verlag GmbH, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, service@rheinwerk-verlag.de

Cookie-Einstellungen ändern