![\"Beispiel](\"..\/fileadmin\/_temp_\/2019_06\/pic_196_001.png\")
<\/p>\nEines der Hauptkonzepte von WPF ist es, dass Steuer-elemente über entsprechende Bindungsattribute an die Datenquellen gebunden werden. Es gibt verschiedene Datenquellen: einfache Eigenschaften, Objekte oder Auflistungen. In dieser Artikelreihe schauen wir uns an, wie Sie die gängigsten Steuer-elemente an verschiedene Datenquellen binden und welche Attribute dazu benötigt werden. Den Beginn macht das Textbox-Steuerelement.<\/b><\/p>\nBinden statt zuweisen<\/h2>\n
Die WPF-Philosophie setzt im Gegensatz etwa zu den Formularen unter Access verstärkt auf die Datenbindung und weniger darauf, dass Steuer-elemente per Code auf bestimmte Datenquellen oder Werte eingestellt werden. Wir schauen uns den Unterschied in einem ersten Beispiel an.<\/p>\n
Hier experimentieren wir einfach nur mit Textfeldern für die drei Eigenschaften Vorname<\/b>, Nachname <\/b>und Ort<\/b>. Das Fenster, in dem wir diese Beispiele darstellen, heißt BindenAnEigenschaft<\/b> und enthält in einem Grid neben zwei Bezeichnungsfeldern jeweils ein Textfeld und eine Schaltfläche pro Zeile (siehe Bild 1). Das erste Textfeld namens txtVorname <\/b>soll beim Öffnen des Fensters per Code in der Code behind-Klasse mit einem Wert gefüllt werden.<\/p>\n
<\/p>\n
Bild 1: Beispiel für mit Daten gefüllte Textfelder im Entwurf<\/span><\/b><\/p>\n Ein Klick auf die Schaltfläche soll den Wert des Textfeldes dann ebenfalls durch Zuweisung per VB ändern. Das erledigen wir, indem wir dem Fenster die folgende Konstruktor-Methode zuweisen, die beim Erstellen des Fensters ausgelöst wird. Der Befehl InitializeComponent <\/b>sorgt dafür, dass das Fenster auf Basis der XAML-Definition des Fensters erstellt wird und die zweite Anweisung weist der Eigenschaft Text <\/b>des Textfeldes txtVorname <\/b>den Wert André <\/b>zu:<\/p>\n Das sorgt dafür, dass das Textfeld direkt nach dem Öffnen den gewünschten Wert anzeigt. Neben dem Textfeld befindet sich die Schaltfläche cmdNameAendern<\/b>. Für dieses hinterlegen wir die folgende Ereignismethode:<\/p>\n Die Methode wird durch einen Klick auf die Schaltfläche ausgelöst. Sie weist der Eigenschaft Text <\/b>den Wert Michael <\/b>zu. Diese Art der Anzeige von Daten in Steuerelementen soll unter WPF optimalerweise nicht praktiziert werden.<\/p>\n Beim zweiten Textfeld txtNachname <\/b>verwenden wir den Ansatz der Bindung vom WPF-Steuerelement aus. Dazu hinterlegen wir im Code behind-Modul des Fensters eine öffentliche Eigenschaft namens Nachname<\/b>:<\/p>\n Dieser Eigenschaft weisen wir in der Konstruktor-Methode New <\/b>einen Wert zu. Außerdem stellen wir für die Eigenschaft DataContext <\/b>den Wert Me <\/b>ein. Damit legen wir fest, dass die aktuelle Klasse als Datenquelle für das WPF-Fenster verwendet werden soll:<\/p>\n Somit können wir in den Steuerelementen im WPF-Fenster auf die öffentlich deklarierten Eigenschaften des Code behind-Moduls zugreifen, zum Beispiel auf die Eigenschaft Nachname<\/b>. Das zweite Textfeld txtNachname <\/b>wollen wir auf diese Weise mit dem Wert füllen, den wir in der New<\/b>-Methode der Eigenschaft Nachname <\/b>zugewiesen haben.<\/p>\n Die XAML-Definition des Textfeldes statten wir dazu mit dem Wert {Binding Nachname} <\/b>für das Attribut Text <\/b>aus:<\/p>\n Starten wir nun das Projekt, zeigt das Textfeld den im Konstruktor zur Eigenschaft Nachname <\/b>zugewiesenen Wert Minhorst <\/b>an. Die Schaltfläche cmdNachnameAendernGebunden <\/b>soll den Wert im Textfeld ändern, indem es der Eigenschaft, an das dieses Textfeld gebunden ist, einen neuen Wert zuweist. Dazu programmieren wir seine Ereignismethode wie folgt:<\/p>\n Das hat aber beim Testen keinen Effekt – der Wert des Textfeldes ändert sich nicht. Der Grund ist einfach: Wir müssen bei der Änderung der Eigenschaft ein Ereignis auslösen, durch die das daran gebundene Steuer-element erfährt, dass der Wert der Eigenschaft geändert wurde. Dazu nutzen wir die INotifyPropertyChanged<\/b>-Schnittstelle. Wie diese genutzt wird, zeigen wir am dritten Textfeld txtOrt <\/b>und der im Code behind-Modul definierten Eigenschaft Ort<\/b>.<\/p>\n Um die IPropertyNotifyChanged<\/b>-Schnittstelle zu implementieren, sind folgende Schritte nötig:<\/p>\n Im Code sieht das Ergebnis wie folgt aus. Im Kopf des Moduls platzieren wir den Verweis auf den System.ComponentModel<\/b>-Namespace:<\/p>\n Die Implementierung der Schnittstelle geben wir durch das Implements-Schlüsselwort in einer neuen Zeile hinter der Klassenbezeichnung an:<\/p>\n Klicken Sie dann mit der rechten Maustaste auf INotifyPropertyChanged <\/b>und wählen Sie den Eintrag Schnellaktionen und Refactorings… <\/b>aus dem nun erscheinenden Kontextmenü aus. Dies liefert ein Popup, mit dem Sie den Befehl Schnittstelle implementieren <\/b>auswählen.<\/p>\n Das ergänzt die folgende Zeile mit der Definition des Ereignisses PropertyChanged<\/b>:<\/p>\n Wir fügen dann diese Methode hinzu, um das enthaltene Auslösen des oben definierten Ereignisses nicht für jede Eigenschaft neu schreiben zu müssen:<\/p>\n Stattdessen können wir einen vereinfachten Aufruf in den Setter der Eigenschaft schreiben. Den Setter erstellen wir nebst dem Getter, indem wir die Eigenschaft ebenfalls mit der rechten Maustaste anklicken und wieder den Befehl Schnellaktionen und Refactorings… <\/b>aufrufen. Diesmal führen wir den Befehl In vollständige Eigenschaft konvertieren <\/b>in dem danach angezeigten Popup aus und erzeugen aus der einfachen Property<\/b>-Eigenschaft das folgende Konstrukt:<\/p>\n Wir haben hier schon die entscheidende Anweisung hinzugefügt, nämlich den Aufruf der Methode OnPropertyChanged <\/b>für die als Parameter angegebene Eigenschaft Ort<\/b>. Um zu prüfen, ob der Inhalt des Textfeldes nun automatisch geändert wird, wenn wir den Wert der Eigenschaft anpassen, nutzen wir die durch die Schaltfläche btnOrtGebunden <\/b>ausgelöste Methode:<\/p>\n Möchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>Public Sub <\/span>New()\r\n InitializeComponent()\r\n txtVorname.Text = \"André\"\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cmdNameAendern_Click(sender As Object<\/span>, e As <\/span>RoutedEventArgs)\r\n txtVorname.Text = \"Michael\"\r\nEnd Sub<\/span><\/pre>\nBindung an eine Eigenschaft der Code behind-Klasse<\/h2>\n
Public Property <\/span>Nachname As String<\/span><\/pre>\nPublic Sub <\/span>New()\r\n InitializeComponent()\r\n DataContext = Me\r\n Nachname = \"Minhorst\"\r\nEnd Sub<\/span><\/pre>\n<TextBox x:Name=\"txtNachname\" ... Text=\"{Binding Nachname}\"><\/TextBox><\/pre>\nPrivate Sub <\/span>CmdNachnameAendernGebunden_Click(sender As Object<\/span>, e As <\/span>RoutedEventArgs)\r\n Nachname = \"Müller\"\r\nEnd Sub<\/span><\/pre>\nTextfeld bei Eigenschaftsänderungen aktualisieren<\/h2>\n
\n
Imports System.ComponentModel<\/pre>\n
Public Class<\/span> BindenAnEigenschaft\r\n Implements INotifyPropertyChanged<\/pre>\n Public <\/span>Event PropertyChanged As <\/span>PropertyChangedEventHandler Implements INotifyPropertyChanged.PropertyChanged<\/pre>\n Protected Overridable Sub OnPropertyChanged(propname As String<\/span>)\r\n RaiseEvent PropertyChanged(Me, New<\/span> PropertyChangedEventArgs(propname))\r\n End Sub<\/pre>\nPrivate <\/span>_Ort As String<\/span>\r\nPublic Property <\/span>Ort As String<\/span>\r\n Get\r\n Return _Ort\r\n End Get\r\n Set<\/span>\r\n _Ort = Value\r\n OnPropertyChanged(\"Ort\")\r\n End Set<\/span>\r\nEnd Property<\/span><\/pre>\nPrivate Sub <\/span>BtnOrtGebunden_Click(sender As Object<\/span>, e As <\/span>RoutedEventArgs)\r\n Ort = \"Mülheim\"\r\nEnd Sub<\/span><\/pre>\n
\nHier geht es zur Bestellung des Jahresabonnements des Magazins Visual Basic Entwickler<\/strong>:<\/span>
\nZur Bestellung ...<\/a><\/span>
\nDanach greifen Sie sofort auf alle rund 200 Artikel<\/strong> unseres Angebots zu - auch auf diesen hier!<\/span>
\nOder haben Sie bereits Zugangsdaten? Dann loggen Sie sich gleich hier ein:<\/span><\/p>\n<\/div>\n\n\t\n\t