Partager via

Nouveautés d’Entity Framework 4.0

  • Article

par Tom Dykstra

Cette série de tutoriels s’appuie sur l’application web Contoso University qui est créée par le Prise en main avec la série de tutoriels Entity Framework. Si vous n’avez pas terminé les didacticiels précédents, comme point de départ de ce tutoriel, vous pouvez télécharger l’application que vous auriez créée. Vous pouvez également télécharger l’application créée par la série complète de tutoriels. Si vous avez des questions sur les tutoriels, vous pouvez les publier sur le forum ASP.NET Entity Framework.

Dans le tutoriel précédent, vous avez vu certaines méthodes permettant d’optimiser les performances d’une application web qui utilise Entity Framework. Ce tutoriel passe en revue certaines des nouvelles fonctionnalités les plus importantes de la version 4 d’Entity Framework, et il établit des liens vers des ressources qui fournissent une présentation plus complète de toutes les nouvelles fonctionnalités. Les fonctionnalités mises en évidence dans ce didacticiel sont les suivantes :

  • Associations de clés étrangères.
  • Exécution de commandes SQL définies par l’utilisateur.
  • Développement de modèle d’abord.
  • Prise en charge de POCO.

En outre, le tutoriel présente brièvement le développement code-first, une fonctionnalité qui sera disponible dans la prochaine version d’Entity Framework.

Pour démarrer le didacticiel, démarrez Visual Studio et ouvrez l’application web Contoso University avec laquelle vous avez travaillé dans le tutoriel précédent.

associations Foreign-Key

La version 3.5 d’Entity Framework incluait des propriétés de navigation, mais elle n’incluait pas de propriétés de clé étrangère dans le modèle de données. Par exemple, les CourseID colonnes et StudentID de la StudentGrade table sont omises de l’entité StudentGrade .

Image01

La raison de cette approche était que, strictement parlant, les clés étrangères sont un détail d’implémentation physique et n’appartiennent pas à un modèle de données conceptuel. Toutefois, dans la pratique, il est souvent plus facile d’utiliser des entités dans le code lorsque vous avez un accès direct aux clés étrangères.

Pour obtenir un exemple de la façon dont les clés étrangères dans le modèle de données peuvent simplifier votre code, réfléchissez à la façon dont vous auriez dû coder la page DepartmentsAdd.aspx sans elles. Dans l’entité Department , la Administrator propriété est une clé étrangère qui correspond à PersonID dans l’entité Person . Pour établir l’association entre un nouveau service et son administrateur, il vous suffisait de définir la valeur de la Administrator propriété dans le ItemInserting gestionnaire d’événements du contrôle de trafic de données :

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

Sans clés étrangères dans le modèle de données, vous géreriez l’événement Inserting du contrôle de source de données au lieu de l’événement ItemInserting du contrôle de trafic de données, afin d’obtenir une référence à l’entité elle-même avant l’ajout de l’entité au jeu d’entités. Lorsque vous disposez de cette référence, vous établissez l’association à l’aide de code semblable à celui-ci dans les exemples suivants :

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));

Comme vous pouvez le voir dans le billet de blog de l’équipe Entity Framework sur les associations de clés étrangères, il existe d’autres cas où la différence de complexité du code est beaucoup plus grande. Pour répondre aux besoins de ceux qui préfèrent utiliser les détails de l’implémentation dans le modèle de données conceptuel pour simplifier le code, Entity Framework vous donne désormais la possibilité d’inclure des clés étrangères dans le modèle de données.

Dans la terminologie d’Entity Framework, si vous incluez des clés étrangères dans le modèle de données, vous utilisez des associations de clés étrangères, et si vous excluez des clés étrangères, vous utilisez des associations indépendantes.

Exécution de commandes SQL User-Defined

Dans les versions antérieures d’Entity Framework, il n’existait pas de moyen simple de créer vos propres commandes SQL à la volée et de les exécuter. Entity Framework a généré dynamiquement des commandes SQL pour vous, ou vous avez dû créer une procédure stockée et l’importer en tant que fonction. La version 4 ajoute et ExecuteStoreCommand méthode ExecuteStoreQuery la ObjectContext classe qui vous permet de passer plus facilement n’importe quelle requête directement à la base de données.

Supposons que les administrateurs de Contoso University souhaitent être en mesure d’effectuer des modifications en bloc dans la base de données sans avoir à passer par le processus de création d’une procédure stockée et de son importation dans le modèle de données. Leur première demande concerne une page qui leur permet de modifier le nombre de crédits pour tous les cours de la base de données. Sur la page web, ils veulent pouvoir entrer un nombre à utiliser pour multiplier la valeur de la colonne de Credits chaque Course ligne.

Créez une page qui utilise la page Site.Master master et nommez-la UpdateCredits.aspx. Ajoutez ensuite le balisage suivant au Content contrôle nommé 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 />

Ce balisage crée un TextBox contrôle dans lequel l’utilisateur peut entrer la valeur du multiplicateur, un Button contrôle sur lequel cliquer pour exécuter la commande et un Label contrôle pour indiquer le nombre de lignes affectées.

Ouvrez UpdateCredits.aspx.cs, puis ajoutez l’instruction suivante using et un gestionnaire pour l’événement du Click bouton :

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

Ce code exécute la commande SQL Update à l’aide de la valeur dans la zone de texte et utilise l’étiquette pour afficher le nombre de lignes affectées. Avant d’exécuter la page, exécutez la page Courses.aspx pour obtenir une image « avant » de certaines données.

Image02

Exécutez UpdateCredits.aspx, entrez « 10 » comme multiplicateur, puis cliquez sur Exécuter.

Image03

Réexécutez la page Courses.aspx pour voir les données modifiées.

Image04

(Si vous souhaitez rétablir le nombre de crédits sur leurs valeurs d’origine, dans UpdateCredits.aspx.cs , remplacez Credits * {0}Credits / {0} la page et réexécutez la page, en entrant 10 comme diviseur.)

Pour plus d’informations sur l’exécution de requêtes que vous définissez dans le code, consultez Guide pratique pour exécuter directement des commandes sur la source de données.

développement Model-First

Dans ces procédures pas à pas, vous avez d’abord créé la base de données, puis généré le modèle de données en fonction de la structure de la base de données. Dans Entity Framework 4, vous pouvez commencer par le modèle de données à la place et générer la base de données en fonction de la structure du modèle de données. Si vous créez une application pour laquelle la base de données n’existe pas encore, l’approche model-first vous permet de créer des entités et des relations qui ont un sens conceptuel pour l’application, sans vous soucier des détails de l’implémentation physique. (Cela reste vrai uniquement pendant les phases initiales de développement, cependant. Finalement, la base de données sera créée et contiendra des données de production, et la recréer à partir du modèle ne sera plus pratique; à ce stade, vous revenez à l’approche de base de données.)

Dans cette section du tutoriel, vous allez créer un modèle de données simple et générer la base de données à partir de celui-ci.

Dans Explorateur de solutions, cliquez avec le bouton droit sur le dossier DAL et sélectionnez Ajouter un nouvel élément. Dans la boîte de dialogue Ajouter un nouvel élément , sous Modèles installés , sélectionnez Données , puis sélectionnez le modèle ADO.NET Modèle de données d’entité . Nommez le nouveau fichier AlumniAssociationModel.edmx , puis cliquez sur Ajouter.

Image06

Cela lance l’Assistant Modèle de données d’entité. À l’étape Choisir le contenu du modèle , sélectionnez Modèle vide , puis cliquez sur Terminer.

Image07

Le modèle de données d’entité Designer s’ouvre avec une aire de conception vide. Faites glisser un élément Entity de la boîte à outils vers l’aire de conception.

Image08

Remplacez le nom de l’entité par Entity1Alumnus, remplacez le nom de la Id propriété par AlumnusId, puis ajoutez une nouvelle propriété scalaire nommée Name. Pour ajouter de nouvelles propriétés, vous pouvez appuyer sur Entrée après avoir modifié le nom de la colonne, ou cliquer avec le Id bouton droit sur l’entité et sélectionner Ajouter une propriété scalaire. Le type par défaut pour les nouvelles propriétés est String, ce qui est parfait pour cette démonstration simple, mais bien sûr, vous pouvez modifier des éléments tels que le type de données dans la fenêtre Propriétés .

Créez une autre entité de la même façon et nommez-la Donation. Remplacez la Id propriété DonationId par et ajoutez une propriété scalaire nommée DateAndAmount.

Image09

Pour ajouter une association entre ces deux entités, cliquez avec le bouton droit sur l’entité Alumnus , sélectionnez Ajouter, puis Association.

Image10

Les valeurs par défaut de la boîte de dialogue Ajouter une association correspondent à ce que vous voulez (un à plusieurs, inclure des propriétés de navigation, inclure des clés étrangères), il vous suffit donc de cliquer sur OK.

Image11

Le concepteur ajoute une ligne d’association et une propriété de clé étrangère.

Image12

Vous êtes maintenant prêt à créer la base de données. Cliquez avec le bouton droit sur l’aire de conception et sélectionnez Générer une base de données à partir du modèle.

Image13

Cela lance l’Assistant Générer une base de données. (Si vous voyez des avertissements indiquant que les entités ne sont pas mappées, vous pouvez les ignorer pour le moment.)

À l’étape Choisir votre connexion de données , cliquez sur Nouvelle connexion.

Image14

Dans la boîte de dialogue Propriétés de connexion, sélectionnez le SQL Server Express instance local et nommez la base de données AlumniAssociation.

Image15

Cliquez sur Oui lorsque vous êtes invité à créer la base de données. Lorsque l’étape Choisir votre connexion de données s’affiche à nouveau, cliquez sur Suivant.

À l’étape Résumé et paramètres , cliquez sur Terminer.

Image18

Un fichier .sql avec les commandes DDL (Data Definition Language) est créé, mais les commandes n’ont pas encore été exécutées.

Image20

Utilisez un outil tel que SQL Server Management Studio pour exécuter le script et créer les tables, comme vous l’avez peut-être fait lors de la création de la School base de données pour le premier tutoriel de la série de tutoriels Prise en main. (Sauf si vous avez téléchargé la base de données.)

Vous pouvez maintenant utiliser le AlumniAssociation modèle de données dans vos pages web de la même façon que vous l’avez School utilisé. Pour essayer cela, ajoutez des données aux tables et créez une page web qui affiche les données.

À l’aide de Server Explorer, ajoutez les lignes suivantes aux Alumnus tables et Donation .

Image21

Créez une page web nommée Alumni.aspx qui utilise la page master Site.Master. Ajoutez le balisage suivant au Content contrôle nommé 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>

Ce balisage crée des contrôles imbriqués GridView , l’externe pour afficher les noms des anciens participants et l’intérieur pour afficher les dates et les montants des dons.

Ouvrez Alumni.aspx.cs. Ajoutez une using instruction pour la couche d’accès aux données et un gestionnaire pour l’événement du RowDataBound contrôle externe GridView :

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

Ce code relie le contrôle interne GridView à l’aide de la Donations propriété de navigation de l’entité de Alumnus la ligne actuelle.

Exécutez la page.

Image22

(Remarque : Cette page est incluse dans le projet téléchargeable, mais pour qu’elle fonctionne, vous devez créer la base de données dans votre SQL Server Express instance local ; la base de données n’est pas incluse en tant que fichier .mdf dans le dossier App_Data.)

Pour plus d’informations sur l’utilisation de la fonctionnalité model-first d’Entity Framework, consultez Model-First dans Entity Framework 4.

Prise en charge POCO

Lorsque vous utilisez une méthodologie de conception basée sur un domaine, vous concevez des classes de données qui représentent des données et un comportement pertinents pour le domaine métier. Ces classes doivent être indépendantes de toute technologie spécifique utilisée pour stocker (conserver) les données ; en d’autres termes, ils doivent être ignorants de persistance. L’ignorance de la persistance peut également faciliter le test unitaire d’une classe, car le projet de test unitaire peut utiliser la technologie de persistance la plus pratique pour les tests. Les versions antérieures d’Entity Framework offraient une prise en charge limitée de l’ignorance de la persistance, car les classes d’entité devaient hériter de la EntityObject classe et incluaient donc une grande partie des fonctionnalités propres à Entity Framework.

Entity Framework 4 introduit la possibilité d’utiliser des classes d’entité qui n’héritent pas de la EntityObject classe et sont donc ignorantes de la persistance. Dans le contexte d’Entity Framework, les classes comme celle-ci sont généralement appelées objets CLR simples (POCO, ou POCOs). Vous pouvez écrire des classes POCO manuellement, ou vous pouvez les générer automatiquement en fonction d’un modèle de données existant à l’aide de modèles T4 (Text Template Transformation Toolkit) fournis par Entity Framework.

Pour plus d’informations sur l’utilisation des POCO dans Entity Framework, consultez les ressources suivantes :

développement Code-First

La prise en charge de POCO dans Entity Framework 4 nécessite toujours la création d’un modèle de données et la liaison de vos classes d’entité au modèle de données. La prochaine version d’Entity Framework inclut une fonctionnalité appelée développement code-first. Cette fonctionnalité vous permet d’utiliser Entity Framework avec vos propres classes POCO sans avoir à utiliser le concepteur de modèle de données ou un fichier XML de modèle de données. (Par conséquent, cette option a également été appelée code uniquement ; code-first et code-only font référence à la même fonctionnalité Entity Framework.)

Pour plus d’informations sur l’utilisation de l’approche code-first du développement, consultez les ressources suivantes :

En outre, un nouveau didacticiel MVC Code-First qui génère une application similaire à l’application Contoso University est prévu pour être publié au printemps 2011 à l’adresse https://asp.net/entity-framework/tutorials

Informations complémentaires

Ceci complète la vue d’ensemble des nouveautés d’Entity Framework et la série de didacticiels Continuer avec Entity Framework. Pour plus d’informations sur les nouvelles fonctionnalités d’Entity Framework 4 qui ne sont pas couvertes ici, consultez les ressources suivantes :

Précédent