{"id":55000175,"date":"2019-04-01T00:00:00","date_gmt":"2020-03-27T19:37:21","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=175"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Validieren_mit_VB_und_EDM","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/Validieren_mit_VB_und_EDM\/","title":{"rendered":"Validieren mit VB und EDM"},"content":{"rendered":"

Im Artikel EDM: Validieren von Entitäten mit IDataErrorInfo haben wir bereits erläutert, wie Sie einer auf dem Entity Framework basierenden Anwendung eine Validierung hinzufügen können. Im vorliegenden Artikel schauen wir uns an, wie Sie die Validierung nicht unter C#, sondern unter VB realisieren und welche Änderungen in den Methoden zum Migrieren einer Access-Anwendung nach WPF\/EDM notwendig sind, um die Validierung vorzubereiten oder gegebenenfalls auch direkt umzusetzen.<\/b><\/p>\n

Für die Programmierung einer Validierung in den Klassen des Entity Data Models und der mit WPF definierten Benutzeroberfläche sind einige Schritte auf den verschiedenen Ebenen erforderlich. Der erste ist, die Entitätsklassen mit der Implementierung der Schnittstelle IDataErrorInfo <\/b>zu versehen, die zweite die Definition der Anzeige der Validierungsmeldungen in der Benutzeroberfläche – und das geschieht durch entsprechende WPF-Elemente.<\/p>\n

IDataErrorInfo – wo implementieren<\/h2>\n

Im oben genannten Artikel haben wir unter C# die Schnittstelle IDataErrorInfo<\/b> für partielle Klassen implementiert. Das bedeutet, dass wir zwei gleichnamige Klassen programmiert haben, wobei wir in der einen die Definition der Properties und in der anderen die Implementierung der Schnittstelle IDataErrorInfo <\/b>eingefügt haben. Warum haben wir das dort so gemacht Weil wir den Code für die Entitätsklassen aus dem Datenmodell der Datenbank generiert haben, was bedeutet, dass wir bei Änderungen des Datenmodells auch die Entitätsklassen neu generieren mussten. Wenn wir dann die Implementierung der Schnittstelle IDataErrorInfo <\/b>in der automatisch generierten Entitätsklasse programmiert hätte, wäre diese bei jeder Aktualisierung wieder überschrieben worden. Deshalb haben wir diese Definition direkt in eigenen, partiellen Klassen programmiert. Partielle Klasse bedeutet dabei, dass wir einfach eine weitere Klasse gleichen Namens mit dem Schlüsselwort Partial <\/b>erstellt und dort die Elemente für die Implementierung der Schnittstelle hineingeschrieben haben. Die Klassenbezeichnungen der per Generator erzeugten Entitätsklassen wurden dabei praktischerweise bereits mit dem Schlüsselwort Partial ausgezeichnet – was keinen Nachteil bringt, auch wenn es keine weiteren partiellen Klassen mehr gibt.<\/p>\n

Nun verwenden wir in der aktuell in diesem Magazin beschriebenen Vorgehensweise eine Access-Datenbank als Vorlage für die Erstellung eines Entity Data Models und auch für die Erstellung von Fenstern auf Basis der Formulare der Access-Datenbank. Wir könnten also theoretisch auch gleich die Implementierung der Schnittstelle IDataErrorInfo <\/b>in die Entitätsklassen schreiben – und hier direkt die im Datenmodell festgelegten Restriktionen wie keine Nullwerte et cetera eintragen. Allerdings kann es auch hier sein, dass Sie die Implementierung der Schnittstelle IDataErrorInfo<\/b> selbst anpassen wollen. Also werden wir auch hier mit partiellen Klassen arbeiten und per Parameter beim Erstellen des Entity Data Models auf Basis der Tabellen der Access-Datenbank die Möglichkeit bieten, entweder nur das Entity Data Model zu erstellen oder auch noch die partiellen Klassen mit den Validierungsfunktionen neu zu generieren. Zunächst schauen wir uns allerdings an, wie die partiellen Klassen unter VB überhaupt aussehen sollen.<\/p>\n

Partielle Klasse mit IDataErrorInfo erstellen<\/h2>\n

Das Anlegen der zusätzlichen partiellen Klasse etwa für die Klasse Kunde <\/b>erfordert zwei Schritte. Als Erstes fügen wir der eigentlichen Klasse das Schlüsselwort Partial <\/b>als erstes Schlüsselwort noch vor Public <\/b>hinzu:<\/p>\n

<Table(\"Kunden\")>\r\nPartial Public Class Kunde\r\n     ...\r\nEnd Class<\/span><\/pre>\n
Danach können wir die zweite partielle Klasse erstellen:<\/p>\n
Partial Public Class Kunde\r\n     ...\r\nEnd Class<\/span><\/pre>\n
Für diese Klasse wollen wir nun die Schnittstelle IDataErrorInfo <\/b>implementieren. Dazu benötigen wir zunächst die Bibliothek System.ComponentModel<\/b>, die wir per Imports<\/b>-Anweisung hinzufügen:<\/p>\n
Imports System.ComponentModel<\/pre>\n
Danach fügen Sie in der Zeile unter der Klassendefinition die Anweisung zur Implementierung der Schnittstelle hinzu:<\/p>\n
Partial Public Class Kunde\r\n     Implements IDataErrorInfo<\/pre>\n
    …<\/p>\n
Wenn Sie mit der rechten Maustaste auf IDataErrInfo <\/b>klicken, erscheint der Kontextmenü-Eintrag Schnellaktionen und Refactorings…<\/b>, den Sie anklicken und danach den nun erscheinenden Befehl Schnittstelle implementieren <\/b>anklicken (siehe Bild 1).<\/p>\n
\"Automatisches<\/p>\n
Bild 1: Automatisches Implementieren der Schnittstelle<\/span><\/b><\/p>\n
Das füllt die Klasse mit den beiden Properties Item <\/b>und [Error]<\/b>:<\/p>\n
Partial Public Class Kunde\r\n     Implements IDataErrorInfo\r\n     Default Public ReadOnly Property Item(columnName As String<\/span>) As String<\/span> Implements IDataErrorInfo.Item\r\n         Get\r\n             Throw New<\/span> NotImplementedException()\r\n         End Get\r\n     End Property\r\n     Public <\/span>ReadOnly Property [Error] As String<\/span> Implements IDataErrorInfo.Error\r\n         Get\r\n             Throw New<\/span> NotImplementedException()\r\n         End Get\r\n     End Property\r\nEnd Class<\/span><\/pre>\n
Uns interessiert dabei speziell die Property <\/b>namens Item<\/b>. Diese liefert mit dem Parameter columnName <\/b>den Namen des Feldes, für das eine Validierung durchgeführt werden soll. Um eine Validierung für das Feld Vorname <\/b>durchzuführen, die prüfen soll, ob das Feld Vorname <\/b>leer ist, fügen Sie die folgende Select Case<\/b>-Bedingung mit dem Case<\/b>-Zweig für den Feldnamen Vorname <\/b>hinzu. Die Prüfung stellt mit der Methode IsNullOrEmpty <\/b>fest, ob Vorname <\/b>leer ist. In diesem Fall wird der Rückgabeparameter strErrorMessage <\/b>mit einer entsprechenden Fehlermeldung gefüllt:<\/p>\n
Default Public ReadOnly Property Item(columnName As String<\/span>) As String<\/span> Implements IDataErrorInfo.Item\r\n     Get\r\n         Dim <\/span>strErrorMessage As String<\/span> = \"\"\r\n         Select Case columnName\r\n             Case <\/span>\"Vorname\"\r\n                 If <\/span>(String.IsNullOrEmpty(Vorname)) Then<\/span>\r\n                     strErrorMessage = \"Bitte geben Sie einen Vornamen ein.\"\r\n                 End If<\/span>\r\n         End Select<\/span>\r\n         Return strErrorMessage\r\n     End Get\r\nEnd Property<\/span><\/pre>\n
Nun stellt sich nur noch die Frage, wodurch diese Methode aufgerufen wird und wie wir die Fehlermeldung aus strErrorMessage <\/b>verarbeiten.<\/p>\n
Auslösen der Validierung<\/h2>\n
Dass für das Feld Vorname <\/b>eine Validierung ausgelöst wird, legen wir in der Definition des an dieses Feld gebundenen Steuerelements fest, in diesem Fall des Textfeldes txtVorname<\/b>. Hier erweitern wir den Inhalt der Bindung für das Attribut Text <\/b>um ValidatesOnDataErrors=True<\/b>:<\/p>\n
<TextBox x:Name=\"txtVorname\" Text=\"{Binding Kunde.Vorname, ValidatesOnDataErrors=True}\" Height=\"21\" Margin=\"118,58,0,0\" Width=\"221\"\/><\/pre>\n
Damit allein wird nun bereits die Validierung ausgelöst, das heißt, wenn das Feld Vorname <\/b>angezeigt wird, ruft dies auch die Methode Item <\/b>der Implementierung von IDataErrorInfo <\/b>auf. Das Ergebnis ist allerdings noch keine Anzeige der Meldung, sondern zunächst nur das rote Einrahmen des Feldes, das nicht erfolgreich validiert werden konnte (siehe Bild 2).<\/p>\n
\"Die<\/p>\n
Bild 2: Die Validierung funktioniert bereits.<\/span><\/b><\/p>\n
Wir wollen allerdings noch konkretere Hinweise auf den Grund für die farbige Markierung liefern, damit der Benutzer weiß, was zu tun ist. Also verwenden wir den Setter, den wir auch schon im oben genannten Artikel genutzt haben, um die Fehlermeldung an entsprechender Stelle unterzubringen. Dazu erweitern wir den Code für das Style<\/b>-Element in der .xaml<\/b>-Datei wie folgt:<\/p>\n
<Style TargetType=\"{x:Type TextBox}\">\r\n     ...\r\n     <Setter Property=\"Validation.ErrorTemplate\">\r\n         <Setter.Value>\r\n             <ControlTemplate>\r\n                 <DockPanel>\r\n                     <Border Background=\"Red\" DockPanel.Dock=\"right\" Margin=\"5,0,0,0\" Width=\"20\" Height=\"20\"                             CornerRadius=\"10\" ToolTip=\"{Binding ElementName=customAdorner,                             Path=AdornedElement.(Validation.Errors)[0].ErrorContent}\">\r\n                         <TextBlock Text=\"!\" VerticalAlignment=\"center\" HorizontalAlignment=\"center\"                            FontWeight=\"Bold\" Foreground=\"white\" \/>\r\n                     <\/Border>\r\n                     <AdornedElementPlaceholder Name=\"customAdorner\" VerticalAlignment=\"Center\" >\r\n                         <Border BorderBrush=\"red\" BorderThickness=\"1\" \/>\r\n                     <\/AdornedElementPlaceholder>\r\n                 <\/DockPanel>\r\n             <\/ControlTemplate>\r\n         <\/Setter.Value>\r\n     <\/Setter>\r\n<\/Style><\/pre>\n
Danach erscheint die Meldung, die wir für das Feld Vorname<\/b> definiert haben, wie in Bild 3.<\/p>\n
\"Validierung<\/p>\n
Bild 3: Validierung mit Hinweismeldung<\/span><\/b><\/p>\n
Validierung von Kombinationsfeldern<\/h2>\n
Für die Validierung des Kombinationsfeldes Anrede <\/b>fügen Sie in der .xaml<\/b>-Datei für die Definition des Style<\/b>-Elements für den Typ ComboBox <\/b>genau die gleiche Property namens Validation.ErrorTemplate <\/b>wie für den Typ TextBox <\/b>hinzu:<\/p>\n
<Style TargetType=\"{x:Type ComboBox}\">\r\n     ...\r\n     <Setter Property=\"Validation.ErrorTemplate\">\r\n     ...\r\n     <\/Setter>\r\n<\/Style><\/pre>\n
Außerdem passen Sie in der Definition des ComboBox<\/b>-Elements das Attribut SelectedItem <\/b>so an, dass die Bindung mit der Option ValidatesOnDataErrors=True <\/b>erfolgt:<\/p>\n
<ComboBox x:Name=\"cboAnredeID\" Padding=\"0\" Height=\"21\" Margin=\"118,111,0,0\" Width=\"78\"\r\n     ItemsSource = \"{Binding Anreden}\"\r\n     SelectedItem = \"{Binding Kunde.Anrede, ValidatesOnDataErrors=True}\"\r\n     ...\r\n<\/ComboBox><\/pre>\n
Schließlich erweitern wir die Implementierung der Schnittstelle IDataErrorInfo <\/b>noch um einen entsprechenden Case<\/b>-Zweig. Hier verwenden wir allerdings die IsNothing<\/b>-Funktion, um zu prüfen, ob für die Eigenschaft Anrede <\/b>eines der Elemente der Auflistung Anreden <\/b>zugewiesen wurde:<\/p>\n
Default Public ReadOnly Property Item(columnName As String<\/span>) As String<\/span> Implements IDataErrorInfo.Item\r\n     Get\r\n         Dim <\/span>strErrorMessage As String<\/span> = \"\"\r\n         Select Case columnName\r\n             ...\r\n             Case <\/span>\"Anrede\"\r\n                 If <\/span>(IsNothing(Anrede)) Then<\/span>\r\n                     strErrorMessage = \"Bitte wählen Sie eine Anrede aus.\"\r\n                 End If<\/span>\r\n         End Select<\/span>\r\n         Return strErrorMessage\r\n     End Get\r\nEnd Property<\/span><\/pre>\n
Verlassen des Datensatzes ohne erfolgreiche Validierung unterbinden<\/h2>\n
Nun müssen wir noch sicherstellen, dass der Benutzer den Datensatz nicht verlassen kann, ohne dass alle erforderlichen Daten eingegeben wurden. Dazu haben wir im oben genannten Artikel eine Technik kennengelernt, die auf den Ergebnissen unserer Validierung aufbaut und davon abhängig Steuer-elemente aktiviert oder deaktiviert. Dabei haben wir für die betroffene Schaltfläche DataTrigger<\/b>-Element als Style<\/b>-Elemente festgelegt und für jeden Trigger eine Bedingung formuliert, unter der eine bestimmte Eigenschaft auf einen Wert eingestellt werden soll – in diesem Fall etwa der Wert der Validierung eines oder mehrerer gebundener Steuer-elemente und damit verbunden die Eigenschaft IsEnabled <\/b>der zu deaktivierenden Schaltfläche.<\/p>\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