Tutoriel : Bien démarrer avec EF Core dans une application web ASP.NET MVCTutorial: Get started with EF Core in an ASP.NET MVC web app

Ce didacticiel décrit ASP.NET Core MVC et Entity Framework Core avec des contrôleurs et des vues.This tutorial teaches ASP.NET Core MVC and Entity Framework Core with controllers and views. Les pages Razor sont une nouvelle alternative dans ASP.NET Core 2.0. Il s’agit d’un modèle de programmation basé sur les pages qui permet de créer une interface utilisateur web de manière plus facile et plus efficace.Razor Pages is a new alternative in ASP.NET Core 2.0, a page-based programming model that makes building web UI easier and more productive. Nous recommandons le didacticiel sur les pages Razor plutôt que la version MVC.We recommend the Razor Pages tutorial over the MVC version. Le didacticiel sur les pages Razor :The Razor Pages tutorial:

  • est plus facile à suivre ;Is easier to follow.
  • Fournit d’autres bonnes pratiques sur EF Core.Provides more EF Core best practices.
  • Utilise des requêtes plus efficaces.Uses more efficient queries.
  • Est plus à jour avec la dernière API.Is more current with the latest API.
  • couvre davantage de fonctionnalités ;Covers more features.

L’exemple d’application web Contoso University montre comment créer des applications web ASP.NET Core 2.2 MVC à l’aide d’Entity Framework (EF) Core 2.2 et de Visual Studio 2017 ou 2019.The Contoso University sample web application demonstrates how to create ASP.NET Core 2.2 MVC web applications using Entity Framework (EF) Core 2.2 and Visual Studio 2017 or 2019.

L’exemple d’application est un site web pour une université Contoso fictive.The sample application is a web site for a fictional Contoso University. Il comprend des fonctionnalités telles que l’admission des étudiants, la création des cours et les affectations des formateurs.It includes functionality such as student admission, course creation, and instructor assignments. Ce document est le premier d’une série de didacticiels qui expliquent comment générer à partir de zéro l’exemple d’application Contoso University.This is the first in a series of tutorials that explain how to build the Contoso University sample application from scratch.

Dans ce didacticiel, vous avez effectué les actions suivantes :In this tutorial, you:

  • Créer une application web ASP.NET Core MVCCreate an ASP.NET Core MVC web app
  • Configurer le style du siteSet up the site style
  • En savoir plus sur les packages NuGet EF CoreLearn about EF Core NuGet packages
  • Créer le modèle de donnéesCreate the data model
  • Créer le contexte de base de donnéesCreate the database context
  • Inscrire le contexte pour l’injection de dépendanceRegister the context for dependency injection
  • Initialiser la base de données avec des données de testInitialize the database with test data
  • Créer un contrôleur et des vuesCreate a controller and views
  • Afficher la base de donnéesView the database

PrérequisPrerequisites

Résolution des problèmesTroubleshooting

Si vous rencontrez un problème que vous ne pouvez pas résoudre, vous pouvez généralement trouver la solution en comparant votre code au projet terminé.If you run into a problem you can't resolve, you can generally find the solution by comparing your code to the completed project. Pour obtenir la liste des erreurs courantes et comment les résoudre, consultez la section Dépannage du dernier didacticiel de la série.For a list of common errors and how to solve them, see the Troubleshooting section of the last tutorial in the series. Si vous n’y trouvez pas ce dont vous avez besoin, vous pouvez publier une question sur StackOverflow.com pour ASP.NET Core ou EF Core.If you don't find what you need there, you can post a question to StackOverflow.com for ASP.NET Core or EF Core.

Conseil

Il s’agit d’une série de 10 didacticiels, dont chacun s’appuie sur les opérations réalisées dans les précédents.This is a series of 10 tutorials, each of which builds on what is done in earlier tutorials. Pensez à enregistrer une copie du projet à la fin de chaque didacticiel réussi.Consider saving a copy of the project after each successful tutorial completion. Ainsi, si vous rencontrez des problèmes, vous pouvez recommencer à la fin du didacticiel précédent au lieu de revenir au début de la série entière.Then if you run into problems, you can start over from the previous tutorial instead of going back to the beginning of the whole series.

Application web Contoso UniversityContoso University web app

L’application que vous allez générer dans ces didacticiels est un site web simple d’université.The application you'll be building in these tutorials is a simple university web site.

Les utilisateurs peuvent afficher et mettre à jour les informations relatives aux étudiants, aux cours et aux formateurs.Users can view and update student, course, and instructor information. Voici quelques écrans que vous allez créer.Here are a few of the screens you'll create.

Page d’index des étudiants

Page de modification des étudiants

Créer une application webCreate web app

  • Ouvrez Visual Studio.Open Visual Studio.

  • Dans le menu Fichier, sélectionnez Nouveau > Projet.From the File menu, select New > Project.

  • Dans le volet gauche, sélectionnez Installé > Visual C# > Web.From the left pane, select Installed > Visual C# > Web.

  • Sélectionnez le modèle de projet Application web ASP.NET Core.Select the ASP.NET Core Web Application project template.

  • Entrez ContosoUniversity comme nom et cliquez sur OK.Enter ContosoUniversity as the name and click OK.

    Boîte de dialogue Nouveau projet

  • Patientez jusqu’à l’affichage de la boîte de dialogue Nouvelle application web ASP.NET Core.Wait for the New ASP.NET Core Web Application dialog to appear.

  • Sélectionnez .NET Core, ASP.NET Core 2.2 et le modèle Application web (Model-View-Controller).Select .NET Core, ASP.NET Core 2.2 and the Web Application (Model-View-Controller) template.

  • Vérifiez que le paramètre Authentification a pour valeur Aucune authentification.Make sure Authentication is set to No Authentication.

  • Sélectionnez OK.Select OK

    Boîte de dialogue Nouveau projet ASP.NET Core

Configurer le style du siteSet up the site style

Quelques changements simples configureront le menu, la disposition et la page d’accueil du site.A few simple changes will set up the site menu, layout, and home page.

Ouvrez Views/Shared/_Layout.cshtml et apportez les modifications suivantes :Open Views/Shared/_Layout.cshtml and make the following changes:

  • Remplacez chaque occurrence de « ContosoUniversity » par « Contoso University ».Change each occurrence of "ContosoUniversity" to "Contoso University". Il y a trois occurrences.There are three occurrences.

  • Ajoutez des entrées de menu pour About, Students, Courses, Instructors, et Departments, et supprimez l’entrée de menu Privacy.Add menu entries for About, Students, Courses, Instructors, and Departments, and delete the Privacy menu entry.

Les modifications sont mises en surbrillance.The changes are highlighted.

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>@ViewData["Title"] - Contoso University</title>

    <environment include="Development">
        <link rel="stylesheet" href="~/lib/bootstrap/dist/css/bootstrap.css" />
    </environment>
    <environment exclude="Development">
        <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/4.1.3/css/bootstrap.min.css"
              asp-fallback-href="~/lib/bootstrap/dist/css/bootstrap.min.css"
              asp-fallback-test-class="sr-only" asp-fallback-test-property="position" asp-fallback-test-value="absolute"
              crossorigin="anonymous"
              integrity="sha256-eSi1q2PG6J7g7ib17yAaWMcrr5GrtohYChqibrV7PBE="/>
    </environment>
    <link rel="stylesheet" href="~/css/site.css" />
</head>
<body>
    <header>
        <nav class="navbar navbar-expand-sm navbar-toggleable-sm navbar-light bg-white border-bottom box-shadow mb-3">
            <div class="container">
                <a class="navbar-brand" asp-area="" asp-controller="Home" asp-action="Index">Contoso University</a>
                <button class="navbar-toggler" type="button" data-toggle="collapse" data-target=".navbar-collapse" aria-controls="navbarSupportedContent"
                        aria-expanded="false" aria-label="Toggle navigation">
                    <span class="navbar-toggler-icon"></span>
                </button>
                <div class="navbar-collapse collapse d-sm-inline-flex flex-sm-row-reverse">
                    <ul class="navbar-nav flex-grow-1">
                        <li class="nav-item">
                            <a class="nav-link text-dark" asp-area="" asp-controller="Home" asp-action="Index">Home</a>
                        </li>
                        <li class="nav-item">
                            <a class="nav-link text-dark" asp-area="" asp-controller="Home" asp-action="About">About</a>
                        </li>
                        <li class="nav-item">
                            <a class="nav-link text-dark" asp-area="" asp-controller="Students" asp-action="Index">Students</a>
                        </li>
                        <li class="nav-item">
                            <a class="nav-link text-dark" asp-area="" asp-controller="Courses" asp-action="Index">Courses</a>
                        </li>
                        <li class="nav-item">
                            <a class="nav-link text-dark" asp-area="" asp-controller="Instructors" asp-action="Index">Instructors</a>
                        </li>
                        <li class="nav-item">
                            <a class="nav-link text-dark" asp-area="" asp-controller="Departments" asp-action="Index">Departments</a>
                        </li>
                    </ul>
                </div>
            </div>
        </nav>
    </header>
    <div class="container">
        <partial name="_CookieConsentPartial" />
        <main role="main" class="pb-3">
            @RenderBody()
        </main>
    </div>

    <footer class="border-top footer text-muted">
        <div class="container">
            &copy; 2019 - Contoso University - <a asp-area="" asp-controller="Home" asp-action="Privacy">Privacy</a>
        </div>
    </footer>

    <environment include="Development">
        <script src="~/lib/jquery/dist/jquery.js"></script>
        <script src="~/lib/bootstrap/dist/js/bootstrap.bundle.js"></script>
    </environment>
    <environment exclude="Development">
        <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"
                asp-fallback-src="~/lib/jquery/dist/jquery.min.js"
                asp-fallback-test="window.jQuery"
                crossorigin="anonymous"
                integrity="sha256-FgpCb/KJQlLNfOu91ta32o/NMZxltwRo8QtmkMRdAu8=">
        </script>
        <script src="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/4.1.3/js/bootstrap.bundle.min.js"
                asp-fallback-src="~/lib/bootstrap/dist/js/bootstrap.bundle.min.js"
                asp-fallback-test="window.jQuery && window.jQuery.fn && window.jQuery.fn.modal"
                crossorigin="anonymous"
                integrity="sha256-E/V4cWE4qvAeO5MOhjtGtqDzPndRO1LBk8lJ/PR7CA4=">
        </script>
    </environment>
    <script src="~/js/site.js" asp-append-version="true"></script>

    @RenderSection("Scripts", required: false)
</body>
</html>

Dans Views/Home/Index.cshtml, remplacez le contenu du fichier par le code suivant, afin de remplacer le texte relatif à ASP.NET et MVC par le texte relatif à cette application :In Views/Home/Index.cshtml, replace the contents of the file with the following code to replace the text about ASP.NET and MVC with text about this application:

@{
    ViewData["Title"] = "Home Page";
}

<div class="jumbotron">
    <h1>Contoso University</h1>
</div>
<div class="row">
    <div class="col-md-4">
        <h2>Welcome to Contoso University</h2>
        <p>
            Contoso University is a sample application that
            demonstrates how to use Entity Framework Core in an
            ASP.NET Core MVC web application.
        </p>
    </div>
    <div class="col-md-4">
        <h2>Build it from scratch</h2>
        <p>You can build the application by following the steps in a series of tutorials.</p>
        <p><a class="btn btn-default" href="https://docs.asp.net/en/latest/data/ef-mvc/intro.html">See the tutorial &raquo;</a></p>
    </div>
    <div class="col-md-4">
        <h2>Download it</h2>
        <p>You can download the completed project from GitHub.</p>
        <p><a class="btn btn-default" href="https://github.com/aspnet/Docs/tree/master/aspnetcore/data/ef-mvc/intro/samples/cu-final">See project source code &raquo;</a></p>
    </div>
</div>

Appuyez sur Ctrl+F5 pour exécuter le projet ou choisissez Déboguer > Exécuter sans débogage dans le menu.Press CTRL+F5 to run the project or choose Debug > Start Without Debugging from the menu. Vous voyez la page d’accueil avec des onglets pour les pages que vous allez créer dans ces didacticiels.You see the home page with tabs for the pages you'll create in these tutorials.

Page d’accueil de Contoso University

À propos des packages NuGet EF CoreAbout EF Core NuGet packages

Pour ajouter la prise en charge d’EF Core à un projet, installez le fournisseur de bases de données que vous souhaitez cibler.To add EF Core support to a project, install the database provider that you want to target. Ce didacticiel utilise SQL Server et le package de fournisseur est Microsoft.EntityFrameworkCore.SqlServer.This tutorial uses SQL Server, and the provider package is Microsoft.EntityFrameworkCore.SqlServer. Ce package étant inclus dans le métapaquet Microsoft.AspNetCore.App, vous n’avez pas besoin de le référencer.This package is included in the Microsoft.AspNetCore.App metapackage, so you don't need to reference the package.

Le package EF SQL Server et ses dépendances (Microsoft.EntityFrameworkCore et Microsoft.EntityFrameworkCore.Relational) fournissent la prise en charge du runtime pour EF.The EF SQL Server package and its dependencies (Microsoft.EntityFrameworkCore and Microsoft.EntityFrameworkCore.Relational) provide runtime support for EF. Vous ajouterez un package d’outils ultérieurement, dans le didacticiel Migrations.You'll add a tooling package later, in the Migrations tutorial.

Pour obtenir des informations sur les autres fournisseurs de bases de données qui sont disponibles pour Entity Framework Core, consultez Fournisseurs de bases de données.For information about other database providers that are available for Entity Framework Core, see Database providers.

Créer le modèle de donnéesCreate the data model

Ensuite, vous allez créer des classes d’entités pour l’application Contoso University.Next you'll create entity classes for the Contoso University application. Vous commencerez avec les trois entités suivantes.You'll start with the following three entities.

Diagramme du modèle de données Course-Enrollment-Student

Il existe une relation un-à-plusieurs entre les entités Student et Enrollment, et une relation un-à-plusieurs entre les entités Course et Enrollment.There's a one-to-many relationship between Student and Enrollment entities, and there's a one-to-many relationship between Course and Enrollment entities. En d’autres termes, un étudiant peut être inscrit dans un nombre quelconque de cours et un cours peut avoir un nombre quelconque d’élèves inscrits.In other words, a student can be enrolled in any number of courses, and a course can have any number of students enrolled in it.

Dans les sections suivantes, vous allez créer une classe pour chacune de ces entités.In the following sections you'll create a class for each one of these entities.

Entité StudentThe Student entity

Diagramme de l’entité Student

Dans le dossier Models, créez un fichier de classe nommé Student.cs et remplacez le code du modèle par le code suivant.In the Models folder, create a class file named Student.cs and replace the template code with the following code.

using System;
using System.Collections.Generic;

namespace ContosoUniversity.Models
{
    public class Student
    {
        public int ID { get; set; }
        public string LastName { get; set; }
        public string FirstMidName { get; set; }
        public DateTime EnrollmentDate { get; set; }

        public ICollection<Enrollment> Enrollments { get; set; }
    }
}

La propriété ID devient la colonne de clé primaire de la table de base de données qui correspond à cette classe.The ID property will become the primary key column of the database table that corresponds to this class. Par défaut, Entity Framework interprète une propriété nommée ID ou classnameID comme clé primaire.By default, the Entity Framework interprets a property that's named ID or classnameID as the primary key.

La propriété Enrollments est une propriété de navigation.The Enrollments property is a navigation property. Les propriétés de navigation contiennent d’autres entités qui sont associées à cette entité.Navigation properties hold other entities that are related to this entity. Dans ce cas, la propriété Enrollments d’un Student entity contient toutes les entités Enrollment associées à l’entité Student.In this case, the Enrollments property of a Student entity will hold all of the Enrollment entities that are related to that Student entity. En d’autres termes, si une ligne Student donnée dans la base de données a deux lignes Enrollment associées (lignes qui contiennent la valeur de clé primaire de cet étudiant dans la colonne de clé étrangère StudentID), la propriété de navigation Enrollments de cette entité Student contiendra ces deux entités Enrollment.In other words, if a given Student row in the database has two related Enrollment rows (rows that contain that student's primary key value in their StudentID foreign key column), that Student entity's Enrollments navigation property will contain those two Enrollment entities.

Si une propriété de navigation peut contenir plusieurs entités (comme dans des relations plusieurs à plusieurs ou un -à-plusieurs), son type doit être une liste dans laquelle les entrées peuvent être ajoutées, supprimées et mises à jour, telle que ICollection<T>.If a navigation property can hold multiple entities (as in many-to-many or one-to-many relationships), its type must be a list in which entries can be added, deleted, and updated, such as ICollection<T>. Vous pouvez spécifier ICollection<T> ou un type tel que List<T> ou HashSet<T>.You can specify ICollection<T> or a type such as List<T> or HashSet<T>. Si vous spécifiez ICollection<T>, EF crée une collection HashSet<T> par défaut.If you specify ICollection<T>, EF creates a HashSet<T> collection by default.

Entité EnrollmentThe Enrollment entity

Diagramme de l’entité Enrollment

Dans le dossier Models, créez Enrollment.cs et remplacez le code existant par le code suivant :In the Models folder, create Enrollment.cs and replace the existing code with the following code:

namespace ContosoUniversity.Models
{
    public enum Grade
    {
        A, B, C, D, F
    }

    public class Enrollment
    {
        public int EnrollmentID { get; set; }
        public int CourseID { get; set; }
        public int StudentID { get; set; }
        public Grade? Grade { get; set; }

        public Course Course { get; set; }
        public Student Student { get; set; }
    }
}

La propriété EnrollmentID sera la clé primaire. Cette entité utilise le modèle classnameID à la place de ID par lui-même, comme vous l’avez vu dans l’entité Student.The EnrollmentID property will be the primary key; this entity uses the classnameID pattern instead of ID by itself as you saw in the Student entity. En général, vous choisissez un modèle et l’utilisez dans tout votre modèle de données.Ordinarily you would choose one pattern and use it throughout your data model. Ici, la variante illustre que vous pouvez utiliser l’un ou l’autre modèle.Here, the variation illustrates that you can use either pattern. Dans un prochain didacticiel, vous verrez comment l’utilisation de l’ID sans classname simplifie l’implémentation de l’héritage dans le modèle de données.In a later tutorial, you'll see how using ID without classname makes it easier to implement inheritance in the data model.

La propriété Grade est un enum.The Grade property is an enum. Le point d’interrogation après la déclaration de type Grade indique que la propriété Grade est nullable.The question mark after the Grade type declaration indicates that the Grade property is nullable. Une note (Grade) qui a la valeur Null est différente d’une note égale à zéro : la valeur Null signifie qu’une note n’est pas connue ou n’a pas encore été affectée.A grade that's null is different from a zero grade -- null means a grade isn't known or hasn't been assigned yet.

La propriété StudentID est une clé étrangère et la propriété de navigation correspondante est Student.The StudentID property is a foreign key, and the corresponding navigation property is Student. Une entité Enrollment est associée à une entité Student, donc la propriété peut contenir uniquement une entité Student unique (contrairement à la propriété de navigation Student.Enrollments que vous avez vue précédemment, qui peut contenir plusieurs entités Enrollment).An Enrollment entity is associated with one Student entity, so the property can only hold a single Student entity (unlike the Student.Enrollments navigation property you saw earlier, which can hold multiple Enrollment entities).

La propriété CourseID est une clé étrangère et la propriété de navigation correspondante est Course.The CourseID property is a foreign key, and the corresponding navigation property is Course. Une entité Enrollment est associée à une entité Course.An Enrollment entity is associated with one Course entity.

Entity Framework interprète une propriété comme une propriété de clé étrangère si elle est nommée <navigation property name><primary key property name> (par exemple, StudentID pour la propriété de navigation Student, puisque la clé primaire de l’entité Student est ID).Entity Framework interprets a property as a foreign key property if it's named <navigation property name><primary key property name> (for example, StudentID for the Student navigation property since the Student entity's primary key is ID). Les propriétés de clé étrangère peuvent également être nommées simplement <primary key property name> (par exemple, CourseID, puisque la clé primaire de l’entité Course est CourseID).Foreign key properties can also be named simply <primary key property name> (for example, CourseID since the Course entity's primary key is CourseID).

Entité CourseThe Course entity

Diagramme de l’entité Course

Dans le dossier Models, créez cs et remplacez le code existant par le code suivant :In the Models folder, create Course.cs and replace the existing code with the following code:

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations.Schema;

namespace ContosoUniversity.Models
{
    public class Course
    {
        [DatabaseGenerated(DatabaseGeneratedOption.None)]
        public int CourseID { get; set; }
        public string Title { get; set; }
        public int Credits { get; set; }

        public ICollection<Enrollment> Enrollments { get; set; }
    }
}

La propriété Enrollments est une propriété de navigation.The Enrollments property is a navigation property. Une entité Course peut être associée à un nombre quelconque d’entités Enrollment.A Course entity can be related to any number of Enrollment entities.

Nous fournirons plus de détails sur l’attribut DatabaseGenerated dans un didacticiel ultérieur de cette série.We'll say more about the DatabaseGenerated attribute in a later tutorial in this series. En fait, cet attribut vous permet d’entrer la clé primaire pour le cours plutôt que de laisser la base de données la générer.Basically, this attribute lets you enter the primary key for the course rather than having the database generate it.

Créer le contexte de base de donnéesCreate the database context

La classe principale qui coordonne les fonctionnalités d’Entity Framework pour un modèle de données spécifié est la classe de contexte de base de données.The main class that coordinates Entity Framework functionality for a given data model is the database context class. Vous créez cette classe en dérivant de la classe Microsoft.EntityFrameworkCore.DbContext.You create this class by deriving from the Microsoft.EntityFrameworkCore.DbContext class. Dans votre code, vous spécifiez les entités qui sont incluses dans le modèle de données.In your code you specify which entities are included in the data model. Vous pouvez également personnaliser un certain comportement d’Entity Framework.You can also customize certain Entity Framework behavior. Dans ce projet, la classe est nommée SchoolContext.In this project, the class is named SchoolContext.

Dans le dossier du projet, créez un dossier nommé Data.In the project folder, create a folder named Data.

Dans ce dossier Data, créez un nouveau fichier de classe nommé SchoolContext.cs et remplacez le code du modèle par le code suivant :In the Data folder create a new class file named SchoolContext.cs, and replace the template code with the following code:

using ContosoUniversity.Models;
using Microsoft.EntityFrameworkCore;

namespace ContosoUniversity.Data
{
    public class SchoolContext : DbContext
    {
        public SchoolContext(DbContextOptions<SchoolContext> options) : base(options)
        {
        }

        public DbSet<Course> Courses { get; set; }
        public DbSet<Enrollment> Enrollments { get; set; }
        public DbSet<Student> Students { get; set; }
    }
}

Ce code crée une propriété DbSet pour chaque jeu d’entités.This code creates a DbSet property for each entity set. Dans la terminologie Entity Framework, un jeu d’entités correspond généralement à une table de base de données, et une entité correspond à une ligne dans la table.In Entity Framework terminology, an entity set typically corresponds to a database table, and an entity corresponds to a row in the table.

Vous pourriez avoir omis les instructions DbSet<Enrollment> et DbSet<Course>, et cela fonctionnerait de la même façon.You could've omitted the DbSet<Enrollment> and DbSet<Course> statements and it would work the same. Entity Framework les inclurait implicitement, car l’entité Student référence l’entité Enrollment, et l’entité Enrollment référence l’entité Course.The Entity Framework would include them implicitly because the Student entity references the Enrollment entity and the Enrollment entity references the Course entity.

Quand la base de données est créée, EF crée des tables dont les noms sont identiques aux noms de propriété DbSet.When the database is created, EF creates tables that have names the same as the DbSet property names. Les noms de propriété pour les collections sont généralement pluriels (Students plutôt que Student), mais les développeurs ne sont pas tous d’accord sur la nécessité d’utiliser des noms de tables au pluriel.Property names for collections are typically plural (Students rather than Student), but developers disagree about whether table names should be pluralized or not. Pour ces didacticiels, vous remplacerez le comportement par défaut en spécifiant des noms de tables au singulier dans le contexte DbContext.For these tutorials you'll override the default behavior by specifying singular table names in the DbContext. Pour ce faire, ajoutez le code en surbrillance suivant après la dernière propriété DbSet.To do that, add the following highlighted code after the last DbSet property.

using ContosoUniversity.Models;
using Microsoft.EntityFrameworkCore;

namespace ContosoUniversity.Data
{
    public class SchoolContext : DbContext
    {
        public SchoolContext(DbContextOptions<SchoolContext> options) : base(options)
        {
        }

        public DbSet<Course> Courses { get; set; }
        public DbSet<Enrollment> Enrollments { get; set; }
        public DbSet<Student> Students { get; set; }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Course>().ToTable("Course");
            modelBuilder.Entity<Enrollment>().ToTable("Enrollment");
            modelBuilder.Entity<Student>().ToTable("Student");
        }
    }
}

Inscrire SchoolContextRegister the SchoolContext

ASP.NET Core implémente l’injection de dépendance par défaut.ASP.NET Core implements dependency injection by default. Des services (tels que le contexte de base de données EF) sont inscrits avec l’injection de dépendance au démarrage de l’application.Services (such as the EF database context) are registered with dependency injection during application startup. Ces services sont affectés aux composants qui les nécessitent (tels que les contrôleurs MVC) par le biais de paramètres de constructeur.Components that require these services (such as MVC controllers) are provided these services via constructor parameters. Vous verrez le code de constructeur de contrôleur qui obtient une instance de contexte plus loin dans ce didacticiel.You'll see the controller constructor code that gets a context instance later in this tutorial.

Pour inscrire SchoolContext en tant que service, ouvrez Startup.cs et ajoutez les lignes en surbrillance à la méthode ConfigureServices.To register SchoolContext as a service, open Startup.cs, and add the highlighted lines to the ConfigureServices method.

public void ConfigureServices(IServiceCollection services)
{
    services.Configure<CookiePolicyOptions>(options =>
    {
        options.CheckConsentNeeded = context => true;
        options.MinimumSameSitePolicy = SameSiteMode.None;
    });

    services.AddDbContext<SchoolContext>(options =>
        options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

    services.AddMvc();
}

Le nom de la chaîne de connexion est transmis au contexte en appelant une méthode sur un objet DbContextOptionsBuilder.The name of the connection string is passed in to the context by calling a method on a DbContextOptionsBuilder object. Pour le développement local, le système de configuration ASP.NET Core lit la chaîne de connexion à partir du fichier appsettings.json.For local development, the ASP.NET Core configuration system reads the connection string from the appsettings.json file.

Ajoutez des instructions using pour les espaces de noms ContosoUniversity.Data et Microsoft.EntityFrameworkCore, puis générez le projet.Add using statements for ContosoUniversity.Data and Microsoft.EntityFrameworkCore namespaces, and then build the project.

using ContosoUniversity.Data;
using Microsoft.EntityFrameworkCore;
using Microsoft.AspNetCore.Http;

Ouvrez le fichier appsettings.json et ajoutez une chaîne de connexion comme indiqué dans l’exemple suivant.Open the appsettings.json file and add a connection string as shown in the following example.

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=(localdb)\\mssqllocaldb;Database=ContosoUniversity1;Trusted_Connection=True;MultipleActiveResultSets=true"
  },
  "Logging": {
    "IncludeScopes": false,
    "LogLevel": {
      "Default": "Warning"
    }
  }
}

SQL Server Express LocalDBSQL Server Express LocalDB

La chaîne de connexion spécifie une base de données SQL Server LocalDB.The connection string specifies a SQL Server LocalDB database. LocalDB est une version allégée du moteur de base de données SQL Server Express. Elle est destinée au développement d’applications, et non à une utilisation en production.LocalDB is a lightweight version of the SQL Server Express Database Engine and is intended for application development, not production use. LocalDB démarre à la demande et s’exécute en mode utilisateur, ce qui n’implique aucune configuration complexe.LocalDB starts on demand and runs in user mode, so there's no complex configuration. Par défaut, LocalDB crée des fichiers de base de données .mdf dans le répertoire C:/Users/<user>.By default, LocalDB creates .mdf database files in the C:/Users/<user> directory.

Initialiser la base de données avec des données de testInitialize DB with test data

Entity Framework créera une base de données vide pour vous.The Entity Framework will create an empty database for you. Dans cette section, vous écrivez une méthode qui est appelée après la création de la base de données pour la remplir avec des données de test.In this section, you write a method that's called after the database is created in order to populate it with test data.

Là, vous allez utiliser la méthode EnsureCreated pour créer automatiquement la base de données.Here you'll use the EnsureCreated method to automatically create the database. Dans un didacticiel ultérieur, vous verrez comment traiter les modifications des modèles à l’aide des migrations Code First pour modifier le schéma de base de données au lieu de supprimer et de recréer la base de données.In a later tutorial you'll see how to handle model changes by using Code First Migrations to change the database schema instead of dropping and re-creating the database.

Dans le dossier Data, créez un nouveau fichier de classe nommé DbInitializer.cs et remplacez le code de modèle par le code suivant, qui entraîne la création d’une base de données, si nécessaire, et charge les données de test dans la nouvelle base de données.In the Data folder, create a new class file named DbInitializer.cs and replace the template code with the following code, which causes a database to be created when needed and loads test data into the new database.

using ContosoUniversity.Models;
using System;
using System.Linq;

namespace ContosoUniversity.Data
{
    public static class DbInitializer
    {
        public static void Initialize(SchoolContext context)
        {
            context.Database.EnsureCreated();

            // Look for any students.
            if (context.Students.Any())
            {
                return;   // DB has been seeded
            }

            var students = new Student[]
            {
            new Student{FirstMidName="Carson",LastName="Alexander",EnrollmentDate=DateTime.Parse("2005-09-01")},
            new Student{FirstMidName="Meredith",LastName="Alonso",EnrollmentDate=DateTime.Parse("2002-09-01")},
            new Student{FirstMidName="Arturo",LastName="Anand",EnrollmentDate=DateTime.Parse("2003-09-01")},
            new Student{FirstMidName="Gytis",LastName="Barzdukas",EnrollmentDate=DateTime.Parse("2002-09-01")},
            new Student{FirstMidName="Yan",LastName="Li",EnrollmentDate=DateTime.Parse("2002-09-01")},
            new Student{FirstMidName="Peggy",LastName="Justice",EnrollmentDate=DateTime.Parse("2001-09-01")},
            new Student{FirstMidName="Laura",LastName="Norman",EnrollmentDate=DateTime.Parse("2003-09-01")},
            new Student{FirstMidName="Nino",LastName="Olivetto",EnrollmentDate=DateTime.Parse("2005-09-01")}
            };
            foreach (Student s in students)
            {
                context.Students.Add(s);
            }
            context.SaveChanges();

            var courses = new Course[]
            {
            new Course{CourseID=1050,Title="Chemistry",Credits=3},
            new Course{CourseID=4022,Title="Microeconomics",Credits=3},
            new Course{CourseID=4041,Title="Macroeconomics",Credits=3},
            new Course{CourseID=1045,Title="Calculus",Credits=4},
            new Course{CourseID=3141,Title="Trigonometry",Credits=4},
            new Course{CourseID=2021,Title="Composition",Credits=3},
            new Course{CourseID=2042,Title="Literature",Credits=4}
            };
            foreach (Course c in courses)
            {
                context.Courses.Add(c);
            }
            context.SaveChanges();

            var enrollments = new Enrollment[]
            {
            new Enrollment{StudentID=1,CourseID=1050,Grade=Grade.A},
            new Enrollment{StudentID=1,CourseID=4022,Grade=Grade.C},
            new Enrollment{StudentID=1,CourseID=4041,Grade=Grade.B},
            new Enrollment{StudentID=2,CourseID=1045,Grade=Grade.B},
            new Enrollment{StudentID=2,CourseID=3141,Grade=Grade.F},
            new Enrollment{StudentID=2,CourseID=2021,Grade=Grade.F},
            new Enrollment{StudentID=3,CourseID=1050},
            new Enrollment{StudentID=4,CourseID=1050},
            new Enrollment{StudentID=4,CourseID=4022,Grade=Grade.F},
            new Enrollment{StudentID=5,CourseID=4041,Grade=Grade.C},
            new Enrollment{StudentID=6,CourseID=1045},
            new Enrollment{StudentID=7,CourseID=3141,Grade=Grade.A},
            };
            foreach (Enrollment e in enrollments)
            {
                context.Enrollments.Add(e);
            }
            context.SaveChanges();
        }
    }
}

Le code vérifie si des étudiants figurent dans la base de données et, dans la négative, il suppose que la base de données est nouvelle et doit être initialement peuplée avec des données de test.The code checks if there are any students in the database, and if not, it assumes the database is new and needs to be seeded with test data. Il charge les données de test dans les tableaux plutôt que dans les collections List<T> afin d’optimiser les performances.It loads test data into arrays rather than List<T> collections to optimize performance.

Dans Program.cs, modifiez la méthode Main pour effectuer les opérations suivantes au démarrage de l’application :In Program.cs, modify the Main method to do the following on application startup:

  • Obtenir une instance de contexte de base de données à partir du conteneur d’injection de dépendance.Get a database context instance from the dependency injection container.
  • Appeler la méthode de remplissage initial, en lui transmettant le contexte.Call the seed method, passing to it the context.
  • Supprimer le contexte une fois l’exécution de la méthode de peuplement initial terminée.Dispose the context when the seed method is done.
public static void Main(string[] args)
{
     var host = CreateWebHostBuilder(args).Build();

    using (var scope = host.Services.CreateScope())
    {
        var services = scope.ServiceProvider;
        try
        {
            var context = services.GetRequiredService<SchoolContext>();
            DbInitializer.Initialize(context);
        }
        catch (Exception ex)
        {
            var logger = services.GetRequiredService<ILogger<Program>>();
            logger.LogError(ex, "An error occurred while seeding the database.");
        }
    }

    host.Run();
}

Ajoutez des instructions using :Add using statements:

using Microsoft.Extensions.DependencyInjection;
using ContosoUniversity.Data;

Dans les didacticiels plus anciens, vous pouvez voir un code similaire dans la méthode Configure, dans Startup.cs.In older tutorials, you may see similar code in the Configure method in Startup.cs. Nous vous recommandons d’utiliser la méthode Configure uniquement pour configurer le pipeline de demande.We recommend that you use the Configure method only to set up the request pipeline. Le code de démarrage d’application doit figurer dans la méthode Main.Application startup code belongs in the Main method.

À présent, la première fois que vous exécutez l’application, la base de données est créée et initialement peuplée avec les données de test.Now the first time you run the application, the database will be created and seeded with test data. Chaque fois que vous changez votre modèle de données, vous pouvez supprimer la base de données, mettre à jour votre méthode de peuplement initial et repartir de la même façon avec une nouvelle base de données.Whenever you change your data model, you can delete the database, update your seed method, and start afresh with a new database the same way. Dans les didacticiels suivants, vous verrez comment modifier la base de données quand le modèle de données change, sans supprimer et recréer la base de données.In later tutorials, you'll see how to modify the database when the data model changes, without deleting and re-creating it.

Créer un contrôleur et des vuesCreate controller and views

Ensuite, vous utiliserez le moteur de génération de modèles automatique dans Visual Studio pour ajouter un contrôleur MVC et les vues qu’utilisera EF pour exécuter des requêtes de données et enregistrer les données.Next, you'll use the scaffolding engine in Visual Studio to add an MVC controller and views that will use EF to query and save data.

La création automatique de vues et de méthodes d’action CRUD porte le nom de génération de modèles automatique.The automatic creation of CRUD action methods and views is known as scaffolding. La génération de modèles automatique diffère de la génération de code dans la mesure où le code obtenu par génération de modèles automatique est un point de départ que vous pouvez modifier pour prendre en compte vos propres exigences, tandis qu’en général vous ne modifiez pas le code généré.Scaffolding differs from code generation in that the scaffolded code is a starting point that you can modify to suit your own requirements, whereas you typically don't modify generated code. Lorsque vous avez besoin de personnaliser le code généré, vous utilisez des classes partielles ou vous regénérez le code en cas de changements.When you need to customize generated code, you use partial classes or you regenerate the code when things change.

  • Cliquez avec le bouton droit sur le dossier Contrôleurs dans l’Explorateur de solutions, puis sélectionnez Ajouter > Nouvel élément généré automatiquement.Right-click the Controllers folder in Solution Explorer and select Add > New Scaffolded Item.

  • Dans la boîte de dialogue Ajouter un modèle automatique :In the Add Scaffold dialog box:

    • Sélectionnez Contrôleur MVC avec vues, utilisant Entity Framework.Select MVC controller with views, using Entity Framework.

    • Cliquez sur Ajouter.Click Add. La boîte de dialogue Ajouter un contrôleur MVC avec vues, utilisant Entity Framework s’affiche.The Add MVC Controller with views, using Entity Framework dialog box appears.

      Génération de modèles automatique – Étudiant

    • Dans Classe de modèle, sélectionnez Student.In Model class select Student.

    • Dans Classe du contexte de données, sélectionnez SchoolContext.In Data context class select SchoolContext.

    • Acceptez la valeur par défaut StudentsController comme nom.Accept the default StudentsController as the name.

    • Cliquez sur Ajouter.Click Add.

    Lorsque vous cliquez sur Ajouter, le moteur de génération de modèles automatique de Visual Studio crée un fichier StudentsController.cs et un ensemble de vues (fichiers .cshtml) qui fonctionnent avec le contrôleur.When you click Add, the Visual Studio scaffolding engine creates a StudentsController.cs file and a set of views (.cshtml files) that work with the controller.

(Le moteur de génération de modèles automatique peut également créer le contexte de base de données pour vous, si vous ne l’avez pas déjà créé manuellement, comme vous l’avez fait précédemment pour ce didacticiel.(The scaffolding engine can also create the database context for you if you don't create it manually first as you did earlier for this tutorial. Vous pouvez spécifier une nouvelle classe de contexte dans la zone Ajouter un contrôleur en cliquant sur le signe plus à droite de Classe du contexte de données.You can specify a new context class in the Add Controller box by clicking the plus sign to the right of Data context class. Visual Studio crée ensuite votre classe DbContext ainsi que le contrôleur et les vues.)Visual Studio will then create your DbContext class as well as the controller and views.)

Vous pouvez remarquer que le contrôleur accepte un SchoolContext comme paramètre de constructeur.You'll notice that the controller takes a SchoolContext as a constructor parameter.

namespace ContosoUniversity.Controllers
{
    public class StudentsController : Controller
    {
        private readonly SchoolContext _context;

        public StudentsController(SchoolContext context)
        {
            _context = context;
        }

L’injection de dépendance ASP.NET Core s’occupe de la transmission d’une instance de SchoolContext dans le contrôleur.ASP.NET Core dependency injection takes care of passing an instance of SchoolContext into the controller. Vous avez configuré cela dans le fichier Startup.cs précédemment.You configured that in the Startup.cs file earlier.

Le contrôleur contient une méthode d’action Index, qui affiche tous les étudiants dans la base de données.The controller contains an Index action method, which displays all students in the database. La méthode obtient la liste des étudiants du jeu d’entités Students en lisant la propriété Students de l’instance de contexte de base de données :The method gets a list of students from the Students entity set by reading the Students property of the database context instance:

public async Task<IActionResult> Index()
{
    return View(await _context.Students.ToListAsync());
}

Vous découvrirez les éléments de programmation asynchrones dans ce code, plus loin dans ce didacticiel.You'll learn about the asynchronous programming elements in this code later in the tutorial.

La vue Views/Students/Index.cshtml affiche cette liste dans une table :The Views/Students/Index.cshtml view displays this list in a table:

@model IEnumerable<ContosoUniversity.Models.Student>

@{
    ViewData["Title"] = "Index";
}

<h2>Index</h2>

<p>
    <a asp-action="Create">Create New</a>
</p>
<table class="table">
    <thead>
        <tr>
                <th>
                    @Html.DisplayNameFor(model => model.LastName)
                </th>
                <th>
                    @Html.DisplayNameFor(model => model.FirstMidName)
                </th>
                <th>
                    @Html.DisplayNameFor(model => model.EnrollmentDate)
                </th>
            <th></th>
        </tr>
    </thead>
    <tbody>
@foreach (var item in Model) {
        <tr>
            <td>
                @Html.DisplayFor(modelItem => item.LastName)
            </td>
            <td>
                @Html.DisplayFor(modelItem => item.FirstMidName)
            </td>
            <td>
                @Html.DisplayFor(modelItem => item.EnrollmentDate)
            </td>
            <td>
                <a asp-action="Edit" asp-route-id="@item.ID">Edit</a> |
                <a asp-action="Details" asp-route-id="@item.ID">Details</a> |
                <a asp-action="Delete" asp-route-id="@item.ID">Delete</a>
            </td>
        </tr>
}
    </tbody>
</table>

Appuyez sur Ctrl+F5 pour exécuter le projet ou choisissez Déboguer > Exécuter sans débogage dans le menu.Press CTRL+F5 to run the project or choose Debug > Start Without Debugging from the menu.

Cliquez sur l’onglet Students pour afficher les données de test que la méthode DbInitializer.Initialize a insérées.Click the Students tab to see the test data that the DbInitializer.Initialize method inserted. Selon l’étroitesse de votre fenêtre de navigateur, vous verrez le lien de l’onglet Students en haut de la page ou vous devrez cliquer sur l’icône de navigation dans le coin supérieur droit pour afficher le lien.Depending on how narrow your browser window is, you'll see the Students tab link at the top of the page or you'll have to click the navigation icon in the upper right corner to see the link.

Page d’accueil étroite de Contoso University

Page d’index des étudiants

Afficher la base de donnéesView the database

Lorsque vous avez démarré l’application, la méthode DbInitializer.Initialize appelle EnsureCreated.When you started the application, the DbInitializer.Initialize method calls EnsureCreated. EF a vu qu’il n’y avait pas de base de données et en a donc créé une, puis le reste du code de la méthode Initialize a rempli la base de données avec des données.EF saw that there was no database and so it created one, then the remainder of the Initialize method code populated the database with data. Vous pouvez utiliser l’Explorateur d’objets SQL Server (SSOX) pour afficher la base de données dans Visual Studio.You can use SQL Server Object Explorer (SSOX) to view the database in Visual Studio.

Fermez le navigateur.Close the browser.

Si la fenêtre SSOX n’est pas déjà ouverte, sélectionnez-la dans le menu Affichage de Visual Studio.If the SSOX window isn't already open, select it from the View menu in Visual Studio.

Dans SSOX, cliquez sur (localdb)\MSSQLLocalDB > Bases de données, puis cliquez sur l’entrée pour le nom de la base de données qui se trouve dans la chaîne de connexion, dans votre fichier appsettings.json.In SSOX, click (localdb)\MSSQLLocalDB > Databases, and then click the entry for the database name that's in the connection string in your appsettings.json file.

Développez le nœud Tables pour afficher les tables de votre base de données.Expand the Tables node to see the tables in your database.

Tables dans SSOX

Cliquez avec le bouton droit sur la table Student et cliquez sur Afficher les données pour voir les colonnes qui ont été créées et les lignes qui ont été insérées dans la table.Right-click the Student table and click View Data to see the columns that were created and the rows that were inserted into the table.

Table Student dans SSOX

Les fichiers de base de données .mdf et .ldf se trouvent dans le dossier C:\Users\<votre_nom_utilisateur>.The .mdf and .ldf database files are in the C:\Users\<yourusername> folder.

Étant donné que vous appelez EnsureCreated dans la méthode d’initialiseur qui s’exécute au démarrage de l’application, vous pouvez maintenant apporter une modification à la classe Student, supprimer la base de données ou réexécuter l’application, et la base de données serait automatiquement recréée conformément à votre modification.Because you're calling EnsureCreated in the initializer method that runs on app start, you could now make a change to the Student class, delete the database, run the application again, and the database would automatically be re-created to match your change. Par exemple, si vous ajoutez une propriété EmailAddress à la classe Student, vous voyez une nouvelle colonne EmailAddress dans la table recréée.For example, if you add an EmailAddress property to the Student class, you'll see a new EmailAddress column in the re-created table.

ConventionsConventions

La quantité de code que vous deviez écrire pour qu’Entity Framework puisse créer une base de données complète pour vous est minimale en raison de l’utilisation de conventions ou d’hypothèses effectuées par Entity Framework.The amount of code you had to write in order for the Entity Framework to be able to create a complete database for you is minimal because of the use of conventions, or assumptions that the Entity Framework makes.

  • Les noms des propriétés DbSet sont utilisés comme noms de tables.The names of DbSet properties are used as table names. Pour les entités non référencées par une propriété DbSet, les noms des classes d’entités sont utilisés comme noms de tables.For entities not referenced by a DbSet property, entity class names are used as table names.

  • Les noms des propriétés d’entités sont utilisés comme noms de colonnes.Entity property names are used for column names.

  • Les propriétés d’entité nommées ID ou classnameID sont reconnues comme propriétés de clé primaire.Entity properties that are named ID or classnameID are recognized as primary key properties.

  • Une propriété est interprétée comme propriété de clé étrangère si elle se nomme*<nom de la propriété de navigation><nom de la propriété de clé primaire>* (par exemple StudentID pour la propriété de navigation Student, puisque la clé primaire de l’entité Student est ID).A property is interpreted as a foreign key property if it's named <navigation property name><primary key property name> (for example, StudentID for the Student navigation property since the Student entity's primary key is ID). Les propriétés de clé étrangère peuvent également être nommées simplement <nom de la propriété de clé primaire> (par exemple, EnrollmentID, puisque la clé primaire de l’entité Enrollment est EnrollmentID).Foreign key properties can also be named simply <primary key property name> (for example, EnrollmentID since the Enrollment entity's primary key is EnrollmentID).

Le comportement conventionnel peut être remplacé.Conventional behavior can be overridden. Par exemple, vous pouvez spécifier explicitement les noms de tables, comme vous l’avez vu précédemment dans ce didacticiel.For example, you can explicitly specify table names, as you saw earlier in this tutorial. De plus, vous pouvez définir des noms de colonne et définir une propriété quelconque en tant que clé primaire ou clé étrangère, comme vous le verrez dans un didacticiel ultérieur dans cette série.And you can set column names and set any property as primary key or foreign key, as you'll see in a later tutorial in this series.

Code asynchroneAsynchronous code

La programmation asynchrone est le mode par défaut pour ASP.NET Core et EF Core.Asynchronous programming is the default mode for ASP.NET Core and EF Core.

Un serveur web a un nombre limité de threads disponibles et, dans les situations de forte charge, tous les threads disponibles peuvent être utilisés.A web server has a limited number of threads available, and in high load situations all of the available threads might be in use. Quand cela se produit, le serveur ne peut pas traiter de nouvelle requête tant que les threads ne sont pas libérés.When that happens, the server can't process new requests until the threads are freed up. Avec le code synchrone, plusieurs threads peuvent être bloqués alors qu’ils n’effectuent en fait aucun travail, car ils attendent que des E/S se terminent.With synchronous code, many threads may be tied up while they aren't actually doing any work because they're waiting for I/O to complete. Avec le code asynchrone, quand un processus attend que des E/S se terminent, son thread est libéré afin d’être utilisé par le serveur pour traiter d’autres demandes.With asynchronous code, when a process is waiting for I/O to complete, its thread is freed up for the server to use for processing other requests. Le code asynchrone permet ainsi d’utiliser plus efficacement les ressources serveur, et le serveur peut gérer plus de trafic sans retard.As a result, asynchronous code enables server resources to be used more efficiently, and the server is enabled to handle more traffic without delays.

Le code asynchrone introduit néanmoins une petite surcharge au moment de l’exécution, mais dans les situations de faible trafic, la baisse de performances est négligeable, alors qu’en cas de trafic élevé, l’amélioration potentielle des performances est importante.Asynchronous code does introduce a small amount of overhead at run time, but for low traffic situations the performance hit is negligible, while for high traffic situations, the potential performance improvement is substantial.

Dans le code suivant, le mot clé async, la valeur renvoyée Task<T>, le mot clé await et la méthode ToListAsync provoquent l’exécution asynchrone du code.In the following code, the async keyword, Task<T> return value, await keyword, and ToListAsync method make the code execute asynchronously.

public async Task<IActionResult> Index()
{
    return View(await _context.Students.ToListAsync());
}
  • Le mot clé async indique au compilateur de générer des rappels pour les parties du corps de la méthode et pour créer automatiquement l’objet Task<IActionResult> qui est renvoyé.The async keyword tells the compiler to generate callbacks for parts of the method body and to automatically create the Task<IActionResult> object that's returned.

  • Le type de retour Task<IActionResult> représente le travail en cours avec un résultat de type IActionResult.The return type Task<IActionResult> represents ongoing work with a result of type IActionResult.

  • Le mot clé await indique au compilateur de fractionner la méthode en deux parties.The await keyword causes the compiler to split the method into two parts. La première partie se termine par l’opération qui est démarrée de façon asynchrone.The first part ends with the operation that's started asynchronously. La seconde partie est placée dans une méthode de rappel qui est appelée quand l’opération se termine.The second part is put into a callback method that's called when the operation completes.

  • ToListAsync est la version asynchrone de la méthode d’extension ToList.ToListAsync is the asynchronous version of the ToList extension method.

Voici quelques éléments à connaître lorsque vous écrivez un code asynchrone qui utilise Entity Framework :Some things to be aware of when you are writing asynchronous code that uses the Entity Framework:

  • Seules les instructions qui provoquent l’envoi de requêtes ou de commandes vers la base de données sont exécutées de façon asynchrone.Only statements that cause queries or commands to be sent to the database are executed asynchronously. Cela inclut, par exemple, ToListAsync, SingleOrDefaultAsync et SaveChangesAsync,That includes, for example, ToListAsync, SingleOrDefaultAsync, and SaveChangesAsync. mais pas les instructions qui ne font, par exemple, que changer IQueryable, telles que var students = context.Students.Where(s => s.LastName == "Davolio").It doesn't include, for example, statements that just change an IQueryable, such as var students = context.Students.Where(s => s.LastName == "Davolio").

  • Un contexte EF n’est pas thread-safe : n’essayez pas d’effectuer plusieurs opérations en parallèle.An EF context isn't thread safe: don't try to do multiple operations in parallel. Lorsque vous appelez une méthode EF asynchrone quelconque, utilisez toujours le mot clé await.When you call any async EF method, always use the await keyword.

  • Si vous souhaitez tirer profit des meilleures performances du code asynchrone, assurez-vous que tous les packages de bibliothèque que vous utilisez (par exemple pour changer de page) utilisent également du code asynchrone s’ils appellent des méthodes Entity Framework qui provoquent l’envoi des requêtes à la base de données.If you want to take advantage of the performance benefits of async code, make sure that any library packages that you're using (such as for paging), also use async if they call any Entity Framework methods that cause queries to be sent to the database.

Pour plus d’informations sur la programmation asynchrone dans .NET, consultez Vue d’ensemble du code asynchrone.For more information about asynchronous programming in .NET, see Async Overview.

Obtenir le codeGet the code

Télécharger ou afficher l’application complète.Download or view the completed application.

Étapes suivantesNext steps

Dans ce didacticiel, vous avez effectué les actions suivantes :In this tutorial, you:

  • Application web ASP.NET Core MVC crééeCreated ASP.NET Core MVC web app
  • Configurer le style du siteSet up the site style
  • Packages NuGet EF Core découvertsLearned about EF Core NuGet packages
  • Modèle de données crééCreated the data model
  • Contexte de base de données crééCreated the database context
  • SchoolContext inscritRegistered the SchoolContext
  • Base de données initialisée avec des données de testInitialized DB with test data
  • Un contrôleur et des vues créésCreated controller and views
  • Base de données affichéeViewed the database

Dans le prochain didacticiel, vous apprendrez à effectuer des opérations CRUD de base (créer, lire, mettre à jour, supprimer).In the following tutorial, you'll learn how to perform basic CRUD (create, read, update, delete) operations.

Passez au tutoriel suivant pour découvrir comment effectuer des opérations CRUD de base (créer, lire, mettre à jour, supprimer).Advance to the next tutorial to learn how to perform basic CRUD (create, read, update, delete) operations.