Bien démarrer avec EF Core sur la plateforme Windows universelle (UWP) avec une nouvelle base de donnéesGetting Started with EF Core on Universal Windows Platform (UWP) with a New Database

Dans ce tutoriel, vous allez générer une application UWP (Universal Windows Platform) qui effectue un accès aux données élémentaire sur une base de données SQLite locale à l’aide d’Entity Framework Core.In this tutorial, you build a Universal Windows Platform (UWP) application that performs basic data access against a local SQLite database using Entity Framework Core.

Affichez l’exemple proposé dans cet article sur GitHub.View this article's sample on GitHub.

PrérequisPrerequisites

Important

Ce tutoriel utilise des commandes de migration Entity Framework Core pour créer et mettre à jour le schéma de la base de données.This tutorial uses Entity Framework Core migrations commands to create and update the schema of the database. Ces commandes ne fonctionnent pas directement avec les projets UWP.These commands don't work directly with UWP projects. Pour cette raison, le modèle de données de l’application est placé dans un projet de bibliothèque partagé, et une application console .NET Core distincte est utilisée pour exécuter les commandes.For this reason, the application's data model is placed in a shared library project, and a separate .NET Core console application is used to run the commands.

Créer un projet de bibliothèque pour stocker le modèle de donnéesCreate a library project to hold the data model

  • Ouvrir Visual StudioOpen Visual Studio

  • Fichier > Nouveau > ProjetFile > New > Project

  • Dans le menu de gauche, sélectionnez Installé > Visual C# > .NET Standard.From the left menu select Installed > Visual C# > .NET Standard.

  • Sélectionnez le modèle Bibliothèque de classes (.NET Standard).Select the Class Library (.NET Standard) template.

  • Nommez le projet Blogging.Model.Name the project Blogging.Model.

  • Nommez la solution Blogging.Name the solution Blogging.

  • Cliquez sur OK.Click OK.

Installer le runtime Entity Framework Core dans le projet de modèle de donnéesInstall Entity Framework Core runtime in the data model project

Pour utiliser EF Core, installez le package pour le ou les fournisseurs de bases de données à cibler.To use EF Core, install the package for the database provider(s) you want to target. Ce tutoriel utilise SQLite.This tutorial uses SQLite. Pour obtenir la liste des fournisseurs disponibles, consultez Fournisseurs de bases de données.For a list of available providers see Database Providers.

  • Outils > Gestionnaire de package NuGet > Console du Gestionnaire de package.Tools > NuGet Package Manager > Package Manager Console.

  • Vérifiez que le projet de bibliothèque Blogging.Model est sélectionné comme Projet par défaut dans la Console du Gestionnaire de package.Make sure that the library project Blogging.Model is selected as the Default Project in the Package Manager Console.

  • Exécutez Install-Package Microsoft.EntityFrameworkCore.Sqlite.Run Install-Package Microsoft.EntityFrameworkCore.Sqlite

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

Définissons à présent le DbContext et les classes d’entité qui composent le modèle.Now it's time to define the DbContext and entity classes that make up the model.

  • Supprimez Class1.cs.Delete Class1.cs.

  • Créez Model.cs avec le code suivant :Create Model.cs with the following code:

    using Microsoft.EntityFrameworkCore;
    using System.Collections.Generic;
    
    namespace Blogging.Model
    {
        public class BloggingContext : DbContext
        {
            public DbSet<Blog> Blogs { get; set; }
            public DbSet<Post> Posts { get; set; }
    
            protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
            {
                optionsBuilder.UseSqlite("Data Source=blogging.db");
            }
        }
    
        public class Blog
        {
            public int BlogId { get; set; }
            public string Url { get; set; }
    
            public List<Post> Posts { get; set; }
        }
    
        public class Post
        {
            public int PostId { get; set; }
            public string Title { get; set; }
            public string Content { get; set; }
    
            public int BlogId { get; set; }
            public Blog Blog { get; set; }
        }
    }
    

Créer un projet de console pour exécuter des commandes de migrationCreate a new console project to run migrations commands

  • Dans l’Explorateur de solutions, cliquez avec le bouton droit sur la solution, puis choisissez Ajouter > Nouveau projet.In Solution Explorer, right-click the solution, and then choose Add > New Project.

  • Dans le menu de gauche, sélectionnez Installé > Visual C# > .NET Core.From the left menu select Installed > Visual C# > .NET Core.

  • Sélectionnez le modèle de projet Application console (.NET Core).Select the Console App (.NET Core) project template.

  • Nommez le projet Blogging.Migrations.Startup, puis cliquez sur OK.Name the project Blogging.Migrations.Startup, and click OK.

  • Ajoutez une référence de projet du projet Blogging.Migrations.Startup au projet Blogging.Model.Add a project reference from the Blogging.Migrations.Startup project to the Blogging.Model project.

Installer les outils Entity Framework Core dans le projet de démarrage de migrationsInstall Entity Framework Core tools in the migrations startup project

Pour activer les commandes de migration EF Core dans la Console du Gestionnaire de package, installez le package d’outils EF Core dans l’application console.To enable the EF Core migration commands in the Package Manager Console, install the EF Core tools package in the console application.

  • Outils > Gestionnaire de package NuGet > Console du Gestionnaire de packageTools > NuGet Package Manager > Package Manager Console

  • Exécutez Install-Package Microsoft.EntityFrameworkCore.Tools -ProjectName Blogging.Migrations.Startup.Run Install-Package Microsoft.EntityFrameworkCore.Tools -ProjectName Blogging.Migrations.Startup

Créer la migration initialeCreate the initial migration

Créez la migration initiale, en spécifiant l’application console comme projet de démarrage.Create the initial migration, specifying the console application as the startup project.

  • Exécutez Add-Migration InitialCreate -StartupProject Blogging.Migrations.Startup.Run Add-Migration InitialCreate -StartupProject Blogging.Migrations.Startup

Cette commande génère automatiquement un modèle de migration qui crée l’ensemble initial de tables de bases de données pour votre modèle de données.This command scaffolds a migration that creates the initial set of database tables for your data model.

Créer le projet UWPCreate the UWP project

  • Dans l’Explorateur de solutions, cliquez avec le bouton droit sur la solution, puis choisissez Ajouter > Nouveau projet.In Solution Explorer, right-click the solution, and then choose Add > New Project.

  • Dans le menu de gauche, sélectionnez Installé > Visual C# > Windows universel.From the left menu select Installed > Visual C# > Windows Universal.

  • Sélectionnez le modèle de projet Application vide (Windows universel).Select the Blank App (Universal Windows) project template.

  • Nommez le projet Blogging.UWP, puis cliquez sur OK.Name the project Blogging.UWP, and click OK

Important

Définissez les versions minimale et cible sur Windows 10 Fall Creators Update (10.0 ; build 16299.0) au minimum.Set the target and minimum versions to at least Windows 10 Fall Creators Update (10.0; build 16299.0). Les versions précédentes de Windows 10 ne prennent pas en charge .NET Standard 2.0, qui est exigé par Entity Framework Core.Previous versions of Windows 10 do not support .NET Standard 2.0, which is required by Entity Framework Core.

Ajouter du code pour créer la base de données au démarrage de l’applicationAdd code to create the database on application startup

Étant donné que vous souhaitez créer la base de données sur l’appareil sur lequel l’application s’exécute, vous allez ajouter du code pour appliquer à la base de données locale toutes les migrations en attente au démarrage de l’application.Since you want the database to be created on the device that the app runs on, add code to apply any pending migrations to the local database on application startup. Lors de la première exécution de l’application, ce code se chargera de créer la base de données locale.The first time that the app runs, this will take care of creating the local database.

  • Ajoutez une référence de projet du projet Blogging.UWP au projet Blogging.Model.Add a project reference from the Blogging.UWP project to the Blogging.Model project.

  • Ouvrez App.xaml.cs.Open App.xaml.cs.

  • Ajoutez le code mis en surbrillance pour appliquer toutes les migrations en attente.Add the highlighted code to apply any pending migrations.

    using Blogging.Model;
    using Microsoft.EntityFrameworkCore;
    using System;
    using Windows.ApplicationModel;
    using Windows.ApplicationModel.Activation;
    using Windows.UI.Xaml;
    using Windows.UI.Xaml.Controls;
    using Windows.UI.Xaml.Navigation;
    
    namespace Blogging.UWP
    {
        /// <summary>
        /// Provides application-specific behavior to supplement the default Application class.
        /// </summary>
        sealed partial class App : Application
        {
            /// <summary>
            /// Initializes the singleton application object.  This is the first line of authored code
            /// executed, and as such is the logical equivalent of main() or WinMain().
            /// </summary>
            public App()
            {
                this.InitializeComponent();
                this.Suspending += OnSuspending;
    
                using (var db = new BloggingContext())
                {
                    db.Database.Migrate();
                }
            }
    
            /// <summary>
            /// Invoked when the application is launched normally by the end user.  Other entry points
            /// will be used such as when the application is launched to open a specific file.
            /// </summary>
            /// <param name="e">Details about the launch request and process.</param>
            protected override void OnLaunched(LaunchActivatedEventArgs e)
            {
                Frame rootFrame = Window.Current.Content as Frame;
    
                // Do not repeat app initialization when the Window already has content,
                // just ensure that the window is active
                if (rootFrame == null)
                {
                    // Create a Frame to act as the navigation context and navigate to the first page
                    rootFrame = new Frame();
    
                    rootFrame.NavigationFailed += OnNavigationFailed;
    
                    if (e.PreviousExecutionState == ApplicationExecutionState.Terminated)
                    {
                        //TODO: Load state from previously suspended application
                    }
    
                    // Place the frame in the current Window
                    Window.Current.Content = rootFrame;
                }
    
                if (e.PrelaunchActivated == false)
                {
                    if (rootFrame.Content == null)
                    {
                        // When the navigation stack isn't restored navigate to the first page,
                        // configuring the new page by passing required information as a navigation
                        // parameter
                        rootFrame.Navigate(typeof(MainPage), e.Arguments);
                    }
                    // Ensure the current window is active
                    Window.Current.Activate();
                }
            }
    
            /// <summary>
            /// Invoked when Navigation to a certain page fails
            /// </summary>
            /// <param name="sender">The Frame which failed navigation</param>
            /// <param name="e">Details about the navigation failure</param>
            void OnNavigationFailed(object sender, NavigationFailedEventArgs e)
            {
                throw new Exception("Failed to load Page " + e.SourcePageType.FullName);
            }
    
            /// <summary>
            /// Invoked when application execution is being suspended.  Application state is saved
            /// without knowing whether the application will be terminated or resumed with the contents
            /// of memory still intact.
            /// </summary>
            /// <param name="sender">The source of the suspend request.</param>
            /// <param name="e">Details about the suspend request.</param>
            private void OnSuspending(object sender, SuspendingEventArgs e)
            {
                var deferral = e.SuspendingOperation.GetDeferral();
                //TODO: Save application state and stop any background activity
                deferral.Complete();
            }
        }
    }
    

Conseil

Si vous modifiez votre modèle, utilisez la commande Add-Migration pour générer automatiquement un nouveau modèle de migration afin d’appliquer les modifications correspondantes à la base de données.If you change your model, use the Add-Migration command to scaffold a new migration to apply the corresponding changes to the database. Les migrations en attente seront appliquées à la base de données locale sur chaque appareil au démarrage de l’application.Any pending migrations will be applied to the local database on each device when the application starts.

EF Core utilise une table __EFMigrationsHistory dans la base de données pour effectuer le suivi des migrations qui ont déjà été appliquées à la base de données.EF Core uses a __EFMigrationsHistory table in the database to keep track of which migrations have already been applied to the database.

Utiliser le modèle de donnéesUse the data model

Vous pouvez à présent utiliser EF Core pour accéder aux données.You can now use EF Core to perform data access.

  • Ouvrez MainPage.xaml.Open MainPage.xaml.

  • Ajoutez le gestionnaire de chargement de page et le contenu de l’interface utilisateur mis en surbrillance ci-dessous.Add the page load handler and UI content highlighted below

<Page
    x:Class="Blogging.UWP.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:Blogging.UWP"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    Loaded="Page_Loaded">

    <Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
        <StackPanel>
            <TextBox Name="NewBlogUrl"></TextBox>
            <Button Click="Add_Click">Add</Button>
            <ListView Name="Blogs">
                <ListView.ItemTemplate>
                    <DataTemplate>
                        <TextBlock Text="{Binding Url}" />
                    </DataTemplate>
                </ListView.ItemTemplate>
            </ListView>
        </StackPanel>
    </Grid>
</Page>

Maintenant, ajoutez du code pour connecter l’interface utilisateur à la base de données.Now add code to wire up the UI with the database

  • Ouvrez MainPage.xaml.cs.Open MainPage.xaml.cs.

  • Ajoutez le code mis en surbrillance de la liste suivante :Add the highlighted code from the following listing:

using Blogging.Model;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using Windows.Foundation;
using Windows.Foundation.Collections;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;
using Windows.UI.Xaml.Data;
using Windows.UI.Xaml.Input;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Navigation;

// The Blank Page item template is documented at https://go.microsoft.com/fwlink/?LinkId=402352&clcid=0x409

namespace Blogging.UWP
{
    /// <summary>
    /// An empty page that can be used on its own or navigated to within a Frame.
    /// </summary>
    public sealed partial class MainPage : Page
    {
        public MainPage()
        {
            this.InitializeComponent();
        }

        private void Page_Loaded(object sender, RoutedEventArgs e)
        {
            using (var db = new BloggingContext())
            {
                Blogs.ItemsSource = db.Blogs.ToList();
            }
        }

        private void Add_Click(object sender, RoutedEventArgs e)
        {
            using (var db = new BloggingContext())
            {
                var blog = new Blog { Url = NewBlogUrl.Text };
                db.Blogs.Add(blog);
                db.SaveChanges();

                Blogs.ItemsSource = db.Blogs.ToList();
            }
        }
    }
}

Vous pouvez à présent exécuter l’application pour la voir en action.You can now run the application to see it in action.

  • Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le projet Blogging.UWP, puis sélectionnez Déployer.In Solution Explorer, right-click the Blogging.UWP project and then select Deploy.

  • Définissez Blogging.UWP comme projet de démarrage.Set Blogging.UWP as the startup project.

  • Déboguer > Démarrer sans débogageDebug > Start Without Debugging

    L’application est générée et s’exécute.The app builds and runs.

  • Entrez une URL et cliquez sur le bouton Ajouter.Enter a URL and click the Add button

    image

    image

    Et le tour est joué !Tada! Vous avez désormais une application UWP simple exécutant Entity Framework Core.You now have a simple UWP app running Entity Framework Core.

Étapes suivantesNext steps

Pour accéder à des informations sur la compatibilité et les performances que vous devez connaître quand vous utilisez EF Core avec UWP, consultez Implémentations de .NET prises en charge par EF Core.For compatibility and performance information that you should know when using EF Core with UWP, see .NET implementations supported by EF Core.

Consultez les autres articles de cette documentation pour en savoir plus sur les fonctionnalités d’Entity Framework Core.Check out other articles in this documentation to learn more about Entity Framework Core features.