{"id":55000165,"date":"2019-02-01T00:00:00","date_gmt":"2020-03-27T19:36:06","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=165"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Access_zu_WPF_Detailformulare_mit_Textfeldern","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/Access_zu_WPF_Detailformulare_mit_Textfeldern\/","title":{"rendered":"Access zu WPF: Detailformulare mit Textfeldern"},"content":{"rendered":"

Wir haben uns bereits in einigen Artikel angesehen, wie Sie Übersichtsformulare, Detailformulare und so weiter unter WPF anlegen. Was aber, wenn Sie keine Lust haben, die Formulare unter WPF alle neu zu programmieren, obwohl Sie das schon unter Access erledigt haben In diesem Artikel schauen wir uns an, wie die programmgesteuerten Möglichkeiten aussehen, um Formulare automatisch als WPF-Fenster oder -Seiten abzubilden. Es wird ein wenig Handarbeit übrig bleiben, aber einen großen Teil der Schritte können Sie sich damit deutlich erleichtern. <\/b><\/p>\n

Voraussetzungen<\/h2>\n

Wir gehen an dieser Stelle davon aus, dass Sie bereits ein Entity Data Model auf Basis des Access-Datenmodells erstellt und eine entsprechende SQL Server-Datenbank auf Basis des Entity Data Modells erstellt haben. Wie das gelingt, zeigen die Artikel Von Access zu Entity Framework: Datenmodell <\/b>und Von Access zu Entity Framework: Daten<\/b> aus Ausgabe 5\/2018.<\/p>\n

Nun wollen wir versuchen, die Migration einfacher Formulare von Access aus in funktionsfähige WPF-Fenster zu erreichen.<\/p>\n

Beispiel: Kundenformular<\/h2>\n

Unser Beispiel finden Sie in der Beispieldatenbank Bestellverwaltung.accdb <\/b>im Download zu diesem Artikel. Wir wollen das Formular frmKundendetails <\/b>als WPF-Fenster nachbauen. Das Formular sehen Sie in Bild 1 in der Entwurfsansicht. Es verwendet die Tabelle tblKunden <\/b>als Datensatzquelle. Die Textfelder sind jeweils an entsprechende Felder der Datensatzquelle des Formulars gebunden. Das Kombinationsfeld cboAnredeID <\/b>verwendet die Abfrage SELECT [tblAnreden].[AnredeID], [tblAnreden].[Anrede] FROM tblAnreden; <\/b>als Datensatzherkunft und ist an das Feld AnredeID <\/b>gebunden. Für das erste Feld der Datensatzherkunft haben wir die Spaltenbreite auf 0cm <\/b>eingestellt, damit dieses nicht angezeigt wird. Es erscheint also nur das zweite Feld der Datensatzherkunft.<\/p>\n

\"Das<\/p>\n

Bild 1: Das Formular frmKunden in der Formularansicht<\/span><\/b><\/p>\n

Projekt erstellen<\/h2>\n

Wir erstellen ein neues Projekt namens AccessZuWPFFormulare <\/b>und führen die im Artikel Von Access zu EF: Step by step <\/b>aus Ausgabe 5\/2018 beschriebenen Schritte aus, um die Tabellenentwürfe und Daten der Tabellen unserer Beispieldatenbank als Entity Data Model hinzuzufügen. Das gelingt innerhalb von ungefähr fünf Minuten, wenn Sie die Beispieldatenbank dazu verwenden. Für andere Datenbanken haben wir dies noch nicht getestet. Wenn Sie versuchen, andere Datenbanken zu migrieren und auf Fehler stoßen, teilen Sie uns das gern mit. Wir benötigen dann allerdings eine Kopie des Datenmodells im Access-Format, damit wir damit experimentieren und unsere Tools verbessern können (per E-Mail an andre@minhorst.com<\/b>).<\/p>\n

Zum Testen der migrierten Datenbank verwenden Sie eine neue Schaltfläche auf der Seite MainWindow.xaml<\/b>, welche die folgende Methode aufruft:<\/p>\n

Private Sub <\/span>btnTestDatabase_Click(sender As Object<\/span>, e As <\/span>RoutedEventArgs)\r\n     Dim <\/span>dbContext As <\/span>BestellverwaltungContext\r\n     Dim <\/span>Kunden As <\/span>ObservableCollection(Of Kunde)\r\n     dbContext = New<\/span> BestellverwaltungContext\r\n     Kunden = New<\/span> ObservableCollection(Of Kunde)(dbContext.Kunden)\r\n     MessageBox.Show(\"Anzahl Kunden: \" + Kunden.Count().ToString())\r\nEnd Sub<\/span><\/pre>\n
Danach sollte beim Starten des Projekts und Anklicken der Schaltfläche ein Meldungsfenster mit der Anzahl der Datensätze der Tabelle Kunden <\/b>erscheinen.<\/p>\n
Vom Formular zu WPF<\/h2>\n
Nun schauen wir uns an, was für eine Aufgabe überhaupt vor uns liegt. Wir wollen das Formular frmKundendetails <\/b>aus der Access-Datenbank als Fenster der WPF-Anwendung abbilden. Was benötigen wir dazu Zunächst einmal ist soll das Fenster die Größe erhalten, die auch unser Access-Formular aufweist. Dann wollen wir die Steuer-elemente auslesen und im WPF-Fenster anlegen. Diese sollen, genau wie das Fenster, mit den Eigenschaften zum Binden des Fensters und der Steuer-elemente an die Daten versehen werden. Schließlich fehlen noch die Ereignisprozeduren, die durch die Steuer-elemente und das Formular selbst ausgelöst werden.<\/p>\n
Wir wollen zunächst von Access aus starten und hier Code schreiben, mit dem wir die notwendigen Informationen aus dem Formularentwurf auslesen und daraus automatisiert die XAML-Definition für das WPF-Fenster sowie den Inhalt der Code behind-Daten für das Fenster erstellen. Diesen kopieren wir dann zunächst von Hand in ein neues Fenster-Element in unserem Projekt.<\/p>\n
Fenstergröße<\/h2>\n
Wir beginnen einmal mit einer vermeintlich einfachen Aufgabe: dem Ermitteln der Fenstergröße und dem Erstellen des Code-Elements, welches diese beiden Eigenschaften enthält. Wenn wir die Eigenschaften im Eigenschaftenblatt von Access ansehen, erhalten wir Angaben in der Einheit Zentimeter, also beispielsweise 9,198cm <\/b>für die Formularbreite und 9,198cm <\/b>für die Höhe des Detailbereichs. Geben wir die Eigenschaften Width <\/b>des Form-Elements und Me.Height <\/b>des Detailbereichs (Me.Section(0).Height<\/b>) aus, erhalten wir Werte wie 4535 <\/b>und 5215<\/b>. Wenn wir die Eigenschaften in der XAML-Definition betrachten, finden wir Werte wie 450 <\/b>für die Eigenschaft Height <\/b>und 800 <\/b>für die Eigenschaft Width<\/b>. Wir müssen die Zahlen also noch umrechnen. Die Größe und Breite unter Visual Studio wird in Pixel angegeben. Unter Access werden diese Werte in Twips angegeben. Zur Umrechnung von Twips in Pixel gibt es ausreichend Funktionen, von denen wir zwei im Modul mdlUmrechnungen <\/b>der Beispieldatenbank eingefügt haben. Sie heißen TwipsToPixelHeight <\/b>und TwipsToPixelWidth<\/b>. Wir benötigen zwei Funktionen, weil die Faktoren für die Umrechnungen unterschiedlich sein können.<\/p>\n
Basisprozedur<\/h2>\n
Damit legen wir nun die Basis für das Erstellen des WPF-Codes. Die benötigte VBA-Prozedur sieht wie folgt aus, wobei wir zunächst einige Variablen deklarieren:<\/p>\n
Public Sub <\/span>FormularNachWPF()\r\n     Dim <\/span>frm As <\/span>Form\r\n     Dim <\/span>strForm As String<\/span>\r\n     Dim <\/span>strXAML As String<\/span>\r\n     Dim <\/span>lngHeight As Long<\/span>\r\n     Dim <\/span>lngWidth As Long<\/span>\r\n     Dim <\/span>strTitle As String<\/span><\/pre>\n
Dann öffnen wir das Formular in der Entwurfsansicht und weisen dieses der Variablen frm <\/b>zu:<\/p>\n
     strForm = \"frmKundendetails\"\r\n     DoCmd.OpenForm strForm, acDesign\r\n     Set<\/span> frm = Forms(strForm)<\/pre>\n
Dann ermitteln wir mit den Umrechnungsfunktionen die Höhe und Breite:<\/p>\n
     lngHeight = TwipsToPixelsHeight(frm.Section(0).Height)\r\n     lngWidth = TwipsToPixelswidth(frm.Width)<\/pre>\n
Außerdem prüfen wir, ob ein Titel für das Formular angegeben wurde und schreiben diesen oder alternativ den Formularnamen in die Variable strTitle<\/b>:<\/p>\n
     If <\/span>Not<\/span> Len<\/span>(frm.Caption) = 0 Then<\/span>\r\n         strTitle = frm.Caption\r\n     Else<\/span>\r\n         strTitle = frm.Name\r\n     End If<\/span><\/pre>\n
Schließlich bauen wir den grundlegenden XAML-Code für das Fenster zusammen, wobei wir den standardmäßig verwendeten Code nutzen und unsere ermittelten Werte für Fenstername, Titel, Höhe und Breite an den entsprechenden Stellen einfügen:<\/p>\n
     strXAML = strXAML & \"<Window x:Class=\"\"\" & frm.Name & \"\"\"\" & vbCrLf<\/span>\r\n     strXAML = strXAML & \"        xmlns=\"\"http:\/\/schemas.microsoft.com\/winfx\/2006\/xaml\/presentation\"\"\" & vbCrLf<\/span>\r\n     strXAML = strXAML & \"        xmlns:x=\"\"http:\/\/schemas.microsoft.com\/winfx\/2006\/xaml\"\"\" & vbCrLf<\/span>\r\n     strXAML = strXAML & \"        xmlns:d=\"\"http:\/\/schemas.microsoft.com\/expression\/blend\/2008\"\"\" & vbCrLf<\/span>\r\n     strXAML = strXAML & \"        xmlns:mc=\"\"http:\/\/schemas.openxmlformats.org\/markup-compatibility\/2006\"\"\" & vbCrLf<\/span>\r\n     strXAML = strXAML & \"        xmlns:local=\"\"clr-namespace:AccessZuWPFFormulare\"\"\" & vbCrLf<\/span>\r\n     strXAML = strXAML & \"        mc:Ignorable=\"\"d\"\"\" & vbCrLf<\/span>\r\n     strXAML = strXAML & \"        Title=\"\"\" & strTitle & \"\"\" Height=\"\"\" & lngHeight & \"\"\" Width=\"\"\" & lngWidth & \"\"\">\" & vbCrLf<\/span>\r\n     strXAML = strXAML & \"    <Grid>\" & vbCrLf<\/span><\/pre>\n
Dazwischen platzieren wir den Aufruf der Prozedur Steuer-elementeHinzufuegen<\/b>, die wir im Anschluss erstellen – für den ersten Testlauf bleibt diese auskommentiert:<\/p>\n
     ''SteuerelementeHinzufuegen frm, strXAML\r\n     strXAML = strXAML & \"    <\/Grid>\" & vbCrLf<\/span>\r\n     strXAML = strXAML & \"<\/Window>\" & vbCrLf<\/span><\/pre>\n
Schließlich nutzen wir die Prozedur InZwischenablage<\/b>, um den Inhalt der String-Variablen strXAML <\/b>in die Zwischenablage zu kopieren (siehe mdlZwischenablage<\/b>) und schließen das Formular wieder:<\/p>\n
     Inzwischenablage strXAML\r\n     DoCmd.Close acForm, strForm\r\nEnd Sub<\/span><\/pre>\n
Wenn Sie diese Prozedur ausführen und den Inhalt der Zwischenablage als XAML-Code eines neuen Fensters einsetzen, erhalten Sie die Ansicht aus Bild 2.<\/p>\n
\"Höhe,<\/p>\n
Bild 2: Höhe, Breite, Titel und Name wurden vom Access-Formular übernommen<\/span><\/b><\/p>\n
Ob dieses Fenster unseren Ansprüchen genügt, müssen wir allerdings noch herausfinden – dazu benötigen wir im Fenster MainWindows.xaml <\/b>noch eine Schaltfläche, mit der wir das neu erstellte Fenster öffnen können. Diese soll den folgenden Code ausführen:<\/p>\n
Private Sub <\/span>btnKundendetails_Click(sender As Object<\/span>, e As <\/span>RoutedEventArgs)\r\n     Dim <\/span>Kundendetails As <\/span>frmKundendetails\r\n     Kundendetails = New<\/span> frmKundendetails()\r\n     Kundendetails.Show()\r\nEnd Sub<\/span><\/pre>\n
Steuer-elemente migrieren<\/h2>\n
Als nächstes wollen wir uns um die Steuerelemente kümmern. Den folgenden Aufruf haben wir ja schon im Code platziert – Sie müssen nur noch die Markierung als Kommentar entfernen:<\/p>\n
    SteuerelementeHinzufuegen frm, strXAML<\/pre>\n
Die Prozedur selbst erwartet die beiden übergebenen Parameter, nämlich einen Verweis auf das Formular (frm<\/b>) und die Variable zum Zusammenstellen des XAML-Codes (strXAML<\/b>). Damit starten wir in die erste Rohfassung der Prozedur:<\/p>\n
Public Function <\/span>SteuerelementeHinzufuegen(frm As <\/span>Form, strXAML As String<\/span>)\r\n     Dim <\/span>ctl As <\/span>Control\r\n     Dim <\/span>lngWidth As Long<\/span>\r\n     Dim <\/span>lngHeight As Long<\/span>\r\n     Dim <\/span>lngTop As Long<\/span>\r\n     Dim <\/span>lngLeft As Long<\/span>\r\n     Dim <\/span>strCaption As String<\/span><\/pre>\n
In dieser durchlaufen wir alle Steuer-elemente des Formulars über die Controls<\/b>-Auflistung und referenzieren das aktuelle Steuer-element jeweils mit der Variablen ctl<\/b>. Hier tragen wir zunächst die Größe und die Position in die entsprechenden Variablen ein:<\/p>\n
     For Each ctl In frm.Controls\r\n         lngWidth = TwipsToPixelsWidth(ctl.Width)\r\n         lngHeight = TwipsToPixelsHeight(ctl.Height)\r\n         lngTop = TwipsToPixelsHeight(ctl.Top)\r\n         lngLeft<\/span> = TwipsToPixelsWidth(ctl.Left)<\/pre>\n
Dann prüfen wir in einer Select Case<\/b>-Schleife, welchen Typ das aktuell mit ctl <\/b>referenzierte Steuer-element hat. In diesem Fall haben wir zunächst die Typen acTextBox <\/b>und acLabel <\/b>untersucht und fügen für jedes Bezeichnungsfeld und jedes Textfeld eine Zeile zu strXAML <\/b>hinzu, welche das Aussehen des jeweiligen Steuerelements beschreibt:<\/p>\n
         Select Case ctl.ControlType\r\n             Case <\/span>acTextBox\r\n                 strXAML = strXAML & \"<TextBox x:Name=\"\"\" & ctl.Name & \"\"\" FontFamily=\"\"Calibri\"\" FontSize=\"\"\" _\r\n                     & ctl.FontSize & \"pt\"\" HorizontalAlignment=\"\"Left\"\" Height=\"\"\" & lngHeight & \"\"\" Margin=\"\"\" _\r\n                     & lngLeft<\/span> & \",\" & lngTop & \",0,0\"\" TextWrapping=\"\"Wrap\"\" Text=\"\"TextBox\"\" \" _\r\n                     & \"VerticalAlignment=\"\"Top\"\" Width=\"\"\" & lngWidth & \"\"\"\/>\" & vbCrLf<\/span>\r\n             Case <\/span>acLabel\r\n                strCaption = ctl.Caption\r\n                 strXAML = strXAML & \"<Label x:Name=\"\"\" & ctl.Name & \"\"\" Content=\"\"\" & strCaption _\r\n                     & \"\"\" FontFamily=\"\"Calibri\"\" FontSize=\"\"11pt\"\" Padding=\"\"0\"\" \" _\r\n                     & \"VerticalContentAlignment=\"\"Center\"\" HorizontalAlignment=\"\"Left\"\" Height=\"\"\" & lngHeight _\r\n                     & \"\"\" Margin=\"\"\" & lngLeft<\/span> & \",\" & lngTop & \",0,0\"\" VerticalAlignment=\"\"Top\"\" Width=\"\"\" & lngWidth _\r\n                     & \"\"\"\/>\" & vbCrLf<\/span>\r\n             Case <\/span>acCommandButton\r\n             Case <\/span>acComboBox\r\n             Case Else<\/span>\r\n                 Debug.Print<\/span> \"Steuerelementtyp nicht behandelt: \" & ctl.Name, ctl.ControlType\r\n         End Select<\/span>\r\n     Next<\/span> ctl\r\nEnd Function<\/span><\/pre>\n
Möchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>
\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
\n\n\t\t\n\t\t