{"id":55000027,"date":"2016-04-01T00:00:00","date_gmt":"2020-03-27T19:17:51","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=27"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Bindung_zwischen_Steuerelementen","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/Bindung_zwischen_Steuerelementen\/","title":{"rendered":"Bindung zwischen Steuerelementen"},"content":{"rendered":"

Unter VBA waren die Möglichkeiten der Datenbindung überschaubar: Formulare, Berichte und einige Steuerelemente wiesen entsprechende Eigenschaften auf, die an Tabellen, Abfragen oder auch Wertlisten oder Felder geknüpft werden konnten. Unter WPF und C# sieht es ganz anders aus. Hier stehen Objekte im Vordergrund. Dieser Artikel zeigt daher zunächst, wie Sie Elemente wie Steuerelemente an die Eigenschaften anderer Elemente binden.<\/b><\/p>\n

Einführung<\/h2>\n

Wenn Sie zuvor mit Access programmiert haben und dieses Magazin lesen, um zu erfahren, wie das, was Sie zuvor mit Access erledigt haben, mit C#\/WPF gelingt, wollen Sie vermutlich nur eins: Daten aus Tabellen oder Abfragen in Fenstern und Steuerelementen anzeigen und diese zum Bearbeiten bereitstellen. Beim Thema Datenbindung ist WPF\/C# allerdings etwas breiter aufgestellt, da es nicht nur auf Datenquellen wie Tabellen oder Abfragen fixiert ist, sondern primär auf Objekte als Datenlieferant.<\/p>\n

Daher räumen wir das Feld etwas weiter auf und beginnen nicht gleich damit, die Daten per Fenster und Steuerelementen bereitzustellen. Zunächst einmal schauen wir uns an, wie Sie verschiedene Elemente aneinander binden können. Davon abgesehen haben Sie ja in vorhergehenden Artikeln der Kategorie Datenzugriffstechnik <\/b>bereits einige Beispiele erhalten, wie dies gelingt. Grundsätzlich dient die Bindung aber dazu, nicht nur die Eigenschaften eines Elements an ein anderes Element zu binden, sondern die gebundenen Daten können auch aus Quellen wie einer XML-Datei, Auflistungen oder Datenbanken stammen.<\/p>\n

Von Textfeld zu Textfeld<\/h2>\n

Im ersten Beispiel wollen wir schlicht und einfach, dass ein Textfeld den Inhalt eines anderen Textfeldes anzeigt. Unter Access\/VBA haben Sie dazu das Nach Aktualisierung<\/b>-Ereignis genutzt – oder auch das Bei Änderung<\/b>-Ereignis. Das Erste hat beispielsweise auf die Eingabe- oder Tabulatortaste reagiert, Letzteres auf jede einzelne Änderung des Inhalts. Etwas eleganter konnten Sie dies erledigen, wenn Sie das erste Textfeld gleich der Eigenschaft Steuerelementinhalt <\/b>des zweiten Textfeldes zugewiesen haben. Damit war noch nicht einmal mehr Code notwendig, um den Inhalt des ersten Textfeldes nach Änderungen in das zweite Textfeld zu übertragen.<\/p>\n

Unter WPF\/C# wollen wir uns gleich um die zweite Variante kümmern, also das zweite Textfeld an das erste Textfeld binden. Dazu fügen Sie einem Fenster eines neuen Projekts zwei Textfelder namens txtFeld1 <\/b>und txtFeld2 <\/b>hinzu:<\/p>\n

<Window x:Class=\"Datenbindung.MainWindow\" ... Title=\"MainWindow\" Height=\"350\" Width=\"525\">\r\n     <Grid>\r\n         <Label x:Name=\"lbl1\" ... \/>\r\n         <Label x:Name=\"lbl2\" ... \/>\r\n         <TextBox x:Name=\"txtFeld1\" ... \/>\r\n         <TextBox x:Name=\"txtFeld2\" ... \/>\r\n     <\/Grid>\r\n<\/Window><\/pre>\n
Damit können Sie nun den Inhalt der beiden Textfelder beliebig ändern – es tut sich nichts. Dies ändern wir, indem wir die Methode MainWindow <\/b>im C#-Modul des Fensters wie folgt um vier Zeilen erweitern:<\/p>\n
public MainWindow() {\r\n     InitializeComponent();\r\n     Binding binding = new Binding();\r\n     binding.ElementName = \"txtFeld1\";\r\n     binding.Path = new PropertyPath(\"Text\");\r\n     txtFeld2.SetBinding(TextBox.TextProperty, binding);\r\n}<\/pre>\n
Diese vier Zeilen binden das zweite Feld so an das erste Feld, dass dieses immer den Inhalt des ersten Feldes anzeigt (siehe Bild 1). In diesem Fall werden Änderungen am Text des ersten Textfeldes direkt in das zweite Textfeld übertragen. Änderungen am zweiten Textfeld landen erst nach dem Verlassen im ersten Textfeld – wie Sie dieses Verhalten ändern, erfahren Sie weiter unten.<\/p>\n
\"Das<\/p>\n
Bild 1: Das untere Textfeld ist an das obere Textfeld gebunden.<\/span><\/b><\/p>\n
Schauen wir uns die vier Zeilen im Detail an. Die erste Zeile erzeugt ein neues Objekt des Typs Binding<\/b>:<\/p>\n
Binding binding = new Binding();<\/pre>\n
Die zweite Zeile weist der Eigenschaft ElementName <\/b>des Binding<\/b>-Objekts den Namen des ersten Textfelds txtFeld1 <\/b>zu:<\/p>\n
binding.ElementName = \"txtFeld1\";<\/pre>\n
Im Gegensatz zu Access\/VBA, wo sich der Steuerelementinhalt eines Steuerelements immer auf den Steuerelementinhalt des angegebenen Quellsteuerelements bezogen hat, können Sie unter WPF alle Eigenschaften des mit Source angegebenen Objekts als Quellwert nutzen. In diesem Fall ist dies die Eigenschaft Text<\/b>, die wir als neues PropertyPath<\/b>-Objekt der Eigenschaft Path <\/b>des Binding<\/b>-Objekts zuweisen:<\/p>\n
binding.Path = new PropertyPath(\"Text\");<\/pre>\n
Schließlich müssen wir noch festlegen, welches Steuerelement das neue Binding<\/b>-Objekt nutzen soll und welches die Zieleigenschaft ist. Dies erledigen wir mit der Methode SetBinding <\/b>wie in der folgenden Anweisung. Der erste Parameter ist die Zieleigenschaft, hier TextProperty<\/b>, der zweite das Binding<\/b>-Objekt:<\/p>\n
txtFeld2.SetBinding(TextBox.TextProperty, binding);<\/pre>\n
Die Binding-Klasse und die Dependency Property<\/h2>\n
Die hier verwendete Binding<\/b>-Klasse legt also fest, wie die Bindung zwischen einer Komponente wie etwa einem Steuerelement und der Datenquelle, hier die Eigenschaft eines Steuerelements, erfolgt. Dabei haben wir hier bereits die folgenden Eigenschaften genutzt:<\/p>\n