Freigeben über

Neuerungen im Entity Framework 4.0

Von Tom Dykstra

Diese Lernprogrammreihe basiert auf der Contoso University-Webanwendung, die von der Lernprogrammreihe "Erste Schritte mit Entity Framework " erstellt wird. Wenn Sie die früheren Lernprogramme nicht abgeschlossen haben, können Sie als Ausgangspunkt für dieses Lernprogramm die Anwendung herunterladen , die Sie erstellt haben. Sie können auch die Anwendung herunterladen , die von der vollständigen Lernprogrammreihe erstellt wird. Wenn Sie Fragen zu den Lernprogrammen haben, können Sie sie im Forum ASP.NET Entity Framework posten.

Im vorherigen Lernprogramm haben Sie einige Methoden zur Maximierung der Leistung einer Webanwendung gesehen, die das Entity Framework verwendet. In diesem Lernprogramm werden einige der wichtigsten neuen Features in Version 4 des Entity Framework überprüft, und sie enthält Links zu Ressourcen, die eine umfassendere Einführung in alle neuen Features bieten. Die in diesem Lernprogramm hervorgehobenen Features umfassen Folgendes:

  • Fremdschlüsselzuordnungen.
  • Ausführen von benutzerdefinierten SQL-Befehlen.
  • Modellorientierte Entwicklung
  • POCO-Unterstützung.

Darüber hinaus führt das Lernprogramm kurz die Code-First-Entwicklung ein, ein Feature, das in der nächsten Version von Entity Framework verfügbar ist.

Um das Lernprogramm zu starten, starten Sie Visual Studio, und öffnen Sie die Contoso University-Webanwendung, mit der Sie im vorherigen Lernprogramm gearbeitet haben.

Fremdschlüssel-Zuordnungen

Version 3.5 des Entity Framework umfasste Navigationseigenschaften, enthielt jedoch keine Fremdschlüsseleigenschaften im Datenmodell. Beispielsweise würden die Spalten CourseID und StudentID der Tabelle StudentGrade aus der Entität StudentGrade weggelassen.

Bild01

Der Grund für diesen Ansatz war, dass Fremdschlüssel streng genommen ein physisches Implementierungsdetail sind und nicht zu einem konzeptionellen Datenmodell gehören. In der Praxis ist es jedoch häufig einfacher, mit Entitäten im Code zu arbeiten, wenn Sie direkten Zugriff auf die Fremdschlüssel haben.

Ein Beispiel dafür, wie Fremdschlüssel im Datenmodell Ihren Code vereinfachen können, betrachten Sie, wie Sie die DepartmentsAdd.aspx Seite ohne diese hätten codieren müssen. In der Department Entität ist die Administrator Eigenschaft ein Fremdschlüssel, der PersonID in der Person Entität entspricht. Um die Zuordnung zwischen einer neuen Abteilung und seinem Administrator herzustellen, mussten Sie nur den Wert für die Administrator Eigenschaft im ItemInserting Ereignishandler des datengebundenen Steuerelements festlegen:

protected void DepartmentsDetailsView_ItemInserting(object sender, DetailsViewInsertEventArgs e)
{
    e.Values["Administrator"] = administratorsDropDownList.SelectedValue;
}

Ohne Fremdschlüssel im Datenmodell behandeln Sie das Inserting-Ereignis des Datenquellensteuerelements, anstatt das ItemInserting-Ereignis des datengebundenen Steuerelements, um einen direkten Verweis auf die Entität selbst zu erhalten, bevor diese dem Entitätssatz hinzugefügt wird. Wenn Sie über diesen Verweis verfügen, richten Sie die Zuordnung mithilfe von Code wie in den folgenden Beispielen ein:

departmentEntityToBeInserted.PersonReference.EntityKey = new System.Data.EntityKey("SchoolEntities.Departments", "PersonID", Convert.ToInt32(administratorsDropDownList.SelectedValue));

departmentEntityToBeInserted.Person = context.People.Single(p => p.PersonID == Convert.ToInt32(administratorsDropDownList.SelectedValue));

Wie Sie im Blogbeitrag des Entity Framework-Teams zu Fremdschlüsselzuordnungen sehen können, gibt es andere Fälle, in denen der Unterschied in der Codekomplexität viel größer ist. Um den Anforderungen derjenigen gerecht zu werden, die es vorziehen, mit Implementierungsdetails im konzeptionellen Datenmodell zu leben, um einfacheren Code zu ermöglichen, bietet Das Entity Framework jetzt die Möglichkeit, Fremdschlüssel in das Datenmodell einzuschließen.

Wenn Sie Fremdschlüssel in das Datenmodell aufnehmen, verwenden Sie Fremdschlüsselzuordnungen, und wenn Sie Fremdschlüssel ausschließen, verwenden Sie unabhängige Zuordnungen.

Ausführen von User-Defined SQL-Befehlen

In früheren Versionen von Entity Framework gab es keine einfache Möglichkeit, eigene SQL-Befehle direkt zu erstellen und auszuführen. Entweder das Entity Framework dynamisch generierte SQL-Befehle für Sie, oder Sie mussten eine gespeicherte Prozedur erstellen und als Funktion importieren. Version 4 fügt der ObjectContext Klasse die Methoden ExecuteStoreQuery und ExecuteStoreCommand hinzu, die es Ihnen erleichtern, jede Abfrage direkt an die Datenbank zu übergeben.

Angenommen, Contoso University-Administratoren möchten Massenänderungen in der Datenbank ausführen können, ohne den Vorgang zum Erstellen einer gespeicherten Prozedur und zum Importieren in das Datenmodell durchlaufen zu müssen. Ihre erste Anforderung ist eine Seite, auf der sie die Anzahl der Credits für alle Kurse in der Datenbank ändern können. Auf der Webseite möchten sie eine Zahl eingeben können, die zum Multiplizieren des Werts Course jeder Credits Zeilenspalte verwendet werden soll.

Erstellen Sie eine neue Seite, die die Gestaltungsvorlage "Site.Master " verwendet, und nennen Sie sie UpdateCredits.aspx. Fügen Sie dann das folgende Markup zum Steuerelement Content, das den Namen Content2 trägt, hinzu.

<h2>Update Credits</h2>
    Enter the number to multiply the current number of credits by: 
    <asp:TextBox ID="CreditsMultiplierTextBox" runat="server"></asp:TextBox>
    <br /><br />
    <asp:Button ID="ExecuteButton" runat="server" Text="Execute" OnClick="ExecuteButton_Click" /><br /><br />
    Rows affected:
    <asp:Label ID="RowsAffectedLabel" runat="server" Text="0" ViewStateMode="Disabled"></asp:Label><br /><br />

Dieses Markup erstellt ein TextBox Steuerelement, in das der Benutzer den Multiplikatorwert eingeben kann, ein Button Steuerelement, auf das geklickt werden soll, um den Befehl auszuführen, und ein Label Steuerelement zur Angabe der Anzahl der betroffenen Zeilen.

Öffnen Sie UpdateCredits.aspx.cs, und fügen Sie die folgende using Anweisung und einen Handler für das Ereignis der Schaltfläche Click hinzu:

using ContosoUniversity.DAL;

protected void ExecuteButton_Click(object sender, EventArgs e)
{
    using (SchoolEntities context = new SchoolEntities())
    {
        RowsAffectedLabel.Text = context.ExecuteStoreCommand("UPDATE Course SET Credits = Credits * {0}", CreditsMultiplierTextBox.Text).ToString();
    }
}

Dieser Code führt den SQL-Befehl Update mithilfe des Werts im Textfeld aus und verwendet die Beschriftung, um die Anzahl der betroffenen Zeilen anzuzeigen. Führen Sie vor dem Ausführen der Seite die Courses.aspx Seite aus, um ein "Before"-Bild einiger Daten zu erhalten.

Bild02

Führen Sie UpdateCredits.aspx aus, geben Sie "10" als Multiplikator ein, und klicken Sie dann auf "Ausführen".

Bild03

Führen Sie die Courses.aspx Seite erneut aus, um die geänderten Daten anzuzeigen.

Bild04

(Wenn Sie die Anzahl der Gutschriften wieder auf ihre ursprünglichen Werte zurücksetzen möchten, ändern Sie in UpdateCredits.aspx.csCredits * {0} zu Credits / {0} und führen Sie die Seite erneut aus, indem Sie 10 als Divisor eingeben.)

Weitere Informationen zum Ausführen von Abfragen, die Sie im Code definieren, finden Sie unter How to: Directly Execute Commands Against the Data Source.

Model-First-Entwicklung

In diesen exemplarischen Vorgehensweisen haben Sie zuerst die Datenbank erstellt und dann das Datenmodell basierend auf der Datenbankstruktur generiert. Im Entity Framework 4 können Sie stattdessen mit dem Datenmodell beginnen und die Datenbank basierend auf der Datenmodellstruktur generieren. Wenn Sie eine Anwendung erstellen, für die die Datenbank noch nicht vorhanden ist, können Sie mit dem Modell-first-Ansatz Entitäten und Beziehungen erstellen, die für die Anwendung sinnvoll sind, während Sie sich keine Sorgen um details zur physischen Implementierung machen. (Dies gilt jedoch nur in den ersten Entwicklungsphasen. Schließlich wird die Datenbank erstellt und wird Produktionsdaten enthalten, und das Neuerstellen aus dem Modell ist nicht mehr praktisch; zu diesem Zeitpunkt kehren Sie wieder zum Ansatz der datenbankbasierten Entwicklung zurück.)

In diesem Abschnitt des Lernprogramms erstellen Sie ein einfaches Datenmodell und generieren die Datenbank daraus.

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den DAL-Ordner , und wählen Sie "Neues Element hinzufügen" aus. Wählen Sie im Dialogfeld "Neues Element hinzufügen" unter "Installierte Vorlagen" "Daten" die Option "Daten" und dann die Vorlage "ADO.NET Entitätsdatenmodell" aus. Benennen Sie die neue Datei AlumniAssociationModel.edmx , und klicken Sie auf "Hinzufügen".

Bild06

Dadurch wird der Entitätsdatenmodell-Assistent gestartet. Wählen Sie im Schritt " Modellinhalt auswählen " die Option "Leeres Modell " aus, und klicken Sie dann auf "Fertig stellen".

Bild07

Der Entitätsdatenmodell-Designer wird mit einer leeren Entwurfsoberfläche geöffnet. Ziehen Sie ein Entitätselement aus der Toolbox auf die Entwurfsoberfläche.

Bild08

Ändern Sie den Entitätsnamen von Entity1 in Alumnus, ändern Sie den Id Eigenschaftsnamen in AlumnusId, und fügen Sie eine neue skalare Eigenschaft mit dem Namen hinzu Name. Wenn Sie neue Eigenschaften hinzufügen möchten, können Sie die EINGABETASTE drücken, nachdem Sie den Namen der Id Spalte geändert haben, oder klicken Sie mit der rechten Maustaste auf die Entität, und wählen Sie "Skalare Eigenschaft hinzufügen" aus. Der Standardtyp für neue Eigenschaften ist String, was für diese einfache Demonstration in Ordnung ist, aber natürlich können Sie Elemente wie datentyp im Eigenschaftenfenster ändern.

Erstellen Sie eine andere Entität auf die gleiche Weise, und benennen Sie sie Donation. Ändern Sie die Id Eigenschaft in DonationId und fügen Sie eine skalare Eigenschaft mit dem Namen DateAndAmounthinzu.

Bild09

Wenn Sie eine Zuordnung zwischen diesen beiden Entitäten hinzufügen möchten, klicken Sie mit der rechten Maustaste auf die Alumnus Entität, wählen Sie "Hinzufügen" aus, und wählen Sie dann "Zuordnung" aus.

Bild10

Die Standardwerte im Dialogfeld "Zuordnung hinzufügen" entsprechen Ihren Wünschen (eins-zu-viele, Navigationseigenschaften einbeziehen, Fremdschlüssel einbeziehen), also klicken Sie einfach auf "OK".

Bild11

Der Designer fügt eine Zuordnungslinie und eine Fremdschlüsseleigenschaft hinzu.

Bild12

Jetzt können Sie die Datenbank erstellen. Klicken Sie mit der rechten Maustaste auf die Entwurfsoberfläche, und wählen Sie "Datenbank aus Modell generieren" aus.

Bild13

Dadurch wird der Assistent zum Generieren von Datenbanken gestartet. (Wenn Warnungen angezeigt werden, die angeben, dass die Entitäten nicht zugeordnet sind, können Sie diese vorerst ignorieren.)

Klicken Sie im Schritt " Datenverbindung auswählen " auf "Neue Verbindung".

Bild14

Wählen Sie im Dialogfeld "Verbindungseigenschaften " die lokale SQL Server Express-Instanz aus, und benennen Sie die Datenbank AlumniAssociation.

Bild 15

Klicken Sie auf "Ja ", wenn Sie gefragt werden, ob Sie die Datenbank erstellen möchten. Wenn der Schritt " Datenverbindung auswählen " erneut angezeigt wird, klicken Sie auf "Weiter".

Klicken Sie im Schritt "Zusammenfassung und Einstellungen " auf "Fertig stellen".

Bild 18

Es wird eine .sql Datei mit den DDL-Befehlen (Data Definition Language) erstellt, aber die Befehle wurden noch nicht ausgeführt.

Bild20

Verwenden Sie ein Tool wie SQL Server Management Studio , um das Skript auszuführen und die Tabellen zu erstellen, wie Sie es möglicherweise getan haben, als Sie die School Datenbank für das erste Lernprogramm in der Lernprogrammreihe "Erste Schritte" erstellt haben. (Sofern Sie die Datenbank nicht heruntergeladen haben.)

Sie können nun das AlumniAssociation Datenmodell auf Ihren Webseiten auf die gleiche Weise wie das School Modell verwenden. Um dies auszuprobieren, fügen Sie den Tabellen einige Daten hinzu, und erstellen Sie eine Webseite, auf der die Daten angezeigt werden.

Fügen Sie mithilfe des Server-Explorers die folgenden Zeilen zu den Alumnus Und-Tabellen Donation hinzu.

Bild21

Erstellen Sie eine neue Webseite mit dem Namen Alumni.aspx, die die Masterseite "Site.Master" verwendet. Fügen Sie dem Content-Steuerelement, das Content2 genannt wird, das folgende Markup hinzu:

<h2>Alumni</h2>
    <asp:EntityDataSource ID="AlumniEntityDataSource" runat="server" 
        ContextTypeName="ContosoUniversity.DAL.AlumniAssociationModelContainer" EnableFlattening="False" 
        EntitySetName="Alumni">
    </asp:EntityDataSource>
    <asp:GridView ID="AlumniGridView" runat="server" 
        DataSourceID="AlumniEntityDataSource" AutoGenerateColumns="False"
        OnRowDataBound="AlumniGridView_RowDataBound"
        DataKeyNames="AlumnusId">
        <Columns>
            <asp:BoundField DataField="Name" HeaderText="Name" SortExpression="Name" />
            <asp:TemplateField HeaderText="Donations">
                <ItemTemplate>
                    <asp:GridView ID="DonationsGridView" runat="server" AutoGenerateColumns="False">
                        <Columns>
                            <asp:BoundField DataField="DateAndAmount" HeaderText="Date and Amount" />
                        </Columns>
                    </asp:GridView>
                </ItemTemplate>
            </asp:TemplateField>
        </Columns>
    </asp:GridView>

Dieses Markup erstellt geschachtelte GridView Steuerelemente: Das äußere Steuerelement zeigt die Alumninamen an, während das innere die Spendendaten und Beträge anzeigt.

Öffnen Sie Alumni.aspx.cs. Fügen Sie eine using Anweisung für die Datenzugriffsebene und einen Handler für das Ereignis des äußeren GridView Steuerelements RowDataBound hinzu:

using ContosoUniversity.DAL; 

// ...

protected void AlumniGridView_RowDataBound(object sender, GridViewRowEventArgs e)
{
    if (e.Row.RowType == DataControlRowType.DataRow)
    {
        var alumnus = e.Row.DataItem as Alumnus;
        var donationsGridView = (GridView)e.Row.FindControl("DonationsGridView");
        donationsGridView.DataSource = alumnus.Donations.ToList();
        donationsGridView.DataBind();
    }
}

Mit diesem Code wird das innere GridView Steuerelement mithilfe der Donations Navigationseigenschaft der Entität der aktuellen Zeile Alumnus gebunden.

Laden Sie die Seite.

Bild22

(Hinweis: Diese Seite ist im herunterladbaren Projekt enthalten, aber damit sie funktioniert, müssen Sie die Datenbank in Ihrer lokalen SQL Server Express-Instanz erstellen. Die Datenbank ist nicht als .mdf Datei im Ordner App_Data enthalten.)

Weitere Informationen zur Verwendung des Modell-first-Features von Entity Framework finden Sie unter Model-First im Entity Framework 4.

POCO-Unterstützung

Wenn Sie eine domänengesteuerte Entwurfsmethodik verwenden, entwerfen Sie Datenklassen, die Daten und Verhalten darstellen, die für die Geschäftsdomäne relevant sind. Diese Klassen sollten unabhängig von jeder spezifischen Technologie sein, die zum Speichern (Persistieren) der Daten verwendet wird; mit anderen Worten, sie sollten persistenzunabhängig sein. Ignorieren der Persistenz kann eine Klasse auch einfacher zu testen machen, weil das Komponententestprojekt die bequemste Persistenztechnologie für Tests verwenden kann. In früheren Versionen von Entity Framework wurde eingeschränkte Unterstützung für Persistenz-Unwissenheit angeboten, da Entitätsklassen von der EntityObject Klasse erben mussten und somit eine menge Entitätsframework-spezifische Funktionen enthielten.

Das Entity Framework 4 führt die Möglichkeit ein, Entitätsklassen zu verwenden, die nicht von der EntityObject Klasse erben und daher persistenz-unwissend sind. Im Kontext von Entity Framework werden Klassen wie diese in der Regel als einfache CLR-Objekte (POCO oder POCOs) bezeichnet. Sie können POCO-Klassen manuell schreiben oder sie automatisch basierend auf einem vorhandenen Datenmodell mithilfe von Text Template Transformation Toolkit (T4)-Vorlagen generieren, die vom Entity Framework bereitgestellt werden.

Weitere Informationen zur Verwendung von POCOs im Entity Framework finden Sie in den folgenden Ressourcen:

Code-First Entwicklung

PoCO-Unterstützung im Entity Framework 4 erfordert weiterhin, dass Sie ein Datenmodell erstellen und Ihre Entitätsklassen mit dem Datenmodell verknüpfen. Die nächste Version von Entity Framework enthält ein Feature, das als Code-First-Entwicklung bezeichnet wird. Mit diesem Feature können Sie das Entity Framework mit Ihren eigenen POCO-Klassen verwenden, ohne entweder den Datenmodell-Designer oder eine XML-Datenmodelldatei verwenden zu müssen. (Daher wird diese Option auch als Nur-Code bezeichnet; Code-First und Nur-Code beziehen sich auf dasselbe Entity Framework-Feature.)

Weitere Informationen zur Verwendung des Code-first-Ansatzes für die Entwicklung finden Sie in den folgenden Ressourcen:

Darüber hinaus soll im Frühjahr 2011 ein neues MVC-Code-First-Tutorial veröffentlicht werden, das eine Applikation entwickelt, die der Applikation Contoso University ähnelt, unter https://asp.net/entity-framework/tutorials

Weitere Informationen

Dies schließt die Übersicht über die Neuerungen im Entity Framework und die Fortsetzung der Tutorialserie "Entity Framework" ab. Weitere Informationen zu neuen Features in Entity Framework 4, die hier nicht behandelt werden, finden Sie in den folgenden Ressourcen:

Zurück

  • Last updated on