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.3 Verschiedene Datenbindungsquellen Zur nächsten ÜberschriftZur vorigen Überschrift


Galileo Computing - Zum Seitenanfang

21.3.1 Bindung an einfache Objekte Zur nächsten ÜberschriftZur vorigen Überschrift

Im letzten Abschnitt hatten wir bereits die Klasse Person bereitgestellt und mit dieser Datenbindung betrieben. Fassen wir an dieser Stelle alle wesentlichen Gesichtspunkte zusammen, die beim Entwurf einer bindungsfähigen Klasse beachtet werden sollten:

  • Die Klasse muss die Schnittstelle INotifyPropertyChanged implementieren. Diese ist im Namespace System.ComponentModel enthalten.
  • Die Klasse sollte einen parameterlosen Konstruktor haben.
  • Als Datenquelle kommen nur Eigenschaften in Betracht, die über eine Eigenschaftsmethode veröffentlicht werden, da öffentliche Felder nicht gebunden werden können.

In den Beispielen zuvor hatten wir mit


this.DataContext = person;

ein Objekt vom Typ Person an den DataContext des Window gebunden. Hier ist der parameterlose Konstruktor nicht unbedingt notwendig. Person-Objekte lassen sich aber auch direkt im XAML-Code angeben. Dazu ist zum Beispiel der Resources-Abschnitt im Window gut geeignet. Im XAML-Code wird zuvor die Angabe des Namespaces benötigt, in dem Person definiert ist. Deshalb muss der Namespace des Typs Person in der XAML-Datei bekannt gegeben werden:


xmlns:src="clr-namespace:NamespaceOfPerson"

Nun kann die Klasse Person auch im Resources-Abschnitt der XAML-Datei verwendet werden. Dabei wird der parameterlose Konstruktor aufgerufen. Optional können den Eigenschaften sofort Werte zugewiesen werden:


<Window.Resources>
  <src:Person x:Key="pers1" Name="Schmidt" Alter="43" />
  <src:Person x:Key="pers2" Name="Müller" Alter="21" />
</Window.Resources>

Anschließend können Sie die Möglichkeiten der Datenbindung benutzen.

Möchten Sie mit C#-Code auf das im XAML-Code erzeugts Objekt zugreifen, müssen Sie sich zuerst die Referenz auf das im XAML-Code erzeugte Objekt besorgen. Hier hilft Ihnen die Methode FindResource der Klasse FrameworkElement weiter, einer Klasse, von der auch Window abgeleitet ist. Der Methode wird als Argument das im XAML-Code erzeugte Objekt übergeben. Der Rückgabewert muss noch in den richtigen Typ konvertiert werden.


private void button1_Click(object sender, RoutedEventArgs e) {
  Person pers = (Person)FindResource("pers1");
  MessageBox.Show("Name und Alter: " + pers.Name + ", " + pers.Alter);
  pers.Zuname = "Fischer";
}


Galileo Computing - Zum Seitenanfang

21.3.2 Auflistungen binden topZur vorigen Überschrift

Im Abschnitt zuvor haben Sie gesehen, dass an eine Klasse besondere Anforderungen gestellt werden müssen, damit sie XAML-bindungsfähig wird. Das gilt in gleichem Maße auch für eine Auflistung. Hier lautet die Forderung, dass die Auflistung neben INotifyPropertyChanged eine weitere Schnittstelle implementieren muss, nämlich INotifyCollectionChanged. Mit der generischen Klasse ObservableCollection<> stellt .NET Ihnen bereits eine solche Klasse zur Verfügung. Sie gehört zum Namespace System.Collections.ObjectModel. Sie kann ähnlich benutzt werden wie eine herkömmliche Auflistung – mit dem Unterschied, dass sie unter WPF bindungsfähig ist.

Damit wird es sehr einfach, eine Liste mehrerer Objekte vom Typ Person zu beschreiben:


ObservableCollection<Person> personen = new ObservableCollection<Person>();

Damit steht uns ein Auflistungsobjekt zur Verfügung, das wir zum Füllen von Steuerelementen wie der ComboBox oder der ListBox einsetzen können.

Im Kapitel habe ich beschrieben, wie Sie mit Elementen vom Typ ListBoxItem und ComboBoxItem Einträge erstellen können. Diese Elemente spielen bei der Datenbindung keine Rolle mehr. Stattdessen betritt nun die Eigenschaft ItemSource die Bühne. Diese Eigenschaft bietet die Möglichkeit der Anbindung von Objektmengen. Grundsätzlich lässt sich jede Objektmenge anbinden, vorausgesetzt, diese implementiert die Schnittstelle IEnumerable. Das gilt nicht nur für ObservableCollection<T>, sondern auch gleichermaßen für ArrayList, List<T> und jedes klassische Array.

Ein komplettes Beispiel, in dem eine ListBox an eine Collection gebunden wird, wollen wir uns nun ansehen.


// ---------------------------------------------------------
// Beispiel: ...\Kapitel 21\ListBoxBinding
// ---------------------------------------------------------
<Window ... >
<Grid>
  <Grid.RowDefinitions>
    <RowDefinition Height="120" />
    <RowDefinition Height="30"/>
    <RowDefinition Height="30"/>
  </Grid.RowDefinitions>
  <ListBox Grid.Column="0" Name="lstPersonen" 
           ItemsSource="{Binding}"
           DisplayMemberPath="Name"/>
  <Button Grid.Row="1" Height="30" Name="btnAddPerson" 
          Click="btnAddPerson_Click">Hinzufügen
  </Button>
  <Button Grid.Row="2" Height="30" Name="btnShowPerson" 
          Click="btnShowPerson_Click">Abrufen
  </Button>
</Grid>
</Window>

Hier ist noch der C#-Code dazu:


public partial class MainWindow : Window {
  private ObservableCollection<Person> personen = 
                         new ObservableCollection<Person>();
  public MainWindow() {         
    personen.Add(new Person("Meier", 67));
    personen.Add(new Person("Fischer", 23));
    personen.Add(new Person("Schmidt", 45));
    personen.Add(new Person("Serna", 26));
    personen.Add(new Person("Müller", 39));
    InitializeComponent();
    this.DataContext = personen;
    lstPersonen.SelectedIndex = 3;
  }
  private void btnAddPerson_Click(object sender, RoutedEventArgs e){
    personen.Add(new Person("Walter", 54));
  }
  private void btnShowPerson_Click(object sender, RoutedEventArgs e){
    Person p = (Person)lstPersonen.SelectedItem;
    MessageBox.Show(p.Name + " / " + p.Alter);
  }       
}

Abbildung 21.3 Ausgabe des Beispielprogramms »ListBoxBinding«

Im Konstruktor des Window wird eine Liste vom Typ der generischen Collection ObservableCollection mit Person-Objekten gefüllt. Die Bindung der Collection erfolgt an die Eigenschaft DataContext des Window. Mit SelectedIndex wird das Element mit dem Index 3 in der Liste vorselektiert. Des Weiteren enthält der Code zwei Ereignishandler für zwei sich im Window befindliche Buttons. Der erste Button gestattet das Hinzufügen eines weiteren Person-Objekts, der zweite wertet mit SelectedItem den aktuell selektierten Eintrag in der ListBox aus. Bei dem zurückgelieferten Element handelt es sich um das entsprechende Person-Objekt. Nach vorhergehender Konvertierung können die Eigenschaften des Objekts ausgewertet werden.

Im XAML-Codes wird die ListBox mit


ItemsSource="{Binding}"

an die Datenquelle gebunden. Mit der Eigenschaft DisplayMemberPath geben wir eine zusätzliche Information, was aus dem Datenobjekt angezeigt werden soll.



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