Introducción a EF Core en Plataforma universal de Windows (UWP) con una base de datos nuevaGetting Started with EF Core on Universal Windows Platform (UWP) with a New Database

En este tutorial, compilará una aplicación de Plataforma universal de Windows (UWP) que accede a datos básicos en una base de datos SQLite local mediante 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.

Vea un ejemplo de este artículo en GitHub.View this article's sample on GitHub.

Requisitos previosPrerequisites

Importante

En este tutorial se usan comandos de migraciones de Entity Framework Core para crear y actualizar el esquema de la base de datos.This tutorial uses Entity Framework Core migrations commands to create and update the schema of the database. Estos comandos no funcionan directamente con proyectos de UWP.These commands don't work directly with UWP projects. Por este motivo, el modelo de datos de la aplicación se coloca en un proyecto de biblioteca compartida y se usa una aplicación de consola .NET Core independiente para ejecutar los comandos.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.

Crear un proyecto de biblioteca que contenga el modelo de datosCreate a library project to hold the data model

  • Apertura de Visual StudioOpen Visual Studio

  • Archivo > Nuevo > ProyectoFile > New > Project

  • En el menú de la izquierda, seleccione Instalado > Visual C# > .NET Standard.From the left menu select Installed > Visual C# > .NET Standard.

  • Seleccione la plantilla Biblioteca de clases (.NET Standard).Select the Class Library (.NET Standard) template.

  • Asigne el nombre Blogging.Model al proyecto.Name the project Blogging.Model.

  • Asigne el nombre Blogging a la solución.Name the solution Blogging.

  • Haga clic en Aceptar.Click OK.

Instalar el runtime de Entity Framework Core en el proyecto de modelo de datosInstall Entity Framework Core runtime in the data model project

Para usar EF Core, instale el paquete correspondiente a los proveedores de bases de datos a los que desea dirigirse.To use EF Core, install the package for the database provider(s) you want to target. En este tutorial se usa SQLite.This tutorial uses SQLite. Para una lista de los proveedores disponibles, consulte Proveedores de bases de datos.For a list of available providers see Database Providers.

  • Herramientas –> Administrador de paquetes NuGet –> Consola del Administrador de paquetes.Tools > NuGet Package Manager > Package Manager Console.

  • Asegúrese de que el proyecto de biblioteca Blogging.Model esté seleccionado como Proyecto predeterminado en la consola del administrador de paquetes.Make sure that the library project Blogging.Model is selected as the Default Project in the Package Manager Console.

  • Ejecute Install-Package Microsoft.EntityFrameworkCore.Sqlite.Run Install-Package Microsoft.EntityFrameworkCore.Sqlite

Crear el modelo de datosCreate the data model

Ahora hay que definir el elemento DbContext y las clases de entidad que conforman el modelo.Now it's time to define the DbContext and entity classes that make up the model.

  • Elimine Class1.cs.Delete Class1.cs.

  • Cree Model.cs con el código siguiente: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; }
        }
    }
    

Crear un nuevo proyecto de consola para ejecutar comandos de migracionesCreate a new console project to run migrations commands

  • En el Explorador de soluciones, haga clic con el botón derecho en la solución y elija Agregar > Nuevo proyecto.In Solution Explorer, right-click the solution, and then choose Add > New Project.

  • En el menú de la izquierda, seleccione Instalado > Visual C# > .NET Core.From the left menu select Installed > Visual C# > .NET Core.

  • Seleccione la plantilla del proyecto Aplicación de consola (.NET Core).Select the Console App (.NET Core) project template.

  • Asigne el nombre Blogging.Migrations.Startup al proyecto y haga clic en Aceptar.Name the project Blogging.Migrations.Startup, and click OK.

  • Agregue una referencia al proyecto Blogging.Model al proyecto Blogging.Migrations.Startup.Add a project reference from the Blogging.Migrations.Startup project to the Blogging.Model project.

Instalar las herramientas de Entity Framework Core en el proyecto de inicio de migracionesInstall Entity Framework Core tools in the migrations startup project

Para habilitar los comandos de migraciones de EF Core en la consola del administrador de paquetes, instale el paquete de herramientas de EF Core en la aplicación de consola.To enable the EF Core migration commands in the Package Manager Console, install the EF Core tools package in the console application.

  • Herramientas > Administrador de paquetes NuGet > Consola del Administrador de paquetesTools > NuGet Package Manager > Package Manager Console

  • Ejecute Install-Package Microsoft.EntityFrameworkCore.Tools -ProjectName Blogging.Migrations.Startup.Run Install-Package Microsoft.EntityFrameworkCore.Tools -ProjectName Blogging.Migrations.Startup

Creación de la migración inicialCreate the initial migration

Cree la migración inicial al especificar la aplicación de consola como proyecto de inicio.Create the initial migration, specifying the console application as the startup project.

  • Ejecute Add-Migration InitialCreate -StartupProject Blogging.Migrations.Startup.Run Add-Migration InitialCreate -StartupProject Blogging.Migrations.Startup

Este comando aplica scaffolding a una migración que crea el conjunto inicial de tablas de base de datos para el modelo de datos.This command scaffolds a migration that creates the initial set of database tables for your data model.

Crear el proyecto de UWPCreate the UWP project

  • En el Explorador de soluciones, haga clic con el botón derecho en la solución y elija Agregar > Nuevo proyecto.In Solution Explorer, right-click the solution, and then choose Add > New Project.

  • En el menú izquierdo, seleccione Instalado > Visual C# > Universal de Windows.From the left menu select Installed > Visual C# > Windows Universal.

  • Seleccione la plantilla de proyecto Aplicación en blanco (Universal de Windows).Select the Blank App (Universal Windows) project template.

  • Asigne el nombre Blogging.UWP al proyecto y haga clic en Aceptar.Name the project Blogging.UWP, and click OK

Importante

Establezca la versión de destino y la versión mínima al menos en Windows 10 Fall Creators Update (10.0; compilación 16299.0).Set the target and minimum versions to at least Windows 10 Fall Creators Update (10.0; build 16299.0). Las versiones anteriores de Windows 10 no admiten .NET Standard 2.0, que Entity Framework Core necesita.Previous versions of Windows 10 do not support .NET Standard 2.0, which is required by Entity Framework Core.

Agregar código para crear la base de datos al inicio de la aplicaciónAdd code to create the database on application startup

Puesto que quiere crear la base de datos en el dispositivo donde se ejecuta la aplicación, debe agregar código para aplicar cualquier migración pendiente a la base de datos local en el inicio de la aplicación.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. La primera vez que se ejecute la aplicación, esta se encargará de crear la base de datos local.The first time that the app runs, this will take care of creating the local database.

  • Agregue una referencia del proyecto Blogging.UWP al proyecto Blogging.Model.Add a project reference from the Blogging.UWP project to the Blogging.Model project.

  • Abra App.xaml.cs.Open App.xaml.cs.

  • Agregue el código resaltado para aplicar cualquier migración pendiente.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();
            }
        }
    }
    

Sugerencia

Si modifica el modelo, use el comando Add-Migration para aplicar el scaffolding a una migración nueva con el fin de aplicar los cambios correspondientes a la base de datos.If you change your model, use the Add-Migration command to scaffold a new migration to apply the corresponding changes to the database. Toda migración pendiente se aplicará a la base de datos local de cada dispositivo cuando se inicie la aplicación.Any pending migrations will be applied to the local database on each device when the application starts.

EF Core usa una tabla __EFMigrationsHistory en la base de datos para realizar un seguimiento de cuáles son las migraciones que ya se aplicaron a la base de datos.EF Core uses a __EFMigrationsHistory table in the database to keep track of which migrations have already been applied to the database.

Usar el modelo de datosUse the data model

Ahora puede usar EF Core para realizar el acceso a los datos.You can now use EF Core to perform data access.

  • Abra MainPage.xaml.Open MainPage.xaml.

  • Agregue el controlador de carga de página y el contenido de UI que aparece resaltado a continuaciónAdd 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>

Ahora, agregue código para conectar la interfaz de usuario con la base de datos.Now add code to wire up the UI with the database

  • Abra MainPage.xaml.cs.Open MainPage.xaml.cs.

  • Agregue el código resaltado de la lista siguiente: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();
            }
        }
    }
}

Ahora puede ejecutar la aplicación para verla en acción.You can now run the application to see it in action.

  • En el Explorador de soluciones, haga clic con el botón derecho en el proyecto Blogging.UWP y seleccione Implementar.In Solution Explorer, right-click the Blogging.UWP project and then select Deploy.

  • Establezca Blogging.UWP como el proyecto de inicio.Set Blogging.UWP as the startup project.

  • Depurar > Iniciar sin depuraciónDebug > Start Without Debugging

    La aplicación se compilará y ejecutará.The app builds and runs.

  • Escriba una dirección URL y haga clic en el botón AgregarEnter a URL and click the Add button

    imagen

    imagen

    ¡Y listo!Tada! Ahora tiene una aplicación de UWP sencilla que ejecuta Entity Framework Core.You now have a simple UWP app running Entity Framework Core.

Pasos siguientesNext steps

Para obtener información sobre la compatibilidad y el rendimiento que debe conocer al usar EF Core con UWP, vea Implementaciones de .NET compatibles con EF Core.For compatibility and performance information that you should know when using EF Core with UWP, see .NET implementations supported by EF Core.

Consulte otros artículos de esta documentación para obtener más información sobre las características de Entity Framework Core.Check out other articles in this documentation to learn more about Entity Framework Core features.