Entity Framework Übersicht

Übersicht über das Entity Framework

Description: Im ersten Modul wird der Aufbau des Entity Frameworks vorgestellt und eine Übersicht über die verschiedenen Workflows gegeben. Demos gibt es zu Code-First, Database-First und Model-First.

Duration: PT23M20S

ContentUrl: https://sec.ch9.ms/ch9/394e/16226ed5-2640-413f-99b7-390e10b2394e/01UebersichtueberdasEntityFramework_mid.mp4

EmbedUrl: https://channel9.msdn.com/Series/Einfuehrung-in-das-Entity-Framework/01--bersicht-ber-das-Entity-Framework/player

UploadDate: 2015-03-20T12:40:00+02:03

Thumbnail



Einführung in folgende Workflows: Code-FirstDatabase-First  und  Model-First


CODE FIRST - DEMO (Installation)

Eine englische Version von Code-First findet ihr auf der MSDN-Webseite. Erstelle eine neue Konsolenanwendung mit dem Namen "1_CodeFirst". Um das EntityFramework verwenden zu können, müssen wir zuerst das NuGet-Packet hinzufügen. Klicke dafür auf folgendes:

Neues NuGet Packet importieren auswählen

In dem geöffneten Fenster das EntityFramework auswählen und auf "Installieren" klicken. Darauf müssen die Nutzungsbedingungen zugestimmt werden und es ist fertig installiert.

Installieren des EntityFramework NuGet-Packet

Nun erstellen wir eine neue Klasse, die unser Datenmodell repräsentiert. Wegen der Übersichtlichkeit erstellen wir in unserem Projekt einen neuen Ordner (Rechtsklick auf Projekt -> Hinzufügen -> Neuer Ordner ) mit dem Namen "Model". Erstelle nun zwei neue Klassen mit Rechtsklick auf den Ordner -> Hinzufügen -> Klasse ( eine mit dem Namen "Author" und eine mit dem Namen "Book" ). Jede Klasse wird eine eigene Tabelle in der Datenbank werden. Jede Variable in der Klasse wird zu einem Attribut, also einer Spalte in der Tabelle. Die "Author"-Klasse würde so aussehen:
Tipp: um die Properties generieren zu lassen tippe "prop" und drücke zweimal auf die Tabulatortaste.

public class Author
{
public int Id { get; set; }
public string Name { get; set; }
public DateTime Birthday { get; set; }
}

Nun erstellen wir die Properties für das Buch. Ein Buch wurde von einem Author geschrieben, daher müssen wir einen Fremdschlüssel zu dem Author erstellen, aber wie? Ein Fremdschlüssel in der Tabelle sieht in der Klasse folgendermaßen aus: Eine Variable, die auf die ID des Eintrags verweist und eine Variable mit dem Schlüsselwort "virtual" mit der anderen Klasse. Das könnte zum Beispiel so aussehen:

public class Book
{
public int Id { get; set; }
public string Name { get; set; }
public int AuthorId { get; set; }
public virtual Author Author { get; set; }
}

Erstellen des Datenbank-Context:

Erstelle dazu eine neue Klasse in dem Ordner "Model" namens "LibraryContext" und leite diese Klasse von DbContext ab. Womöglich wird es die Ableitung als einen Fehler ansehen, da DbContext nicht erkannt wird. Füge dazu das "using System.Data.Entity" hinzu. Lege in deiner LibraryContext-Klasse zwei Properties für jede Klasse an.

public class LibraryContext : DbContext
{
public DbSet<Author> Authors { get; set; }
public DbSet<Book> Books { get; set; }
}

Verwenden der Datenbank im Code:

class Program
{
static void Main(string[] args)
{
using (var db = new LibraryContext())
{
Author a = new Author { Name = "J.R.R. Tolkien", Birthday = new DateTime(1892, 1, 3) };
Book lotr = new Book { Name = "Herr der Ringe", Author = a };
db.Authors.Add(a);
db.Books.Add(lotr);
db.SaveChanges();
}
}
}

Das using ( ------------- ) { } wird aus dem Grund verwendet, dass die Datenbankverbindung nur solange geöffnet ist, bis der Code ausgeführt wurde. Nachdem der Code innerhalb des using() {} ausgeführt wurde, schließt sich die Datenbankverbindung. In unserer Datenbank (LibraryContext) können wir zu den Variablen Authors und Books unsere Objekte hinzufügen. Wichtig: Nachdem Änderungen an der Datenbank erfolgten, sollte man die Änderungen speichern mit db.SaveChanges(); Führt man das Programm aus, passiert in der Konsole zwar nichts, aber im Hintergrund wird die Datenbank erstellt und diese Werte werden eingefügt. Nachdem man das Programm ausgeführt hat, kann man in den Server-Explorer gehen -> Rechtsklick auf Datenverbindungen -> Verbindung hinzufügen -> Standard Servername eintragen -> Datenbankname auswählen -> OK

Verbindung zu Datenbank herstellen

Um den Inhalt der Tabelle zu sehen öffnet man die Datenverbindungen -> Tabellen -> Rechtsklick auf eine Tabelle -> Tabellendaten anzeigen

Inhalt der Tabelle einer Datenbank ansehen

Um die Werte aus der Datenbank in der Konsole auszugeben, ersetzen wird das Einfügen von Werten, durch den Code für das Ausgeben der Werte. Der Zugriff auf die DatenbankSets in der LibraryContext-Klasse erfolgt über die Datenbankverbindung, die man in dem "using"-Statement hergestellt hat. Geben wir zunächst alle Bücher aus der Datenbank in der Konsole aus.

foreach (var book in db.Books)
{
Console.WriteLine("{0} - {1}", book.Author.Name, book.Name);
}

Console.ReadLine();

Die geschwungenen Klammern in dem Statement für die Konsolenausgabe sind Platzhalter für die Strings, die man als Parameter angibt. Die Nummerierung innerhalb der geschwungenen Klammern steht für die Position des Übergabeparameters, beginnend bei null. Der Zugriff auf den Authoren über das Buch funktioniert durch einen sogenannten Fremdschlüssel. Das bedeutet, dass ein Buch mit dem Fremdschlüssel 1, den Authoren mit der ID eins sucht.

Um alle Bücher eines Authoren auszugeben, wäre die Variante, jedes Buch zu prüfen ob es der richtige Author ist, ziemlich aufwendig. Eine bessere Methode wäre eine Liste von Bücher in der Authorenklasse zu erstellen. Die Liste ist von dem Typ "ICollection" und wird im Konstruktor der Klasse auf eine leere Liste gesetzt, sodass der Inhalt nicht "null" ist. Die Autorenklasse sieht nun folgendermaßen aus:

public class Author
{
public int Id { get; set; }
public string Name { get; set; }
public DateTime Birthday { get; set; }

public virtual ICollection<Book> Books { get; set; }
public Author()
{
Books = new List<Book>();
}
}

Die Suche nach einem bestimmten Author in einem Set erfolgt mittels Linq-Kommandos. Die Methode .First() hat als Rückgabewert den ersten Wert in der Liste. Fügt man als Parameter in der Methode eine Lambda-Expression ein, wird der erste Wert zurückgegeben, der die Bedingung erfüllt. Der Aufbau dieser Lambda-Expression (bei der .First()-Methode) sieht folgendermaßen aus:   <Übergangsparameter>  =>  <Bedingung> Der Übergangsparameter ist von dem Datentyp des Sets. Bei "Books" wäre der Parameter vom Typ "Book". Geben wir mal alle Bücher eines Authors mit dem Namen "Tolkien", den es in der Datenbank gibt, aus. Dazu verändern wir den Inhalt des "using"-Statements auf folgendes:

using (var db = new LibraryContext())
{
var tolkien = db.Authors.First(a => a.Name.Contains("Tolkien"));
Console.WriteLine("Bücher von {0}", tolkien.Name);

foreach (var book in db.Books)
{
Console.WriteLine("{0} - {1}", book.Author.Name, book.Name);
}
}

Console.ReadLine();

DATABASE-FIRST - DEMO

Da wir aus dem vorherigen Beispiel schon eine Datenbank besitzen, erstellen wir aus dieser ein Entity-Data-Model. Achtung: Es muss eine Datenbankverbindung im Server-Explorer vorhanden sein. Zum Erstellen eines Entity-Data-Models, klickt man mit der rechten Maustaste auf das Projekt

Erstellen einer Datenbank-Model-file

Nach dem Klick auf "Hinzufügen" erscheint ein Fenster, wo wir "Ein Diagramm aus einer Datenbank erstellen" anklicken und auf "Weiter" drücken. Nun wählen wir unsere Datenbankverbindung (aus der ein Diagramm generiert werden soll) aus und geben ihr den Namen "LibraryContext" und klicken auf "Weiter".

Nun erscheint ein Fenster, wo wir wählen können, welche Tabellen wir in unserem Diagramm haben wollen und erstellt werden sollen. Klickt auf die Checkboxen von Book und Author um diese Tabellen im Diagramm einzubinden.

Mit dem Klick auf "Fertig stellen" wird das Diagramm generiert und angezeigt. Nun wird ein Diagramm der Tabellen angezeigt. Kommen wir nun zum eigentlichen Erstellen und Ändern von Werten in der Datenbank. Wähle dafür deine Datenbankverbindung im Server-Explorer aus und klicke auf die Authorentabelle. Hier werden alle Spalten der Tabelle angezeigt mit deren Datentypen und der SQL-Befehl zum Erstellen dieser Tabelle. Klicke in die unterste, leere Zeile (unter der "Birthday"-Reihe) und füge eine Spalte namens "Country" hinzu, dass einen Datentyp von NCHAR(10) besitzt. Das bedeutet, dass das Land ein String mit maximal 10 Zeichen ist. Die Checkbox "NULL-Werte zulassen" wählt man aus, sodass der Wert in der Tabelle auch leer sein kann und ein Land anzugeben keine Pflicht ist. Sind alle Veränderungen getätigt, klicke auf "Aktualisieren" um die Änderungen zu speichern.

Hinzufügen einer Spalte in der Datenbank

Gehe wieder zurück in deine Library.edmx-File und klicke mit der rechten Maustaste in eine freie Fläche und drücke auf "Modell aus der Datenbank aktualisieren". Im nächsten Schritt wählt man die Tabellen aus, die aktualisiert werden sollten. Danach wird das Diagramm neu geladen und die Spalte "Country" ist zu sehen.

Datenbanktabellen aktualisieren

MODEL-FIRST - DEMO

Erstelle eine neue Konsolenanwendung mit dem Namen 3_ModelFirst. Klicke mit der rechten Maustaste auf das Projekt und wähle "Hinzufügen" -> "Neues Element". Erstelle hier ein neues Entity-Data-Model mit dem Namen Library und klicke auf "Hinzufügen". Da wir eine neue Tabelle erstellen wollen, wählen wir "Leeres Modell" und klicken auf "Fertigstellen".

In der neu erstellen File ist noch nichts zu sehen. Fügen wir nun eine Tabelle hinzu. Klicke mit der rechten Maustaste auf den leeren Hintergrund und wähle "Neues hinzufügen" -> "Entität" , was eine neue Tabelle in unserem Diagramm anlegt. In dem neu geöffneten Fenster, gib den Entitätsnamen an (Tabellenname in der Datenbank). Die Checkbox bei "Schlüsseleigenschaft" ist dafür da, dass ein Primärschlüssel erstellt wird. Mit dem Klick auf "OK" wird die Entität erstellt.

In der neu erstellten Entität klicke mit der rechten Maustaste auf "Eigenschaften" um eine neue Spalte in der Tabelle hinzuzufügen. Nach dem Klick auf Skalare Eigenschaften, gibt man in das Textfeld den Namen der Spalte ein.

Hat man die Spalten "Name" und "Birthday" erstellt, möchte man natürlich den Datentyp ändern. Klicke mit der rechten Maustaste auf den Namen der gewünschten Spalte und wähle "Eigenschaften". In dem Fenster auf der rechten Seite kann man durch ein Drop-Down-Menü seinen Datentyp auswählen, was bei Birthday "DateTime" wäre und bei Name "String".

Nach dem gleichen Prinzip erstellt man die Book-Tabelle mit der Spalte "Name". Zurzeit sind 2 Tabellen vorhanden, aber ohne Beziehung zwischen diesen. Um eine Beziehung zwischen der Book-Tabelle und der Author-Tabelle zu erstellen, klickt man mit der rechten Maustaste in die freie Fläche und wählt "Neues hinzufügen" -> "Zuordnung".

Erstellen einer Zugehörigkeit zwischen zwei Tabellen in EDMX

Die Multiplizität bedeutet in diesem Fall, dass mehrere Bücher auf denselben Author verweisen können, aber ein Buch von nur einem Author ist. Der Name in den Navigationseigenschaftsfeldern ist der Name des Navigationsfeldes. Mit dem Klick auf "OK" werden die zwei Klassen verbunden mit einer Eins-zu-Viele-Beziehung. Um aus dem Diagramm eine Datenbank zu erstellen mit diesen Tabellen, klickt man mit der rechten Maustaste in den Hintergrund und wählt "Datenbank aus Modell generieren". In dem neu geöffneten Fenster klickt man auf "Neue Verbindung", da wir noch keine Datenbank für unser Modell haben und legen diese an.

Datenbankverbindung erstellen

Nach dem Klick auf "OK" wird die Datenbank angelegt und wir kommen wieder zum Ausgangsfenster zurück. Hier klick man auf "Weiter" -> "Fertig stellen" und die SQL-File für die Datenbank wurde generiert. Um die Tabellen in der Datenbank zu erstellen, führt man das SQL-File aus (grüner Knopf neben dem Server-Explorer) und gibt an, auf welchem Server die Tabellen erstellt werden sollten.

SQL-File auf Server ausführen

Einzugeben sind der Servername und der Datenbankname. Nach dem Klick auf Connect werden die Tabellen erstellt. Ein sehr gutes, umfangreiches Entity-Framework-Tutorial (in Englisch) findest du unter: http://www.entityframeworktutorial.net