Neue Funktionen in Entity Framework 4.0

von Tom Dykstra

Diese Tutorialreihe baut auf der Contoso University-Webanwendung auf, die vom Erste Schritte mit der Tutorialreihe "Entity Framework" erstellt wird. Wenn Sie die vorherigen Tutorials nicht abgeschlossen haben, können Sie als Ausgangspunkt für dieses Tutorial die Anwendung herunterladen, die Sie erstellt hätten. Sie können auch die Anwendung herunterladen, die von der vollständigen Tutorialreihe erstellt wird. Wenn Sie Fragen zu den Tutorials haben, können Sie diese im ASP.NET Entity Framework-Forum veröffentlichen.

Im vorherigen Tutorial haben Sie einige Methoden zum Maximieren der Leistung einer Webanwendung gesehen, die das Entity Framework verwendet. In diesem Tutorial werden einige der wichtigsten neuen Features in Version 4 von Entity Framework erläutert, und es enthält Links zu Ressourcen, die eine vollständigere Einführung in alle neuen Features bieten. In diesem Tutorial werden folgende Features hervorgehoben:

• Fremdschlüsselzuordnungen.
• Ausführen benutzerdefinierter SQL-Befehle.
• Model-First-Entwicklung.
• POCO-Unterstützung.

Darüber hinaus wird im Tutorial kurz die Code-First-Entwicklung vorgestellt, ein Feature, das in der nächsten Version von Entity Framework verfügbar ist.

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

Foreign-Key Zuordnungen

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

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

Für ein Beispiel dafür, wie Fremdschlüssel im Datenmodell Ihren Code vereinfachen können, sollten Sie sich überlegen, wie Sie ohne sie die Seite DepartmentsAdd.aspx codieren müssen. In der Department Entität ist die Administrator Eigenschaft ein Fremdschlüssel, der in der Person Entität entsprichtPersonID. Um die Zuordnung zwischen einer neuen Abteilung und ihrem 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 würden Sie das Inserting Ereignis des Datenquellensteuerelements anstelle des ItemInserting Ereignisses des datengebundenen Steuerelements behandeln, um einen Verweis auf die Entität selbst abzurufen, bevor die Entität 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 die Anforderungen von Personen zu erfüllen, die es vorziehen, mit Implementierungsdetails im konzeptionellen Datenmodell aus Gründen des einfacheren Codes zu leben, bietet Ihnen das Entity Framework jetzt die Möglichkeit, Fremdschlüssel in das Datenmodell einzuordnen.

Wenn Sie in der Entity Framework-Terminologie Fremdschlüssel in das Datenmodell einschließen, verwenden Sie Fremdschlüsselzuordnungen, und wenn Sie Fremdschlüssel ausschließen, verwenden Sie unabhängige Zuordnungen.

Ausführen User-Defined SQL-Befehle

In früheren Versionen von Entity Framework gab es keine einfache Möglichkeit, ihre eigenen SQL-Befehle im Lauf der Zeit zu erstellen und auszuführen. Entweder die dynamisch generierten SQL-Befehle von Entity Framework für Sie, oder Sie mussten eine gespeicherte Prozedur erstellen und als Funktion importieren. Version 4 fügt die ObjectContext -Klasse hinzu ExecuteStoreQuery und ExecuteStoreCommand methoden, die es Ihnen erleichtern, abfragen direkt an die Datenbank zu übergeben.

Angenommen, Administratoren der Contoso University möchten Massenänderungen in der Datenbank ausführen können, ohne den Prozess zum Erstellen einer gespeicherten Prozedur und zum Importieren in das Datenmodell durchlaufen zu müssen. Ihre erste Anforderung ist eine Seite, mit der sie die Anzahl der Guthaben 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 Credits jeder Course Zeilenspalte verwendet werden soll.

Erstellen Sie eine neue Seite, die die Seite Site.Master master verwendet, und nennen Sie sie UpdateCredits.aspx. Fügen Sie dann das folgende Markup zum Steuerelement mit dem Content Namen hinzu Content2:

<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 dem der Benutzer den Multiplikatorwert eingeben kann, ein Button Steuerelement, auf das zum Ausführen des Befehls geklickt werden soll, und ein Label Steuerelement zum Angeben 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 Bezeichnung, um die Anzahl der betroffenen Zeilen anzuzeigen. Führen Sie vor dem Ausführen der Seite die Seite Courses.aspx aus, um ein "Vorher"-Bild einiger Daten zu erhalten.

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

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

(Wenn Sie die Anzahl der Guthaben wieder auf ihre ursprünglichen Werte festlegen möchten, ändern Credits * {0} Sie in UpdateCredits.aspx.cs die Credits / {0} Seite, und führen Sie sie erneut aus, und geben Sie 10 als Divisor ein.)

Weitere Informationen zum Ausführen von Abfragen, die Sie im Code definieren, finden Sie unter Vorgehensweise: Direktes Ausführen von Befehlen für die Datenquelle.

Model-First Entwicklung

In diesen exemplarischen Vorgehensweisen haben Sie zuerst die Datenbank erstellt und dann das Datenmodell basierend auf der Datenbankstruktur generiert. In 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 Model-First-Ansatz Entitäten und Beziehungen erstellen, die konzeptionell für die Anwendung sinnvoll sind, ohne sich um details der physischen Implementierung zu kümmern. (Dies gilt jedoch nur in den Anfangsstadien der Entwicklung. Schließlich wird die Datenbank erstellt und enthält Produktionsdaten, und die Neuerstellung aus dem Modell ist nicht mehr praktikabel; an diesem Punkt kehren Sie wieder zum Database-First-Ansatz zurück.)

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

Klicken Sie in 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 die Option Daten aus, und wählen Sie dann die Vorlage ADO.NET Entitätsdatenmodell aus. Nennen Sie die neue Datei AlumniAssociationModel.edmx , und klicken Sie auf Hinzufügen.

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

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

Ändern Sie den Entitätsnamen von Entity1 in Alumnus, ändern Sie den Eigenschaftsnamen Id in AlumnusId, und fügen Sie eine neue skalare Eigenschaft mit dem Namen hinzu Name. Um neue Eigenschaften hinzuzufügen, 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 im Eigenschaftenfenster den Datentyp ändern.

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

Um eine Zuordnung zwischen diesen beiden Entitäten hinzuzufügen, klicken Sie mit der rechten Maustaste auf die Alumnus Entität, wählen Sie Hinzufügen und dann Zuordnung aus.

Die Standardwerte im Dialogfeld Zuordnung hinzufügen sind das, was Sie möchten (1:n, Navigationseigenschaften einschließen, Fremdschlüssel einschließen), klicken Sie also einfach auf OK.

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

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.

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

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

Wählen Sie im Dialogfeld Verbindungseigenschaften die lokale SQL Server Express instance aus, und nennen Sie die Datenbank AlumniAssociation.

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.

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

Verwenden Sie ein Tool wie SQL Server Management Studio, um das Skript auszuführen und die Tabellen zu erstellen, wie Sie es beim Erstellen der Datenbank für das Schoolerste Tutorial in der Erste Schritte Tutorialreihe getan haben. (Es sei denn, Sie haben die Datenbank heruntergeladen.)

Sie können das AlumniAssociation Datenmodell jetzt auf Ihren Webseiten auf die gleiche Weise verwenden, wie Sie das School Modell verwendet haben. 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 unter Verwendung von Server Explorer den Tabellen und Donation die Alumnus folgenden Zeilen hinzu.

Erstellen Sie eine neue Webseite namens Alumni.aspx, die die Seite Site.Master master verwendet. Fügen Sie dem Steuerelement das folgende Markup mit dem Content Namen hinzu Content2:

<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 zum Anzeigen von Alumninamen und das innere, um Spendentermine und -beträge anzuzeigen.

Ö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();
    }
}

Dieser Code bindet das innere GridView Steuerelement mithilfe der Donations Navigationseigenschaft der Entität der aktuellen Zeile Alumnus .

Führen Sie die Seite aus.

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

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

POCO-Unterstützung

Wenn Sie 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 einer bestimmten Technologie sein, die zum Speichern (Beibehalten) der Daten verwendet wird. Mit anderen Worten, sie sollten hartnäckig unwissend sein. Persistenz-Unwissenheit kann auch den Komponententest einer Klasse erleichtern, da das Komponententestprojekt die für Tests am bequemsten geeignete Persistenztechnologie verwenden kann. Frühere Versionen von Entity Framework boten eingeschränkte Unterstützung für Persistenz-Unwissenheit, da Entitätsklassen von der EntityObject Klasse erben mussten und daher eine große Menge an Entity Framework-spezifischen Funktionen enthielten.

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 des Entity Frameworks werden Klassen wie diese in der Regel als einfache alte CLR-Objekte (POCO oder POCOs) bezeichnet. Sie können POCO-Klassen manuell schreiben oder automatisch basierend auf einem vorhandenen Datenmodell mithilfe von T4-Vorlagen (Text Template Transformation Toolkit) generieren, die vom Entity Framework bereitgestellt werden.

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

• Arbeiten mit POCO-Entitäten. Dies ist ein MSDN-Dokument, das eine Übersicht über POCOs mit Links zu anderen Dokumenten enthält, die ausführlichere Informationen enthalten.
• Exemplarische Vorgehensweise: POCO-Vorlage für das Entity Framework Dies ist ein Blogbeitrag des Entity Framework-Entwicklungsteams mit Links zu anderen Blogbeiträgen zu POCOs.

Code-First Entwicklung

Die POCO-Unterstützung in 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 namens Code-First-Entwicklung. Mit diesem Feature können Sie Entity Framework mit Ihren eigenen POCO-Klassen verwenden, ohne entweder den Datenmodell-Designer oder eine DATENMODELL-XML-Datei verwenden zu müssen. (Daher wurde diese Option auch als nur Code bezeichnet; code-first und code-only 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:

• Code-First-Entwicklung mit Entity Framework 4. Dies ist ein Blogbeitrag von Scott Guthrie, der die Code-First-Entwicklung vorstellt.
• Blog des Entity Framework-Entwicklungsteams – Beiträge mit dem Tags "CodeOnly"
• Blog des Entity Framework-Entwicklungsteams – Beiträge mit dem Tags "Code First"
• MVC Music Store-Tutorial – Teil 4: Modelle und Datenzugriff
• Erste Schritte mit MVC 3 – Teil 4: Entity Framework Code-First Entwicklung

Darüber hinaus wird ein neues MVC-Code-First-Tutorial, das eine Anwendung ähnlich der Contoso University-Anwendung erstellt, voraussichtlich im Frühjahr 2011 unter https://asp.net/entity-framework/tutorials

Weitere Informationen

Dadurch wird die Übersicht über die Neuerungen in Entity Framework und die Fortsetzung der Tutorialreihe "Entity Framework" vervollständigt. Weitere Informationen zu neuen Features in Entity Framework 4, die hier nicht behandelt werden, finden Sie in den folgenden Ressourcen:

• Neuerungen in ADO.NET MSDN-Thema zu neuen Features in Version 4 von Entity Framework.
• Ankündigung der Veröffentlichung von Entity Framework 4 Der Blogbeitrag des Entity Framework-Entwicklungsteams über neue Features in Version 4.

Zurück