Erstellen von Modellklassen mit Entity Framework (C#)

von Microsoft

In diesem Tutorial erfahren Sie, wie Sie ASP.NET MVC mit dem Microsoft Entity Framework verwenden. Sie erfahren, wie Sie mit dem Entitäts-Assistenten ein ADO.NET Entitätsdatenmodell erstellen. Im Laufe dieses Tutorials erstellen wir eine Webanwendung, die veranschaulicht, wie Datenbankdaten mithilfe von Entity Framework ausgewählt, eingefügt, aktualisiert und gelöscht werden.

In diesem Tutorial wird erläutert, wie Sie Beim Erstellen einer ASP.NET MVC-Anwendung Datenzugriffsklassen mithilfe von Microsoft Entity Framework erstellen können. In diesem Tutorial wird davon ausgegangen, dass keine Vorkenntnisse des Microsoft Entity Frameworks vorliegen. Am Ende dieses Tutorials erfahren Sie, wie Sie Mit dem Entity Framework Datenbankdatensätze auswählen, einfügen, aktualisieren und löschen können.

Microsoft Entity Framework ist ein O/RM-Tool (Object Relational Mapping), mit dem Sie automatisch eine Datenzugriffsebene aus einer Datenbank generieren können. Mit Dem Entity Framework können Sie die mühsame Arbeit beim manuellen Erstellen Ihrer Datenzugriffsklassen vermeiden.

Um zu veranschaulichen, wie Sie das Microsoft Entity Framework mit ASP.NET MVC verwenden können, erstellen wir eine einfache Beispielanwendung. Wir erstellen eine Filmdatenbankanwendung, mit der Sie Filmdatenbankdatensätze anzeigen und bearbeiten können.

In diesem Tutorial wird davon ausgegangen, dass Sie über Visual Studio 2008 oder Visual Web Developer 2008 mit Service Pack 1 verfügen. Sie benötigen Service Pack 1, um das Entity Framework verwenden zu können. Sie können Visual Studio 2008 Service Pack 1 oder Visual Web Developer mit Service Pack 1 von der folgenden Adresse herunterladen:

https://www.asp.net/downloads/

Erstellen der Filmbeispieldatenbank

Die Movie Database-Anwendung verwendet eine Datenbanktabelle namens Movies, die die folgenden Spalten enthält:

Sie können diese Tabelle einem ASP.NET MVC-Projekt hinzufügen, indem Sie die folgenden Schritte ausführen:

1. Klicken Sie im fenster Projektmappen-Explorer mit der rechten Maustaste auf den Ordner App_Data, und wählen Sie die Menüoption Hinzufügen, Neues Element aus.
2. Wählen Sie im Dialogfeld Neues Element hinzufügenSQL Server Datenbank aus, geben Sie der Datenbank den Namen MoviesDB.mdf, und klicken Sie auf die Schaltfläche Hinzufügen.
3. Doppelklicken Sie auf die Datei MoviesDB.mdf, um das Fenster Server Explorer/Database Explorer zu öffnen.
4. Erweitern Sie die MoviesDB.mdf-Datenbankverbindung, klicken Sie mit der rechten Maustaste auf den Ordner Tabellen, und wählen Sie die Menüoption Neue Tabelle hinzufügen aus.
5. Fügen Sie im Designer Tabelle die Spalten ID, Titel und Director hinzu.
6. Klicken Sie auf die Schaltfläche Speichern (sie verfügt über das Symbol der Diskette), um die neue Tabelle mit dem Namen Filme zu speichern.

Nachdem Sie die Movies-Datenbanktabelle erstellt haben, sollten Sie der Tabelle einige Beispieldaten hinzufügen. Klicken Sie mit der rechten Maustaste auf die Tabelle Filme, und wählen Sie die Menüoption Tabellendaten anzeigen aus. Sie können gefälschte Filmdaten in das angezeigte Raster eingeben.

Erstellen des ADO.NET Entitätsdatenmodells

Um das Entity Framework verwenden zu können, müssen Sie ein Entitätsdatenmodell erstellen. Sie können den Visual Studio-Assistenten für Entitätsdatenmodelle nutzen, um ein Entitätsdatenmodell automatisch aus einer Datenbank zu generieren.

Führen Sie die folgenden Schritte aus:

1. Klicken Sie im fenster Projektmappen-Explorer mit der rechten Maustaste auf den Ordner Models, und wählen Sie die Menüoption Hinzufügen, Neues Element aus.
2. Wählen Sie im Dialogfeld Neues Element hinzufügen die Kategorie Daten aus (siehe Abbildung 1).
3. Wählen Sie die Vorlage ADO.NET Entitätsdatenmodell aus, geben Sie dem Entitätsdatenmodell den Namen MoviesDBModel.edmx, und klicken Sie auf die Schaltfläche Hinzufügen . Durch Klicken auf die Schaltfläche Hinzufügen wird der Datenmodell-Assistent gestartet.
4. Wählen Sie im Schritt Modellinhalt auswählen die Option Aus Datenbank generieren aus, und klicken Sie auf die Schaltfläche Weiter (siehe Abbildung 2).
5. Wählen Sie im Schritt Datenverbindung auswählen die Datenbankverbindung MoviesDB.mdf aus, geben Sie den Namen der Entitätenverbindungseinstellungen ein, und klicken Sie auf die Schaltfläche Weiter (siehe Abbildung 3).
6. Wählen Sie im Schritt Datenbankobjekte auswählen die Tabelle Filmdatenbank aus, und klicken Sie auf die Schaltfläche Fertig stellen (siehe Abbildung 4).

Nachdem Sie diese Schritte ausgeführt haben, wird das ADO.NET Entity Data Model Designer (Entity Designer) geöffnet.

Abbildung 1: Erstellen eines neuen Entitätsdatenmodells

Abbildung 2: Schritt "Modellinhalt auswählen"

Abbildung 3: Auswählen Ihrer Datenverbindung

Abbildung 4: Auswählen Ihrer Datenbankobjekte

Ändern des ADO.NET Entitätsdatenmodells

Nachdem Sie ein Entitätsdatenmodell erstellt haben, können Sie das Modell ändern, indem Sie die Vorteile der Entitäts-Designer nutzen (siehe Abbildung 5). Sie können die Entität Designer jederzeit öffnen, indem Sie im Fenster Projektmappen-Explorer auf die Datei MoviesDBModel.edmx doppelklicken, die im Ordner Models enthalten ist.

Abbildung 5: ADO.NET Entitätsdatenmodell Designer

Sie können beispielsweise die Entitäts-Designer verwenden, um die Namen der Klassen zu ändern, die vom Assistenten für Entitätsmodelldaten generiert werden. Der Assistent hat eine neue Datenzugriffsklasse mit dem Namen Movies erstellt. Anders ausgedrückt: Der Assistent hat der Klasse den gleichen Namen wie die Datenbanktabelle gegeben. Da wir diese Klasse verwenden, um einen bestimmten Movie instance darzustellen, sollten wir die Klasse von Movies in Movie umbenennen.

Wenn Sie eine Entitätsklasse umbenennen möchten, können Sie im Entitäts-Designer auf den Klassennamen doppelklicken und einen neuen Namen eingeben (siehe Abbildung 6). Alternativ können Sie den Namen einer Entität im Eigenschaftenfenster ändern, nachdem Sie eine Entität in der Entität Designer ausgewählt haben.

Abbildung 6 : Ändern eines Entitätsnamens

Denken Sie daran, Ihr Entitätsdatenmodell zu speichern, nachdem Sie eine Änderung vorgenommen haben, indem Sie auf die Schaltfläche Speichern (das Symbol der Diskette) klicken. Im Hintergrund generiert die Entität Designer eine Reihe von C#-Klassen. Sie können diese Klassen anzeigen, indem Sie moviesDBModel öffnen. Designer.cs-Datei aus dem fenster Projektmappen-Explorer.

Ändern Sie den Code in der Datei Designer.cs nicht, da Ihre Änderungen bei der nächsten Verwendung der Entität Designer überschrieben werden. Wenn Sie die Funktionalität der Entitätsklassen erweitern möchten, die in der Datei Designer.cs definiert sind, können Sie Teilklassen in separaten Dateien erstellen.

Auswählen von Datenbankdatensätzen mit dem Entity Framework

Beginnen wir mit dem Erstellen unserer Filmdatenbankanwendung, indem Sie eine Seite erstellen, auf der eine Liste mit Filmdatensätzen angezeigt wird. Der Startcontroller in Listing 1 macht eine Aktion mit dem Namen Index() verfügbar. Die Index()-Aktion gibt alle Filmdatensätze aus der Movie-Datenbanktabelle zurück, indem sie das Entity Framework nutzt.

Listing 1 – Controller\HomeController.cs

using System.Linq;
using System.Web.Mvc;
using MovieEntityApp.Models;

namespace MovieEntityApp.Controllers
{
    [HandleError]
    public class HomeController : Controller
    {
        MoviesDBEntities _db;

        public HomeController()
        {
            _db = new MoviesDBEntities();
        }

        public ActionResult Index()
        {
            ViewData.Model = _db.MovieSet.ToList();
            return View();
        }

    }
}

Beachten Sie, dass der Controller in Listing 1 einen Konstruktor enthält. Der Konstruktor initialisiert ein Feld auf Klassenebene mit dem Namen _db. Das Feld _db stellt die vom Microsoft Entity Framework generierten Datenbankentitäten dar. Das Feld _db ist ein instance der MoviesDBEntities-Klasse, die vom Entity Designer generiert wurde.

Um dieMoviesDBEntities-Klasse im Home-Controller verwenden zu können, müssen Sie den MovieEntityApp.Models-Namespace (MVCProjectName) importieren. Modelle).

Das Feld _db wird in der Index()-Aktion verwendet, um die Datensätze aus der Tabelle Movies-Datenbank abzurufen. Der Ausdruck _db. MovieSet stellt alle Datensätze aus der Movies-Datenbanktabelle dar. Die ToList()-Methode wird verwendet, um die Gruppe von Filmen in eine generische Auflistung von Movie-Objekten (List<Movie>) zu konvertieren.

Die Filmdatensätze werden mithilfe von LINQ to Entities abgerufen. Die Index()-Aktion in Listing 1 verwendet die LINQ-Methodensyntax , um den Satz von Datenbankdatensätzen abzurufen. Wenn Sie möchten, können Sie stattdessen LINQ-Abfragesyntax verwenden. Die folgenden beiden Anweisungen führen dasselbe aus:

ViewData.Model = _db.MovieSet.ToList();
ViewData.Model = (from m in _db.MovieSet select m).ToList();

Verwenden Sie die LINQ-Syntax – Methodensyntax oder Abfragesyntax –, die Sie am intuitivsten finden. Es gibt keinen Unterschied in der Leistung zwischen den beiden Ansätzen – der einzige Unterschied ist stil.

Die Ansicht in Listing 2 wird verwendet, um die Filmdatensätze anzuzeigen.

Listing 2 – Views\Home\Index.aspx

<%@ Page Language="C#"  
  Inherits="System.Web.Mvc.ViewPage<List<MovieEntityApp.Models.Movie>>" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title>Index</title>
</head>
<body>
    <div>
    
<% foreach (var m in ViewData.Model)
   { %>

    Title: <%= m.Title %>
    <br />
    Director: <%= m.Director %>
    <br />
    <%= Html.ActionLink("Edit", "Edit", new { id = m.Id })%>
    <%= Html.ActionLink("Delete", "Delete", new { id = m.Id })%>
       
        <hr />
<% } %>

<%= Html.ActionLink("Add Movie", "Add") %>
    
    </div>
</body>
</html>

Die Ansicht in Listing 2 enthält eine foreach-Schleife , die jeden Filmdatensatz durchläuft und die Werte der Eigenschaften Title und Director des Filmdatensatzes anzeigt. Beachten Sie, dass neben jedem Datensatz ein Link zum Bearbeiten und Löschen angezeigt wird. Außerdem wird unten in der Ansicht ein Link Film hinzufügen angezeigt (siehe Abbildung 7).

Abbildung 7– Die Indexansicht

Die Indexansicht ist eine typisierte Ansicht. Die Indexansicht enthält eine <%@ Page %> -Direktive mit einem Inherits-Attribut , das die Model-Eigenschaft in eine stark typisierte generische List-Auflistung von Movie-Objekten (List<Movie) wandelt.

Einfügen von Datenbankdatensätzen mit dem Entity Framework

Sie können entity Framework verwenden, um das Einfügen neuer Datensätze in eine Datenbanktabelle zu vereinfachen. Listing 3 enthält zwei neue Aktionen, die der Home-Controllerklasse hinzugefügt wurden, mit denen Sie neue Datensätze in die Movie-Datenbanktabelle einfügen können.

Listing 3 – Controllers\HomeController.cs (Methoden hinzufügen)

public ActionResult Add()
{
    return View();
}

[AcceptVerbs(HttpVerbs.Post)]
public ActionResult Add(FormCollection form)
{
    var movieToAdd = new Movie();

    // Deserialize (Include white list!)
    TryUpdateModel(movieToAdd, new string[] { "Title", "Director" }, form.ToValueProvider());

    // Validate
    if (String.IsNullOrEmpty(movieToAdd.Title))
        ModelState.AddModelError("Title", "Title is required!");
    if (String.IsNullOrEmpty(movieToAdd.Director))
        ModelState.AddModelError("Director", "Director is required!");

    // If valid, save movie to database
    if (ModelState.IsValid)
    {
        _db.AddToMovieSet(movieToAdd);
        _db.SaveChanges();
        return RedirectToAction("Index");
    }

    // Otherwise, reshow form
    return View(movieToAdd);
}

Die erste Add()-Aktion gibt einfach eine Ansicht zurück. Die Ansicht enthält ein Formular zum Hinzufügen eines neuen Filmdatenbankdatensatzes (siehe Abbildung 8). Wenn Sie das Formular übermitteln, wird die zweite Add()-Aktion aufgerufen.

Beachten Sie, dass die zweite Add()-Aktion mit dem AcceptVerbs-Attribut versehen ist. Diese Aktion kann nur aufgerufen werden, wenn ein HTTP POST-Vorgang ausgeführt wird. Anders ausgedrückt: Diese Aktion kann nur beim Veröffentlichen eines HTML-Formulars aufgerufen werden.

Die zweite Add()-Aktion erstellt mithilfe der ASP.NET MVC TryUpdateModel()-Methode eine neue instance der Entity Framework Movie-Klasse. Die TryUpdateModel()-Methode übernimmt die Felder in der FormCollection, die an die Add()-Methode übergeben werden, und weist die Werte dieser HTML-Formularfelder der Movie-Klasse zu.

Bei Verwendung von Entity Framework müssen Sie eine "Safelist" von Eigenschaften angeben, wenn Sie die TryUpdateModel- oder UpdateModel-Methoden verwenden, um die Eigenschaften einer Entitätsklasse zu aktualisieren.

Als Nächstes führt die Add()-Aktion eine einfache Formularüberprüfung durch. Die Aktion überprüft, ob sowohl die Title- als auch die Director-Eigenschaft Werte aufweisen. Wenn ein Validierungsfehler vorliegt, wird ModelState eine Validierungsfehlermeldung hinzugefügt.

Wenn keine Validierungsfehler vorliegen, wird der Movies-Datenbanktabelle mit Hilfe von Entity Framework ein neuer Filmdatensatz hinzugefügt. Der neue Datensatz wird der Datenbank mit den folgenden zwei Codezeilen hinzugefügt:

_db.AddToMovieSet(movieToAdd);
_db.SaveChanges();

Mit der ersten Codezeile wird die neue Movie-Entität der Gruppe von Filmen hinzugefügt, die vom Entity Framework nachverfolgt werden. Die zweite Codezeile speichert alle Änderungen, die an den filmenden Filmen vorgenommen wurden, in der zugrunde liegenden Datenbank.

Abbildung 8: Ansicht hinzufügen

Aktualisieren von Datenbankdatensätzen mit dem Entity Framework

Sie können fast den gleichen Ansatz zum Bearbeiten eines Datenbankdatensatzes mit dem Entity Framework wie den Ansatz verfolgen, den wir gerade zum Einfügen eines neuen Datenbankdatensatzes verfolgt haben. Listing 4 enthält zwei neue Controlleraktionen mit dem Namen Edit(). Die erste Edit()-Aktion gibt ein HTML-Formular zum Bearbeiten eines Filmdatensatzes zurück. Die zweite Edit()-Aktion versucht, die Datenbank zu aktualisieren.

Auflistung 4 – Controllers\HomeController.cs (Edit-Methoden)

public ActionResult Edit(int id)
{
    // Get movie to update
    var movieToUpdate = _db.MovieSet.First(m => m.Id == id);

    ViewData.Model = movieToUpdate;
    return View();
}

[AcceptVerbs(HttpVerbs.Post)]
public ActionResult Edit(FormCollection form)
{
    // Get movie to update
    var id = Int32.Parse(form["id"]);
    var movieToUpdate = _db.MovieSet.First(m => m.Id == id);

    // Deserialize (Include white list!)
    TryUpdateModel(movieToUpdate, new string[] { "Title", "Director" }, form.ToValueProvider());

    // Validate
    if (String.IsNullOrEmpty(movieToUpdate.Title))
        ModelState.AddModelError("Title", "Title is required!");
    if (String.IsNullOrEmpty(movieToUpdate.Director))
        ModelState.AddModelError("Director", "Director is required!");

    // If valid, save movie to database
    if (ModelState.IsValid)
    {
        _db.SaveChanges();
        return RedirectToAction("Index");
    }

    // Otherwise, reshow form
    return View(movieToUpdate);
}

Die zweite Edit()-Aktion beginnt mit dem Abrufen des Movie-Eintrags aus der Datenbank, der der ID des zu bearbeitenden Films entspricht. Die folgende LINQ to Entities-Anweisung greift den ersten Datenbankdatensatz ab, der einer bestimmten ID entspricht:

var movieToUpdate = _db.MovieSet.First(m => m.Id == id);

Als Nächstes wird die TryUpdateModel()-Methode verwendet, um die Werte der HTML-Formularfelder den Eigenschaften der Filmentität zuzuweisen. Beachten Sie, dass eine Safelist bereitgestellt wird, um die genauen Zu aktualisierenden Eigenschaften anzugeben.

Als Nächstes wird eine einfache Überprüfung durchgeführt, um zu überprüfen, ob sowohl die Filmtitel- als auch die Director-Eigenschaft Werte aufweisen. Wenn bei einer Eigenschaft ein Wert fehlt, wird modelState eine Validierungsfehlermeldung hinzugefügt, und ModelState.IsValid gibt den Wert false zurück.

Wenn keine Überprüfungsfehler auftreten, wird die zugrunde liegende Movies-Datenbanktabelle mit allen Änderungen aktualisiert, indem die SaveChanges()-Methode aufgerufen wird.

Beim Bearbeiten von Datenbankdatensätzen müssen Sie die ID des zu bearbeitenden Datensatzes an die Controlleraktion übergeben, die die Datenbankaktualisierung ausführt. Andernfalls weiß die Controlleraktion nicht, welcher Datensatz in der zugrunde liegenden Datenbank aktualisiert werden soll. Die Bearbeitungsansicht in Listing 5 enthält ein ausgeblendetes Formularfeld, das die ID des zu bearbeitenden Datenbankdatensatzes darstellt.

Listing 5 – Views\Home\Edit.aspx

<%@ Page Language="C#" 
  Inherits="System.Web.Mvc.ViewPage<MovieEntityApp.Models.Movie>" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title>Edit</title>
    <style type="text/css">
    
    .input-validation-error
    {
        background-color:Yellow;
    }
    
    </style>    
</head>
<body>
    <div>

<h1>Edit Movie</h1>

<form method="post" action="/Home/Edit">

    <!-- Include Hidden Id -->
    <%= Html.Hidden("id") %>

    Title:
    <br />
    <%= Html.TextBox("title") %>
    
    <br /><br />
    Director:
    <br />
    <%= Html.TextBox("director") %>
    
    <br /><br />
    <input type="submit" value="Edit Movie" />
</form>
    
    </div>
</body>
</html>

Löschen von Datenbankdatensätzen mit dem Entity Framework

Der letzte Datenbankvorgang, den wir in diesem Tutorial behandeln müssen, ist das Löschen von Datenbankdatensätzen. Sie können die Controlleraktion in Listing 6 verwenden, um einen bestimmten Datenbankdatensatz zu löschen.

Listing 6 -- \Controllers\HomeController.cs (Aktion löschen)

public ActionResult Delete(int id)
{
    // Get movie to delete
    var movieToDelete = _db.MovieSet.First(m => m.Id == id);

    // Delete 
    _db.DeleteObject(movieToDelete);
    _db.SaveChanges();

    // Show Index view
    return RedirectToAction("Index");
}

Die Delete()-Aktion ruft zuerst die Movie-Entität ab, die der an die Aktion übergebenen ID entspricht. Als Nächstes wird der Film aus der Datenbank gelöscht, indem die DeleteObject()-Methode gefolgt von der SaveChanges()-Methode aufgerufen wird. Schließlich wird der Benutzer zurück zur Indexansicht umgeleitet.

Zusammenfassung

In diesem Tutorial soll veranschaulicht werden, wie Sie datenbankgesteuerte Webanwendungen erstellen können, indem Sie ASP.NET MVC und das Microsoft Entity Framework nutzen. Sie haben gelernt, wie Sie eine Anwendung erstellen, mit der Sie Datenbankdatensätze auswählen, einfügen, aktualisieren und löschen können.

Zunächst wurde erläutert, wie Sie den Entity Data Model-Assistenten verwenden können, um ein Entitätsdatenmodell in Visual Studio zu generieren. Als Nächstes erfahren Sie, wie Sie LINQ to Entities verwenden, um eine Reihe von Datenbankdatensätzen aus einer Datenbanktabelle abzurufen. Schließlich haben wir das Entity Framework verwendet, um Datenbankdatensätze einzufügen, zu aktualisieren und zu löschen.