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

Note

Ce didacticiel utilise EF Core 2.0.1 (version publiée avec ASP.NET Core et le Kit SDK .NET Core 2.0.3).This tutorial uses EF Core 2.0.1 (released alongside ASP.NET Core and .NET Core SDK 2.0.3). EF Core 2.0.0 ne dispose pas de certains correctifs de bogues essentiels pour une bonne expérience UWP.EF Core 2.0.0 lacks some crucial bug fixes required for a good UWP experience.

Dans cette procédure pas à pas, vous allez générer une plateforme Windows universelle (UWP) qui exécute l’accès aux données de base d’une base de données SQLite locale à l’aide d’Entity Framework.In this walkthrough, you will build a Universal Windows Platform (UWP) application that performs basic data access against a local SQLite database using Entity Framework.

Important

Évitez les types anonymes dans les requêtes LINQ sur UWP.Consider avoiding anonymous types in LINQ queries on UWP. Pour déployer une application UWP dans le magasin d’applications, votre application doit être générée avec .NET Native.Deploying a UWP application to the app store requires your application to be compiled with .NET Native. Les requêtes avec des types anonymes ont des performances inférieures sur .NET Native.Queries with anonymous types have worse performance on .NET Native.

Conseil

Vous pouvez afficher cet exemple sur GitHub.You can view this article's sample on GitHub.

Conditions préalablesPrerequisites

Les éléments suivants sont nécessaires pour effectuer cette procédure pas à pas :The following items are required to complete this walkthrough:

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

Avertissement

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 pouvoir 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

  • Ouvrir Visual StudioOpen Visual Studio

  • Fichier > Nouveau > Projet...File > New > Project...

  • Dans le menu de gauche, sélectionnez Modèles > Visual C#.From the left menu select Templates > Visual C#

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

  • Nommez le projet et cliquez sur OK.Give the project a name and click OK

Installer Entity FrameworkInstall Entity Framework

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. Cette procédure pas à pas utilise SQLite.This walkthrough 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 packageTools > NuGet Package Manager > Package Manager Console

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

Un peu plus loin dans cette procédure pas à pas, nous utiliserons également des outils Entity Framework pour gérer la base de données.Later in this walkthrough we will also be using some Entity Framework Tools to maintain the database. Nous installerons donc également le package d’outils.So we will install the tools package as well.

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

  • Modifiez le fichier .csproj et remplacez <TargetFramework>netstandard2.0</TargetFramework> par <TargetFrameworks>netcoreapp2.0;netstandard2.0</TargetFrameworks>.Edit the .csproj file and replace <TargetFramework>netstandard2.0</TargetFramework> with <TargetFrameworks>netcoreapp2.0;netstandard2.0</TargetFrameworks>

Créer un modèleCreate your model

Définissons à présent le contexte et les classes d’entité qui composeront le modèle.Now it's time to define a context and entity classes that make up your model.

  • Projet > Ajouter une classe...Project > Add Class...

  • Entrez le nom Model.cs et cliquez sur OK.Enter Model.cs as the name and click OK

  • Remplacez le contenu du fichier par le code suivant.Replace the contents of the file with the following code

using Microsoft.EntityFrameworkCore;
using System.Collections.Generic;

namespace EFGetStarted.UWP
{
    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

  • Ouvrir Visual StudioOpen Visual Studio

  • Fichier > Nouveau > Projet...File > New > Project...

  • Dans le menu de gauche, sélectionnez Modèles > Visual C# > Windows universel.From the left menu select Templates > 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 et cliquez sur OK.Give the project a name and click OK

  • Définissez la cible et les versions minimales 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 base de donnéesCreate your database

Une fois que vous avez un modèle, vous pouvez utiliser des migrations pour créer une base de données.Now that you have a model, you can use migrations to create a database for you.

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

  • Sélectionnez le projet de modèle en tant que projet par défaut et définissez-le comme projet de démarrage.Select the model project as the Default project and set it as the startup project

  • Exécutez Add-Migration MyFirstMigration pour générer automatiquement un modèle de migration pour créer l’ensemble initial de tables de votre modèle.Run Add-Migration MyFirstMigration to scaffold a migration to create the initial set of tables for your model.

Étant donné que nous voulons créer la base de données sur l’appareil sur lequel est exécutée l’application, nous allons ajouter du code pour appliquer à la base de données locale toutes les migrations en attente au démarrage de l’application.Since we want the database to be created on the device that the app runs on, we will add some code to apply any pending migrations to the local database on application startup. Au cours de la première exécution de l’application, ce code se chargera de créer la base de données locale pour nous.The first time that the app runs, this will take care of creating the local database for us.

  • Cliquez avec le bouton de droite sur App.xaml dans l’Explorateur de solutions, puis sélectionnez Afficher le code.Right-click on App.xaml in Solution Explorer and select View Code

  • Ajoutez la ligne using mise en surbrillance au début du fichier.Add the highlighted using to the start of the file

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

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 EFGetStarted.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)
        {
#if DEBUG
            if (System.Diagnostics.Debugger.IsAttached)
            {
                this.DebugSettings.EnableFrameRateCounter = true;
            }
#endif
            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 apportez des modifications ultérieures au modèle, vous pouvez utiliser la commande Add-Migration pour générer automatiquement un nouveau modèle de migration pour appliquer les modifications correspondantes à la base de données.If you make future changes to your model, you can 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 your model

Vous pouvez à présent utiliser le modèle pour accéder aux données.You can now use your 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="EFGetStarted.UWP.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:EFGetStarted.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>

Nous allons maintenant ajouter du code pour connecter l’interface utilisateur à la base de données.Now we'll add code to wire up the UI with the database

  • Cliquez avec le bouton de droite sur MainPage.xaml dans l’Explorateur de solutions, puis sélectionnez Afficher le code.Right-click MainPage.xaml in Solution Explorer and select View Code

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

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 http://go.microsoft.com/fwlink/?LinkId=402352&clcid=0x409

namespace EFGetStarted.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.

  • Déboguer > Exécuter sans débogageDebug > Start Without Debugging

  • L’application est générée et lancée.The application will build and launch

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

image

image

Étapes suivantesNext steps

Conseil

La performance SaveChanges() peut être améliorée en implémentant INotifyPropertyChanged, INotifyPropertyChanging et INotifyCollectionChanged dans vos types d’entité et en utilisant ChangeTrackingStrategy.ChangingAndChangedNotifications.SaveChanges() performance can be improved by implementing INotifyPropertyChanged, INotifyPropertyChanging, INotifyCollectionChanged in your entity types and using ChangeTrackingStrategy.ChangingAndChangedNotifications.

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

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