Wprowadzenie do programu EF Core na platformie Universal Windows (UWP) przy użyciu nowej bazy danychGetting Started with EF Core on Universal Windows Platform (UWP) with a New Database

W tym samouczku utworzysz aplikację platformy uniwersalnej Windows (UWP), która wykonuje dostęp do podstawowych danych lokalnej bazy danych SQLite przy użyciu platformy 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.

Wyświetlanie przykładowych w tym artykule w witrynie GitHub.View this article's sample on GitHub.

Wymagania wstępnePrerequisites

Ważne

Ten samouczek używa platformy Entity Framework Core migracje poleceń do tworzenia i aktualizowania schematu bazy danych.This tutorial uses Entity Framework Core migrations commands to create and update the schema of the database. Te polecenia nie działają bezpośrednio z projektów platformy UWP.These commands don't work directly with UWP projects. Z tego powodu modelu danych aplikacji znajduje się w projekcie biblioteki udostępnionej, a oddzielną aplikację konsoli .NET Core jest używany do uruchamiania polecenia.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.

Utwórz projekt biblioteki do przechowywania modelu danychCreate a library project to hold the data model

  • Otwórz program Visual StudioOpen Visual Studio

  • Plik > Nowy > ProjektFile > New > Project

  • Z menu po lewej stronie wybierz zainstalowane > Visual C# > .NET Standard.From the left menu select Installed > Visual C# > .NET Standard.

  • Wybierz biblioteki klas (.NET Standard) szablonu.Select the Class Library (.NET Standard) template.

  • Nadaj projektowi nazwę Blogging.Model.Name the project Blogging.Model.

  • Nazwij rozwiązanie do obsługi blogów.Name the solution Blogging.

  • Kliknij przycisk OK.Click OK.

Zainstaluj środowisko uruchomieniowe programu Entity Framework Core w projekcie modelu danychInstall Entity Framework Core runtime in the data model project

Aby korzystać z programu EF Core, należy zainstalować pakiet dla dostawców bazy danych, który ma pod kątem.To use EF Core, install the package for the database provider(s) you want to target. Ten samouczek używa bazy danych SQLite.This tutorial uses SQLite. Aby uzyskać listę dostępnych dostawców zobacz dostawcy baz danych.For a list of available providers see Database Providers.

  • Narzędzia > Menedżer pakietów NuGet > Konsola Menedżera pakietów.Tools > NuGet Package Manager > Package Manager Console.

  • Upewnij się, że projekt biblioteki Blogging.Model jest wybrany jako domyślny projekt w konsoli Menedżera pakietów.Make sure that the library project Blogging.Model is selected as the Default Project in the Package Manager Console.

  • Uruchom Install-Package Microsoft.EntityFrameworkCore.SqliteRun Install-Package Microsoft.EntityFrameworkCore.Sqlite

Tworzenie modelu danychCreate the data model

Teraz nadszedł czas, aby zdefiniować DbContext i klas jednostek, które tworzą model.Now it's time to define the DbContext and entity classes that make up the model.

  • Usuń Class1.cs.Delete Class1.cs.

  • Tworzenie Model.cs następującym kodem: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; }
        }
    }
    

Utwórz nowy projekt konsoli, aby uruchamiać polecenia migracjiCreate a new console project to run migrations commands

  • W Eksploratora rozwiązań, kliknij prawym przyciskiem myszy rozwiązanie, a następnie wybierz Dodaj > Nowy projekt.In Solution Explorer, right-click the solution, and then choose Add > New Project.

  • Z menu po lewej stronie wybierz zainstalowane > Visual C# > .NET Core.From the left menu select Installed > Visual C# > .NET Core.

  • Wybierz Aplikacja konsoli (.NET Core) szablonu projektu.Select the Console App (.NET Core) project template.

  • Nadaj projektowi nazwę Blogging.Migrations.Startupi kliknij przycisk OK.Name the project Blogging.Migrations.Startup, and click OK.

  • Dodaj odwołanie do projektu z Blogging.Migrations.Startup projekt Blogging.Model projektu.Add a project reference from the Blogging.Migrations.Startup project to the Blogging.Model project.

Zainstaluj narzędzia Entity Framework Core w projekcie uruchamiania migracjiInstall Entity Framework Core tools in the migrations startup project

Aby włączyć polecenia migracji EF Core w konsoli Menedżera pakietów, należy zainstalować pakiet narzędzi programu EF Core w aplikacji konsoli.To enable the EF Core migration commands in the Package Manager Console, install the EF Core tools package in the console application.

  • Narzędzia > Menedżer pakietów NuGet > Konsola Menedżera pakietówTools > NuGet Package Manager > Package Manager Console

  • Uruchom Install-Package Microsoft.EntityFrameworkCore.Tools -ProjectName Blogging.Migrations.StartupRun Install-Package Microsoft.EntityFrameworkCore.Tools -ProjectName Blogging.Migrations.Startup

Tworzenie początkowej migracjiCreate the initial migration

Tworzenie początkowej migracji, określenie aplikacji konsoli jako projekt startowy.Create the initial migration, specifying the console application as the startup project.

  • Uruchom Add-Migration InitialCreate -StartupProject Blogging.Migrations.StartupRun Add-Migration InitialCreate -StartupProject Blogging.Migrations.Startup

To polecenie scaffolds migracji, który tworzy początkowy zestaw tabel bazy danych dla modelu danych.This command scaffolds a migration that creates the initial set of database tables for your data model.

Tworzenie projektu platformy uniwersalnej systemu WindowsCreate the UWP project

  • W Eksploratora rozwiązań, kliknij prawym przyciskiem myszy rozwiązanie, a następnie wybierz Dodaj > Nowy projekt.In Solution Explorer, right-click the solution, and then choose Add > New Project.

  • Z menu po lewej stronie wybierz zainstalowane > Visual C# > Windows Universal.From the left menu select Installed > Visual C# > Windows Universal.

  • Wybierz pusta aplikacja (Windows Universal) szablonu projektu.Select the Blank App (Universal Windows) project template.

  • Nadaj projektowi nazwę Blogging.UWPi kliknij przycisk OKName the project Blogging.UWP, and click OK

Ważne

Co najmniej równa wersje docelową i minimalną Windows 10 Fall Creators Update (10.0; kompilacja 16299.0).Set the target and minimum versions to at least Windows 10 Fall Creators Update (10.0; build 16299.0). Poprzednie wersje systemu Windows 10 nie obsługują .NET Standard 2.0, która jest wymagana przez Entity Framework Core.Previous versions of Windows 10 do not support .NET Standard 2.0, which is required by Entity Framework Core.

Dodaj kod, aby utworzyć bazę danych podczas uruchamiania aplikacjiAdd code to create the database on application startup

Ponieważ baza danych ma zostać utworzony na urządzeniu, która jest uruchamiana aplikacja, należy dodać kod Zastosuj wszelkie oczekujące migracji w lokalnej bazie danych podczas uruchamiania aplikacji.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. Przy pierwszym uruchomieniu aplikacji, to zajmie się tworzenie lokalnej bazy danych.The first time that the app runs, this will take care of creating the local database.

  • Dodaj odwołanie do projektu z Blogging.UWP projekt Blogging.Model projektu.Add a project reference from the Blogging.UWP project to the Blogging.Model project.

  • Otwórz App.xaml.cs.Open App.xaml.cs.

  • Dodaj wyróżniony kod, aby zastosować wszelkie oczekujące migracji.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();
            }
        }
    }
    

Porada

W przypadku zmiany modelu użycia Add-Migration polecenia do tworzenia szkieletu nową migrację do zastosowania odpowiednich zmian w bazie danych.If you change your model, use the Add-Migration command to scaffold a new migration to apply the corresponding changes to the database. Wszystkie oczekujące migracje zostaną zastosowane do lokalnej bazy danych na każdym urządzeniu, podczas uruchamiania aplikacji.Any pending migrations will be applied to the local database on each device when the application starts.

Używa programu EF Core __EFMigrationsHistory tabeli w bazie danych, aby śledzić migracje, które zostały już zastosowane do bazy danych.EF Core uses a __EFMigrationsHistory table in the database to keep track of which migrations have already been applied to the database.

Przy użyciu modelu danychUse the data model

Można teraz używać programu EF Core przeprowadzić dostępu do danych.You can now use EF Core to perform data access.

  • Otwórz MainPage.xaml.Open MainPage.xaml.

  • Dodawanie obsługi ładowania strony i UI zawartości, które przedstawiono poniżejAdd 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>

Teraz Dodaj kod, aby Podłączanie do interfejsu użytkownika z bazą danychNow add code to wire up the UI with the database

  • Otwórz MainPage.xaml.cs.Open MainPage.xaml.cs.

  • Dodaj wyróżniony kod z poniższej listy: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();
            }
        }
    }
}

Teraz można uruchomić aplikacji, aby zobaczyć go w działaniu.You can now run the application to see it in action.

  • W Eksploratora rozwiązań, kliknij prawym przyciskiem myszy Blogging.UWP projektu, a następnie wybierz pozycję Wdróż.In Solution Explorer, right-click the Blogging.UWP project and then select Deploy.

  • Ustaw Blogging.UWP jako projekt startowy.Set Blogging.UWP as the startup project.

  • Debuguj > Uruchom bez debugowaniaDebug > Start Without Debugging

    Aplikacja tworzy i uruchamia.The app builds and runs.

  • Wprowadź adres URL, a następnie kliknij przycisk Dodaj przyciskuEnter a URL and click the Add button

    obraz

    obraz

    Tada!Tada! Masz teraz platformy Entity Framework Core uruchomioną prostą aplikacją platformy uniwersalnej systemu Windows.You now have a simple UWP app running Entity Framework Core.

Następne krokiNext steps

Uzyskać zgodności i wydajności, którą należy wiedzieć podczas korzystania z programu EF Core przy użyciu platformy uniwersalnej systemu Windows, zobacz implementacji platformy .NET obsługiwanych przez platformę EF Core.For compatibility and performance information that you should know when using EF Core with UWP, see .NET implementations supported by EF Core.

Zapoznaj się z innymi artykułami w tej dokumentacji, aby dowiedzieć się więcej na temat funkcji platformy Entity Framework Core.Check out other articles in this documentation to learn more about Entity Framework Core features.