Public Class<\/span> Article\r\n Public <\/span>Property ID As Integer<\/span>\r\n Public <\/span>Property Name As String<\/span>\r\n Public <\/span>Property CategoryID As Integer<\/span>\r\n Public <\/span>Property Category As <\/span>Category\r\n Public <\/span>Property Price As Decimal<\/span>\r\nEnd Class<\/span><\/pre>\nDie zweite Klasse nimmt die Kategorien auf und heißt Categories.cs<\/b>:<\/p>\nPublic Class<\/span> Category\r\n Public <\/span>Property ID As Integer<\/span>\r\n Public <\/span>Property Name As String<\/span>\r\n Public <\/span>Property Articles As <\/span>ICollection(Of Article)\r\nEnd Class<\/span><\/pre>\nDazu kommen zwei Zeilen, welche die Auflistungen der Elemente dieser beiden Klassen repräsentieren. Diese fügen wir in der Klasse ein, die beim Hinzufügen des Entity Data Models angelegt wurde und den Namen ArticleContext.vb <\/b>trägt. Diese sieht dann so aus:<\/p>\nImports System.Data.Entity\r\nPublic Class<\/span> ArticleContext\r\n Inherits DbContext\r\n Public <\/span>Sub New()\r\n MyBase.New(\"name=ArticleContext\")\r\n End Sub\r\n Public <\/span>Property Categories() As <\/span>DbSet(Of Category)\r\n Public <\/span>Property Articles() As <\/span>DbSet(Of Article)\r\nEnd Class<\/span><\/pre>\nDatenbank beim ersten Zugriff erstellen<\/h2>\n
Entity Framework hat einen Mechanismus, der dafür sorgt, dass eine Datenbank automatisch erstellt wird, wenn Sie das erste Mal auf diese zugreifen, aber noch keine Datenbank vorhanden ist. Um dies auszuprobieren, fügen Sie der Code behind-Klasse des Fensters MainWindow.xaml <\/b>zunächst den Konstruktor hinzu und füllen diesen dann mit den folgenden Anweisungen:<\/p>\nClass<\/span> MainWindow\r\n Public <\/span>Sub New()\r\n Using dbContext As <\/span>ArticleContext = New<\/span> ArticleContext\r\n Dim <\/span>MyCategory As <\/span>Category\r\n MyCategory = New<\/span> Category()\r\n MyCategory.Name = \"Getränke\"\r\n dbContext.Categories.Add(MyCategory)\r\n dbContext.SaveChanges()\r\n End Using\r\n End Sub\r\nEnd Class<\/span><\/pre>\nDie Methode New <\/b>erstellt einen neuen Kontext auf Basis der Klasse ArticleContext <\/b>und speichert diese in der Variablen dbContext<\/b>. Dann erstellen wir ein neues Objekt des Typs Category<\/b>, weisen der Eigenschaft Name <\/b>den Wert Getränke <\/b>zu und fügen das neue Objekt zur Auflistung Categories <\/b>des Objekts dbContext <\/b>hinzu. Die Änderungen speichern wir dann mit der Methode SaveChanges<\/b>.<\/p>\n
Nun brauchen Sie die Anwendung nur noch zu starten. Es dauert dann ein wenig länger bis zum Erscheinen des Anwendungsfensters, aber dafür wird in der Zwischenzeit auch gleich die Datenbank erstellt.<\/p>\n
Diese finden Sie dann nach dem Beenden der Anwendung unter Visual Studio im SQL Server-Objekt-Explorer, den Sie mit dem Menübefehl Ansicht|SQL Server-Objekt-Explorer <\/b>einblenden können. Hier klappen Sie den Eintrag Datenbanken <\/b>auf und finden die Datenbank InitializationSample.ArticleContext <\/b>vor (siehe Bild 1).<\/p>\n
![\"Die](\"..\/fileadmin\/_temp_\/2018_05\/pic_146_001.png\")
<\/p>\n
Bild 1: Die neue Datenbank im SQL Server-Objekt-Explorer<\/span><\/b><\/p>\nWenn Sie nun noch das Kontextmenü des Eintrags dbo.Categories <\/b>öffnen und dort den Befehl Daten anzeigen <\/b>auswählen, erscheinen die Daten der Tabelle Categories <\/b>– in diesem Fall der eine in der Konstruktor-Methode angelegte Datensatz mit dem Wert Getränke <\/b>im Feld Name<\/b>.<\/p>\nErgebnisse beim Anlegen der Datenbank<\/h2>\n
Schauen wir uns an, was im Detail geschehen ist. Als Erstes ist festzuhalten: Es wurde eine Datenbank angelegt, und zwar auf dem Server (LocalDb)\\MSSQLLocalDB <\/b>und unter dem Namen InitializationSample.ArticleContext<\/b>.<\/p>\n
Wenn Sie diese Einstellung ändern wollen, können Sie das in der Datei App.config <\/b>(für Desktop-Anwendungen) oder Web.config <\/b>(für Web-Anwendungen) erledigen, wo Sie den folgenden Abschnitt anpassen müssen:<\/p>\n<connectionStrings>\r\n <add name=\"ArticleContext\" connectionString=\"data source=(LocalDb)\\MSSQLLocalDB; initial catalog=InitializationSample.ArticleContext;integrated security=True;MultipleActiveResultSets=True; App=EntityFramework\" providerName=\"System.Data.SqlClient\" \/>\r\n<\/connectionStrings><\/pre>\nWoher weiß Entity Framework, dass es genau diese Verbindungszeichenfolge nutzen soll Wir sehen hier, dass diese den Namen ArticleContext aufweist. Dieser wird in der Konstruktor-Methode der Klasse ArticleContext.vb, die mit dem Entity Data Model erstellt wurde, referenziert:<\/p>\n
Public Sub <\/span>New()\r\n MyBase.New(\"name=ArticleContext\")\r\nEnd Sub<\/span><\/pre>\nWenn Sie also eine andere Verbindungszeichenfolge nutzen wollen, stellen Sie diese hier ein.<\/p>\n
Alternativer Datenbankname<\/h2>\n
Während wir dem New-Konstruktor von MyBase soeben den Namen der Verbindungszeichenfolge übergeben haben, können Sie hier auch den Namen der zu erstellenden Datenbank angeben. Dazu lassen Sie einfach den Namen des Parameters weg und geben direkt den gewünschten Datenbanknamen an, zum Beispiel InitializationSample:<\/p>\n
Public Sub <\/span>New()\r\n MyBase.New(\"InitializationSample\")\r\nEnd Sub<\/span><\/pre>\nSie können aber auch einfach den Namen der Datenbank in der Verbindungszeichenfolge anpassen. Diesen finden Sie unter dem Parameternamen initial catalog.<\/p>\n
Tabellen erstellen<\/h2>\n
Welche Tabellen Entity Framework in der neuen Datenbank erstellen soll, entnimmt es ebenfalls der Klasse ArticleContext.vb. Hier berücksichtigt es einfach alle als DbSet deklarierten öffentlichen Eigenschaften, also aktuell diese hier:<\/p>\n
Public Property <\/span>Categories() As <\/span>DbSet(Of Category)\r\nPublic Property <\/span>Articles() As <\/span>DbSet(Of Article)<\/pre>\nFelder hinzufügen<\/h2>\n
Nun fehlen noch die Felder. Welche Entity Framework hier hinzufügen muss, entnimmt es der Definition der Klassen, die in den DbSet-Objekten angegeben sind (zum Beispiel DbSet(Of Category)).<\/p>\n
Wie Sie die Felder anlegen müssen, damit beispielsweise Beziehungen zwischen den Tabellen in der Zieldatenbank entstehen, erfahren Sie in den Artikeln EDM: 1:n-Beziehungen per Code First, EDM: 1:1-Beziehungen per Code First und EDM: m:n-Beziehungen per Code First.<\/p>\n
Der nächste Start<\/h2>\n
Wenn Sie die Anwendung nun nochmals öffnen, ist die Datenbank bereits vorhanden. Entity Framework muss diese dann nicht erneut anlegen und kann die vorhandene Datenbank verwenden.<\/p>\n
Änderungen am Datenmodell<\/h2>\n
Wenn Sie nun eine Änderung am Datenmodell vornehmen, indem Sie etwa das Feld Description zur Klasse Article hinzufügen, wollen Sie diese Änderung natürlich auch auf das Datenmodell einer eventuell bereits existierenden Datenbank übertragen. Also probieren wir aus, was nach der folgenden Anpassung und einem Neustart der Anwendung geschieht:<\/p>\n
Public Class<\/span> Article\r\n ...\r\n Public <\/span>Property Description As String<\/span>\r\nEnd Class<\/span><\/pre>\nMö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