{"id":55000120,"date":"2018-02-01T00:00:00","date_gmt":"2020-03-27T19:30:31","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=120"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"EDM_Der_Code_FirstAnsatz","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/EDM_Der_Code_FirstAnsatz\/","title":{"rendered":"EDM: Der Code First-Ansatz"},"content":{"rendered":"

In den bisherigen Ausgaben haben wir immer mit dem Database First-Ansatz gearbeitet, das heißt, dass wir unser Entity Data Model auf Basis einer bestehenden Datenbank im SQL Server oder SQLite generiert haben. Das geht auch andersherum: Sie erstellen ein paar Klassen, geben eine Verbindungszeichenfolge an und beim ersten Versuch, auf die Daten der Datenbank zuzugreifen, erstellt die Anwendung automatisch die Datenbank im angegebenen SQL Server. Wie das gelingt und wie die Klassen und die Verbindungszeichenfolge aussehen müssen, erfahren Sie in diesem Beitrag.<\/b><\/p>\n

Als Beispiel wählen wir unsere Anwendung zum Erstellen von Anschreiben mit Word von einem WPF-Fenster aus. Dieser haben wir im ersten Schritt ja nur einfache Textfelder als Eingabemöglichkeit hinzugefügt, in die der Benutzer Anschrift, Datum, Betreff und Inhalt des Anschreibens eintragen kann, bevor daraus ein Word-Dokument auf Basis der gewählten Vorlage erstellt wird. Nun wollen wir dies erweitern – und zwar um die Möglichkeit, sowohl verschiedene Anschriften zu verwalten als auch um die Anschreiben abzuspeichern, um diese gegebenenfalls später noch einmal aufzurufen oder auch als Vorlage für neue Anschreiben zu verwenden.<\/p>\n

Unter Access würden wir das Formular einfach an eine Tabelle zum Speichern der Daten des Anschreibens binden und gegebenenfalls noch eine Tabelle für die verschiedenen Anschriften hinzufügen. Allerdings wollen wir ja in diesem Magazin lernen, mit den unter WPF gängigen Techniken umzugehen – wie etwa dem Entity Data Model als Möglichkeit, Daten zwischen Benutzeroberfläche und Datenbank hin- und herzuschieben.<\/p>\n

In den vorherigen Ausgaben haben wir meist eine vorhandene Datenbank genutzt und mit dem dafür vorgesehenen Assistenten ein Entity Data Model erstellen lassen. Dieses enthält die Klassen und Auflistungen, mit denen wir dann von der Benutzeroberfläche beziehungsweise von der Anwendungslogik aus auf die Daten der Datenbank zugreifen konnten. In diesem Beispiel wollen wir es einmal andersherum versuchen: Wir wollen zuerst die Klassen für die beiden Entitäten programmieren, also für die Anschreiben und die Adressen, und daraus dann ein Datenmodell generieren. Auch dieser Fall ist vom Entity Framework als Möglichkeit vorgesehen und nennt sich Code First. Wir erstellen also erst den Code und lassen daraus dann die Datenbank erzeugen. Das wir für das erste Beispiel eine relativ einfache Konstellation mit nur zwei Entitäten nutzen (okay, mit Anreden für die Adressen vielleicht drei), wird die Komplexität ein wenig vermindern.<\/p>\n

Vorbereitungen<\/h2>\n

Als Erstes erstellen wir ein neues, leeres Projekt namens CodeFirst<\/b> – und zwar mit der Vorlage Visual Basic|Windows|WPF-Anwendung <\/b>oder Visual C#|Windows|WPF-Anwendung<\/b>. Diesem Projekt fügen Sie nach Markierung des Eintrags mit dem Projektnamen CodeFirst <\/b>im Projektmappen-Explorer ein Element des Typs ADO.NET Entity Data Model <\/b>hinzu. Den dazu nötigen Dialog Neues Element hinzufügen… <\/b>öffnen Sie mit der Tastenkombination Strg + Umschalt + A<\/b>. Hier wählen Sie den passenden Elementtyp aus und legen als Name den Wert Wordgenerator <\/b>fest (siehe Bild 1).<\/p>\n

\"Entity<\/p>\n

Bild 1: Entity Data Model zum Projekt hinzufügen<\/span><\/b><\/p>\n

Im folgenden Assistent für Entity Data Model <\/b>wählen Sie den Eintrag Leeres Code First-Modell <\/b>aus (siehe Bild 2). Im Gegensatz zu der Variante, die wir sonst gewählt haben, nämlich EF Designer aus Datenbank<\/b>, ist dies gleichzeitig schon der letzte Schritt in diesem Assistenten, den wir mit einem Klick auf die Schaltfläche Fertigstellen <\/b>beenden.<\/p>\n

\"Modelltyp<\/p>\n

Bild 2: Modelltyp Leeres Code First-Modell auswählen<\/span><\/b><\/p>\n

Diesmal geschieht auch gar nicht viel in unserem Projekt. Die augenscheinlichste Änderung ist, dass der Assistent ein Klassenmodul namens Wordgenerator.vb <\/b>(beziehungsweise Wordgenerator.cs <\/b>unter C#) angelegt hat (siehe Bild 3). Die Klasse Wordgenerator erbt von der Klasse DbContext<\/b>.<\/p>\n

\"Durch<\/p>\n

Bild 3: Durch den Assistenten angelegte Klasse<\/span><\/b><\/p>\n

Modell programmieren<\/h2>\n

Nun programmieren wir die Klassen für unser Modell, auf dessen Basis wir später eine Datenbank erstellen lassen wollen. <\/p>\n

Dazu legen wir drei neue Klassen an – jeweils wieder über die Tastenkombination Strg + Umschalt + A <\/b>und den dadurch aufgerufenen Dialog Neues Element einfügen…<\/b>. Hier wählen wir nun jeweils den Eintrag Klasse aus und legen die Namen Anschreiben.vb<\/b>, Adresse.vb <\/b>und Anrede.vb <\/b>fest. Die Klasse Anrede.vb <\/b>sieht wie folgt aus:<\/p>\n

Public Class<\/span> Anrede\r\n     Public <\/span>Property ID As Integer<\/span>\r\n     Public <\/span>Property Anrede As String<\/span>\r\nEnd Class<\/span><\/pre>\n
Für die Klasse Adresse legen wir den folgenden Code fest, wobei wir als Typ der Eigenschaft Anrede auch gleich die frisch angelegte Klasse gleichen Namens verwenden:<\/p>\n
Public Class<\/span> Adresse\r\n     Public <\/span>Property ID As Integer<\/span>\r\n     Public <\/span>Property Firma As String<\/span>\r\n     Public <\/span>Property Anrede As <\/span>Anrede\r\n     Public <\/span>Property Vorname As String<\/span>\r\n     Public <\/span>Property Nachname As String<\/span>\r\n     Public <\/span>Property Strasse As String<\/span>\r\n     Public <\/span>Property PLZ As String<\/span>\r\n     Public <\/span>Property Ort As String<\/span>\r\n     Public <\/span>Property Land As String<\/span>\r\n     Public <\/span>Property EMail As String<\/span>\r\nEnd Class<\/span><\/pre>\n
Nachdem wir die Klasse Adresse <\/b>erzeugt haben, die wir auch als Collection der Klasse Anrede <\/b>zuordnen wollen – jede Anrede gehört ja zu keiner, einer oder mehreren Adressen -, können wir die Klasse Anrede <\/b>noch um die Auflistung Adressen <\/b>mit dem Typ Adresse <\/b>erweitern:<\/p>\n
Public Class<\/span> Anrede\r\n     ...\r\n     Public <\/span>Property Adressen As <\/span>ICollection(Of Adresse)\r\nEnd Class<\/span><\/pre>\n
Die Klasse Anschreiben <\/b>erhält schließlich die folgenden Eigenschaften:<\/p>\n
Public Class<\/span> Anschreiben\r\n     Public <\/span>Property ID As Integer<\/span>\r\n     Public <\/span>Property Adresse As <\/span>Adresse\r\n     Public <\/span>Property Datum As Date<\/span>\r\n     Public <\/span>Property Betreff As String<\/span>\r\n     Public <\/span>Property Inhalt As String<\/span>\r\nEnd Class<\/span><\/pre>\n
Auch hier können wir nun die Klasse Adresse <\/b>um die Auflistung der Anschreiben ergänzen:<\/p>\n
Public Class<\/span> Adresse\r\n     ...\r\n     Public <\/span>Property Anschreiben As <\/span>ICollection(Of Anschreiben)\r\nEnd Class<\/span><\/pre>\n
Mit der Angabe der beiden ICollections <\/b>in den Klassen Anschreiben <\/b>und Adresse <\/b>legen wir praktisch die 1:n-Beziehung zwischen den Klassen fest. Damit kann dann eine Adresse mehreren Anschreiben zugeordnet werden und eine Anrede mehreren Adressen.<\/p>\n
Auflistungen in der DBContext-Klasse definieren<\/h2>\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