Wprowadzenie do podstawowych EF na platformę uniwersalną systemu Windows (UWP) z nową bazę danychGetting Started with EF Core on Universal Windows Platform (UWP) with a New Database

Uwaga

W tym samouczku używana Core EF 2.0.1 (wydane z platformy ASP.NET Core i .NET Core SDK 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 brakuje niektórych ważnych poprawki wymagane do dobrej obsługi platformy uniwersalnej systemu Windows.EF Core 2.0.0 lacks some crucial bug fixes required for a good UWP experience.

W tym przewodniku będzie tworzenia aplikacji systemu Windows platformy Uniwersalnej, która wykonuje dostęp do podstawowych danych lokalnej bazy danych SQLite używający narzędzia 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.

Ważne

Należy rozważyć unikanie typy anonimowe w zapytaniach LINQ na platformy uniwersalnej systemu Windows.Consider avoiding anonymous types in LINQ queries on UWP. Wdrażanie aplikacji do sklepu z aplikacjami platformy uniwersalnej systemu Windows wymaga aplikacji do skompilowania z platformą .NET Native.Deploying a UWP application to the app store requires your application to be compiled with .NET Native. Zapytania z typy anonimowe ma pogorszenie wydajności na platformie .NET Native.Queries with anonymous types have worse performance on .NET Native.

Porada

Można wyświetlić w tym artykule próbki w witrynie GitHub.You can view this article's sample on GitHub.

Wstępnie wymagane składnikiPrerequisites

Poniższe elementy są wymagane w tym przewodniku:The following items are required to complete this walkthrough:

Utwórz nowy projekt modeluCreate a new model project

Ostrzeżenie

Ze względu na ograniczenia w narzędziach .NET Core sposób interakcji z projektów uniwersalnych systemu Windows, które modelu musi być umieszczona w projekcie aplikacje platformy UWP, aby można było uruchamiać polecenia migracji w konsoli Menedżera pakietówDue 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

  • Otwórz program Visual StudioOpen Visual Studio

  • Plik > Nowy > Projekt...File > New > Project...

  • Z menu po lewej stronie wybierz Szablony > Visual C#From the left menu select Templates > Visual C#

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

  • Nadaj nazwę projektu, a następnie kliknij przycisk OKGive the project a name and click OK

Instalowanie programu Entity FrameworkInstall Entity Framework

Aby użyć EF podstawowe, należy zainstalować pakiet dla powszechne bazy danych, który ma być docelowa.To use EF Core, install the package for the database provider(s) you want to target. W tym przewodniku zastosowano SQLite.This walkthrough uses SQLite. Lista dostępnych dostawców dostawcy bazy danych.For a list of available providers see Database Providers.

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

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

W dalszej części tego przewodnika również użyjemy narzędzi Framework niektóre jednostki do obsługi bazy danych.Later in this walkthrough we will also be using some Entity Framework Tools to maintain the database. Dlatego zostanie zainstalowany pakiet narzędzi również.So we will install the tools package as well.

  • UruchomInstall-Package Microsoft.EntityFrameworkCore.ToolsRun Install-Package Microsoft.EntityFrameworkCore.Tools

  • Przeprowadź edycję pliku .csproj i Zastąp <TargetFramework>netstandard2.0</TargetFramework> z<TargetFrameworks>netcoreapp2.0;netstandard2.0</TargetFrameworks>Edit the .csproj file and replace <TargetFramework>netstandard2.0</TargetFramework> with <TargetFrameworks>netcoreapp2.0;netstandard2.0</TargetFrameworks>

Tworzenie modeluCreate your model

Teraz nadszedł czas do definiowania klas kontekstu i jednostek, wchodzące w skład modelu.Now it's time to define a context and entity classes that make up your model.

  • Projekt > Dodaj klasę...Project > Add Class...

  • Wprowadź Model.cs jako nazwy i kliknij przycisk OKEnter Model.cs as the name and click OK

  • Zastąp zawartość pliku następującym kodemReplace 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; }
    }
}

Utwórz nowy projekt platformy uniwersalnej systemu WindowsCreate a new UWP project

  • Otwórz program Visual StudioOpen Visual Studio

  • Plik > Nowy > Projekt...File > New > Project...

  • Z menu po lewej stronie wybierz Szablony > Visual C# > uniwersalnych systemu WindowsFrom the left menu select Templates > Visual C# > Windows Universal

  • Wybierz pusta aplikacja (uniwersalna systemu Windows) szablonu projektuSelect the Blank App (Universal Windows) project template

  • Nadaj nazwę projektu, a następnie kliknij przycisk OKGive the project a name and click OK

  • Ustaw docelowy i co najmniej wersji do co najmniejWindows 10 Fall Creators Update (10.0; build 16299.0)Set the target and minimum versions to at least Windows 10 Fall Creators Update (10.0; build 16299.0)

Tworzenie bazy danychCreate your database

Teraz, gdy masz modelu można użyć migracji tworzenia bazy danych dla Ciebie.Now that you have a model, you can use migrations to create a database for you.

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

  • Wybierz projekt z modelem jako domyślny projekt i ustaw go jako projekt startowySelect the model project as the Default project and set it as the startup project

  • Uruchom Add-Migration MyFirstMigration Aby utworzyć szkielet migracji do utworzenia wstępnego zestawu tabel dla modelu.Run Add-Migration MyFirstMigration to scaffold a migration to create the initial set of tables for your model.

Ponieważ chcemy bazy danych ma zostać utworzony na urządzeniu, która aplikacja jest uruchamiana na dodamy kodu, zastosuj wszelkie oczekujące migracje do lokalnej bazy danych podczas uruchamiania aplikacji.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. Aplikacja jest uruchamiana, po raz pierwszy to zajmie się tworzenie firmie Microsoft w lokalnej bazie danych.The first time that the app runs, this will take care of creating the local database for us.

  • Kliknij prawym przyciskiem myszy App.xaml w Eksploratora rozwiązań i wybierz widoku koduRight-click on App.xaml in Solution Explorer and select View Code

  • Dodaj wyróżnione using na początku plikuAdd the highlighted using to the start of the file

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

Porada

Jeśli wprowadzisz zmiany w przyszłości do modelu, możesz użyć Add-Migration polecenie, aby utworzyć szkielet nowe migracji, aby zastosować odpowiednie zmiany w bazie danych.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. Wszelkie 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 EF __EFMigrationsHistory tabeli w bazie danych, aby śledzić migracji, które zostały już zastosowane do bazy danych.EF uses a __EFMigrationsHistory table in the database to keep track of which migrations have already been applied to the database.

Użyj modeluUse your model

Można teraz używać modelu do uzyskania dostępu do danych.You can now use your model to perform data access.

  • Otwórz MainPage.xamlOpen MainPage.xaml

  • Dodawanie obsługi obciążenia strony i interfejsu użytkownika zawartości wskazanych poniżejAdd 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>

Teraz dodamy kod, aby okablować interfejsu użytkownika z bazy danychNow we'll add code to wire up the UI with the database

  • Kliknij prawym przyciskiem myszy MainPage.xaml w Eksploratora rozwiązań i wybierz widoku koduRight-click MainPage.xaml in Solution Explorer and select View Code

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

Można teraz uruchomić aplikację, aby zobaczyć ją w akcji.You can now run the application to see it in action.

  • Debuguj > Uruchom bez debugowaniaDebug > Start Without Debugging

  • Aplikacja tworzenie i uruchamianieThe application will build and launch

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

obraz

obraz

Następne krokiNext steps

Porada

SaveChanges()można poprawić wydajność dzięki implementacji INotifyPropertyChanged , INotifyPropertyChanging , INotifyCollectionChanged w Twojej typów jednostek i przy użyciu ChangeTrackingStrategy.ChangingAndChangedNotifications.SaveChanges() performance can be improved by implementing INotifyPropertyChanged, INotifyPropertyChanging, INotifyCollectionChanged in your entity types and using ChangeTrackingStrategy.ChangingAndChangedNotifications.

Tada!Tada! Masz teraz prostej aplikacji platformy uniwersalnej systemu Windows z programu Entity Framework.You now have a simple UWP app running Entity Framework.

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