{"id":55000149,"date":"2018-10-01T00:00:00","date_gmt":"2020-03-27T19:34:17","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=149"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Von_Access_zu_Entity_Framework_Daten","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/Von_Access_zu_Entity_Framework_Daten\/","title":{"rendered":"Von Access zu Entity Framework: Daten"},"content":{"rendered":"

\"Beispiel<\/p>\n

Bild 1: Beispiel für ein zu migrierendes Datenmodell<\/span><\/b><\/p>\n

Viele Leser dieses Magazins programmieren auch mit Access. Daher haben wir im Artikel “Von Access zu Entity Framework: Datenmodell” bereits gezeigt, wie Sie die meisten Elemente eines Datenmodells in Klassen für ein Entity Data Model überführen, die Sie dann wiederum zum Erstellen einer SQL Server-Datenbank per Code First nutzen können. Was fehlt, sind allerdings noch die Daten in diesen Tabellen. Wie Sie den Code erstellen, um auch die Daten über eine entsprechend Seed-Methode in die Datenbank zu schreiben, erfahren Sie in diesem Artikel.<\/b><\/p>\n

Im Artikel Von Access zu Entity Framework: Datenmodell <\/b>haben wir uns darum gekümmert, das Datenmodell unserer kleinen Access-Beispielanwendung aus Bild 1 zuerst in die Klassen eines Entity Data Models zu überführen. Dann haben wir mit den Methoden Add-Migration <\/b>und Update-Database <\/b>in der Paket-Manager-Konsole dafür gesorgt, dass diese Klassen zusammen mit den passenden DbSet<\/b>-Auflistungen in eine neue SQL Server-Datenbank überführt wurden. Die dort vorgestellten Routinen sind sicher noch nicht perfekt, aber sie sind eine gute Grundlage, die Sie selbst erweitern können – oder Sie teilen uns einfach mit, bei welchen Eigenarten von Tabellendefinitionen oder Datenmodellen die Erstellung des Entity Data Models oder der SQL Server-Datenbank noch nicht funktioniert.<\/p>\n

\"Beispiel<\/p>\n

Bild 1: Beispiel für ein zu migrierendes Datenmodell<\/span><\/b><\/p>\n

Im vorliegenden Artikel nun wollen wir die Daten in diesen Tabellen in eine Form bringen, in der wie diese beim Erstellen der Datenbank von Visual Studio aus mit der Seed<\/b>-Methode direkt in die frisch angelegten Tabellen schreiben können. Die Grundlagen dafür erhalten Sie im Artikel Entity Framework: Tabellen füllen<\/b> sowie in den beiden Artikeln Entity Framework: Datenbankinitialisierung <\/b>und Entity Framework: Datenbankmigration<\/b>.<\/p>\n

Anlegen der Daten für eine einzelne Tabelle ohne Fremdschlüsselfelder<\/h2>\n

Wir wollen uns langsam an die Lösung der Aufgabe heranbewegen und uns zuerst einmal eine einfache Tabelle heraussuchen, deren Daten wir dann über den Weg der Seed<\/b>-Methode etwa der Configuration<\/b>-Klasse im Migrations<\/b>-Ordner nach dem Erstellen des Datenmodells in die Datenbank schreiben (wie Sie diesen Ordner erstellen, erfahren Sie im Artikel Entity Framework: Datenbankmigration<\/b>).<\/p>\n

Die Tabelle tblAnreden <\/b>unserer Ausgangsdatenbank enthält nur zwei Datensätze (siehe Bild 2). Diese wollen wir nun in einem ersten Schritt in Anweisungen schreiben, die wir in die Seed<\/b>-Methode der .NET-Anwendung schreiben können. Wir schauen uns erst einmal an, wie die fertige Seed<\/b>-Methode anschließend aussehen soll:<\/p>\n

\"Die<\/p>\n

Bild 2: Die Tabelle tblAnreden der Ausgangsdatenbank<\/span><\/b><\/p>\n

Namespace Migrations\r\n     Friend NotInheritable Class Configuration \r\n         Inherits DbMigrationsConfiguration(Of BestellverwaltungContext)\r\n         Public <\/span>Sub New()\r\n             AutomaticMigrationsEnabled = False<\/span>\r\n         End Sub\r\n         Protected Overrides Sub Seed(context As <\/span>BestellverwaltungContext)\r\n             context.Anreden.AddOrUpdate(Function(x) x.ID,\r\n                 New<\/span> Anrede() With<\/span> {.Name = \"Herr\"},\r\n                 New<\/span> Anrede() With<\/span> {.Name = \"Frau\"}\r\n             )\r\n         End Sub\r\n     End Class\r\nEnd Namespace<\/pre>\n
Wir sollten uns überlegen, ob wir per VBA immer die komplette Klasse namens Configuration <\/b>wie oben abgebildet erstellen sollen oder nur die Seed<\/b>-Methode in dieser Klasse. Praktischer ist es vermutlich, gleich die komplette Klasse zu erstellen, damit man entweder – im ersten Schritt – die Ausgabe dieser Klasse aus dem Direktbereich des VBA-Editors von Access komplett kopieren und als Ganzes in diese Klasse einsetzen kann. Im zweiten Schritt könnten wir den Code direkt in die entsprechende Datei schreiben, die dann von Visual Studio aktualisiert eingelesen wird.<\/p>\n
Die Seed<\/b>-Methode enthält hier eine Anweisung, bei der wir die AddOrUpdate<\/b>-Methode der Auflistung Anreden <\/b>aufrufen und dieser eine Funktion übergeben, welche jeweils ein neues Objekt auf Basis der Klasse Anrede <\/b>enthält. Für diese legen wir dann jeweils die Anrede fest.<\/p>\n
Wir bauen zunächst eine Prozedur, welche den Rahmen im Direktfenster ausgibt, also die Imports<\/b>-Anweisungen, den Namespace, die Klasse und die enthaltenen Methoden – mit Ausnahme der Seed<\/b>-Methode:<\/p>\n
Public Sub <\/span>SeedErstellen()\r\n     Dim <\/span>strSeed As String<\/span>\r\n     strSeed = strSeed & \"Imports System\" & vbCrLf<\/span>\r\n     strSeed = strSeed & \"Imports System.Data.Entity\"\r\n     strSeed = strSeed & \"Imports System.Data.Entity.Migrations\"\r\n     strSeed = strSeed & \"Imports System.Linq\"\r\n     strSeed = strSeed & \"\"\r\n     strSeed = strSeed & \"Namespace Migrations\"\r\n     strSeed = strSeed & \"    Friend NotInheritable Class Configuration\"\r\n     strSeed = strSeed & \"        Inherits DbMigrationsConfiguration(Of BestellverwaltungContext)\"\r\n     strSeed = strSeed & \"        Public Sub New()\"\r\n     strSeed = strSeed & \"            AutomaticMigrationsEnabled = False\"\r\n     strSeed = strSeed & \"        End Sub\"\r\n     strSeed = strSeed & \"        Protected Overrides Sub Seed(context As <\/span>BestellverwaltungContext)\"\r\n     strSeed = strSeed & SeedData\r\n     strSeed = strSeed & \"        End Sub\"\r\n     strSeed = strSeed & \"    End Class\"\r\n     strSeed = strSeed & \"End Namespace\"\r\nEnd Sub<\/span><\/pre>\n
Das ist noch kein Hexenwerk. Interessant ist die hier eingebettete Prozedur SeedData<\/b>. Diese stellt die Anweisungen zusammen, die wir zur Methode Seed <\/b>hinzufügen wollen. Statisch sieht das für unsere Tabelle tblAnreden <\/b>zunächst wie folgt aus:<\/p>\n
Public Sub <\/span>SeedData()\r\n     Dim <\/span>strSeedData As String<\/span>\r\n     strSeedData = strSeedData & \"            context.Anreden.AddOrUpdate(Function(x) x.ID,\"\r\n     strSeedData = strSeedData & \"                New<\/span> Anrede() With<\/span> {.Name = \"\"Herr\"\"},\"\r\n     strSeedData = strSeedData & \"                New<\/span> Anrede() With<\/span> {.Name = \"\"Frau\"\"}\"\r\n     strSeedData = strSeedData & \"            )\"\r\n     SeedData = strSeedData\r\nEnd Sub<\/span><\/pre>\n
Um dies aus VBA heraus dynamisch für die Tabelle tblAnreden <\/b>zu erzeugen, müssen wir dies allerdings mit einigen erst zur Laufzeit ermittelten Daten füllen. Das erledigen wir in den folgenden Schritten.<\/p>\n
Seed für mehrere Tabellen<\/h2>\n
Die Prozedur SeedData <\/b>wandeln wir in eine Funktion um, die das Ergebnis an die aufrufende Prozedur zurückgeben soll. Sie enthält dafür für jede Tabelle der Datenbank einen Aufruf der Tabelle SeedData <\/b>und fügt das Ergebnis jeweils an die Zeichenkette strSeed <\/b>an. Die Aufrufe der Tabellen erledigen wir in einer For Each<\/b>-Schleife über alle TableDef<\/b>-Elemente der mit CurrentDb <\/b>referenzierten aktuellen Datenbank. In der Schleife prüfen wir zunächst, ob es sich bei der aktuellen Tabelle nicht um eine Systemtabelle von Access handelt. Nur wenn das nicht der Fall ist, rufen wir die Funktion SeedData <\/b>mit dem Namen der Tabelle auf. Den Namen der Tabelle ermitteln wir dabei mit der Eigenschaft Name <\/b>des TableDef<\/b>-Objekts.<\/p>\n
Public Sub <\/span>SeedErstellen()\r\n     ...\r\n     strSeed = strSeed & \"        Protected Overrides Sub Seed(context As <\/span>BestellverwaltungContext)\" & vbCrLf<\/span>\r\n     For Each tdf In db.TableDefs\r\n         If <\/span>Not<\/span> Left<\/span>(tdf.Name, 4) = \"MSYS\" Then<\/span>\r\n             strSeed = strSeed & SeedData(tdf.Name) & vbCrLf<\/span>\r\n         End If<\/span>\r\n     Next<\/span> tdf    strSeed = strSeed & \"        End Sub\" & vbCrLf<\/span>\r\n     strSeed = strSeed & \"    End Class\" & vbCrLf<\/span>\r\n     strSeed = strSeed & \"End Namespace\"\r\n     Inzwischenablage strSeed\r\nEnd Sub<\/span><\/pre>\n
Am Ende der Prozedur nutzen wir die Prozedur InZwischenablage<\/b>, um den Inhalt der Variablen strSeed<\/b>, in der wir die Anweisungen für die Configuration.vb<\/b>-Klasse gesammelt haben, in die Zwischenablage zu kopieren. Das ist eine bessere Lösung als die Ausgabe im Direktbereich, weil dieser nur eine begrenzte Anzahl Zeichen aufnehmen kann und bei vielen Daten der obere Teil der Ausgabe dann nicht mehr verfügbar ist. Die Prozedur InZwischenablage <\/b>finden Sie im Modul mdlZwischenablage<\/b>.<\/p>\n
Die Funktion SeedData zum Zusammenstellen der AddOrUpdate-Aufrufe<\/h2>\n
Die Funktion SeedData <\/b>bohren wir gegenüber der vorherigen Version erheblich auf. Als Erstes fällt der Parameter strTabelle <\/b>auf, welcher die Information enthält, für die Datensätze welcher Tabelle die AddOrUpdate<\/b>-Methoden zusammengestellt werden sollen.<\/p>\n
Public Function <\/span>SeedData(strTabelle As String<\/span>) As String<\/span>\r\n     Dim <\/span>db As <\/span>DAO.Database\r\n     Dim <\/span>rst As <\/span>DAO.Recordset\r\n     Dim <\/span>strSeedData As String<\/span>\r\n     Dim <\/span>strPK As String<\/span>\r\n     Dim <\/span>strFelder As String<\/span>\r\n     Dim <\/span>fld As <\/span>DAO.Field\r\n     Dim <\/span>strEntity As String<\/span>\r\n     Dim <\/span>strEntities As String<\/span>\r\n     Dim <\/span>strProperty As String<\/span><\/pre>\n
Nach der Deklaration der Variablen speichern wir einen Verweis auf die aktuelle Datenbank in der Variablen db<\/b>. Dann prüfen wir mit der Funktion GetPrimaryKey<\/b>, die wir bereits im Artikel Von Access zu Entity Framework: Datenmodell <\/b>erläutert haben, ob die gerade untersuchte Tabelle genau ein Primärschlüsselfeld bereitstellt. Ist das der Fall, wird eine entsprechende Meldung im Direktbereich ausgeben und die Funktion wird mit Exit Function <\/b>verlassen:<\/p>\n
     Set<\/span> db = CurrentDb\r\n     If <\/span>Not<\/span> GetPrimaryKey(strTabelle, strPK) Then<\/span>\r\n         Debug.Print<\/span> \"    ''Mehrere PKs in \" & strTabelle & \". Die Klasse wird nicht erstellt.\"\r\n         Exit Function<\/span><\/pre>\n
Kann jedoch genau ein Primärschlüsselfeld gefunden werden, landet dies in der Variablen strPK<\/b>. Daraus ermitteln wir zunächst den Namen der Entität, indem wir hinten die Zeichenkette ID <\/b>entfernen. Außerdem ermittelten wir den Namen der Tabelle, indem wir vom Tabellenname vorn tbl <\/b>abtrennen und das Ergebnis in der Variablen strEntitaeten <\/b>speichern:<\/p>\n
     Else<\/span>\r\n         strEntity = Replace<\/span>(strPK, \"ID\", \"\")\r\n         strEntities = Replace<\/span>(strTabelle, \"tbl\", \"\")<\/pre>\n
Damit starten wir in die Ermittlung der benötigten Daten, indem wir ein Recordset auf Basis der mit strTabelle<\/b> übergebenen Tabelle erstellen. Außerdem tragen wir die erste Zeile in die Variable strSeedData <\/b>ein, welche zum Beispiel bei der Tabelle tblAnreden <\/b>nun context.Anreden.AddOrUpdate(Function(x) x.ID, <\/b>lautet:<\/p>\n
         Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM \" & strTabelle, dbOpenDynaset)\r\n         strSeedData = strSeedData & \"            context.\" & strEntities & \".AddOrUpdate(Function(x) x.ID,\" & vbCrLf<\/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