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

Créer un projet de modèleCreate a model project

Important

En raison des limitations au niveau de l’interaction des outils .NET Core avec les projets UWP, le modèle doit être placé dans un projet autre que UWP pour que vous puissiez exécuter des commandes de migration dans la Console du Gestionnaire de package.Due to limitations in the way .NET Core tools interact with UWP projects the model needs to be placed in a non-UWP project to be able to run migrations commands in the Package Manager Console (PMC)

  • 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 Entity Framework CoreInstall Entity Framework Core

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.

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

Un peu plus loin dans ce tutoriel, vous utiliserez certains outils Entity Framework Core pour tenir à jour la base de données.Later in this tutorial you will be using some Entity Framework Core tools to maintain the database. Installez donc le package d’outils.So install the tools package as well.

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

Créer le modèleCreate the model

Définissons à présent le contexte et les classes d’entité qui composent le modèle.Now it's time to define a context 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 UWPCreate a new 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

  • 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).

Créer la migration initialeCreate the initial migration

Maintenant que vous avez un modèle, configurez l’application pour créer une base de données lors de sa première exécution.Now that you have a model, set up the app to create a database the first time it runs. Dans cette section, vous allez créer la migration initiale.In this section, you create the initial migration. Dans la section suivante, vous ajouterez du code qui applique cette migration au démarrage de l’application.In the following section, you add code that applies this migration when the app starts.

Les outils de migration nécessitent un projet de démarrage autre que UWP. Vous allez donc le créer en premier lieu.Migrations tools require a non-UWP startup project, so create that first.

  • 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.

Vous pouvez maintenant créer votre migration initiale.Now you can create your initial migration.

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

  • Sélectionnez le projet Blogging.Model comme Projet par défaut.Select the Blogging.Model project as the Default project.

  • Dans l’Explorateur de solutions, définissez le projet Blogging.Migrations.Startup comme projet de démarrage.In Solution Explorer, set the Blogging.Migrations.Startup project as the startup project.

  • Exécutez Add-Migration InitialCreate.Run Add-Migration InitialCreate.

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

Créer la base de données au démarrage de l’applicationCreate the database on app 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 utilise une table __EFMigrationsHistory dans la base de données pour identifier les migrations qui ont déjà été appliquées à la base de données.EF uses a __EFMigrationsHistory table in the database to keep track of which migrations have already been applied to the database.

Utiliser le modèleUse the model

Vous pouvez à présent utiliser le modèle pour accéder aux données.You can now use the model 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.