Compartir a través de

Code First para una Base de Datos Nueva

Este vídeo y el tutorial paso a paso proporcionan una introducción al desarrollo de Code First destinado a una nueva base de datos. Este escenario incluye apuntar a una base de datos que no existe, que Code First creará, o a una base de datos vacía en la que Code First añadirá nuevas tablas. Code First permite definir el modelo mediante C# o VB.Net clases. Opcionalmente, se puede realizar una configuración adicional mediante atributos en las clases y propiedades o mediante una API fluida.

Vea el vídeo

En este vídeo se proporciona una introducción al desarrollo de Code First destinado a una nueva base de datos. Este escenario incluye la orientación a una base de datos que no existe y que Code First creará, o a una base de datos vacía a la que Code First agregará nuevas tablas. Code First permite definir el modelo mediante C# o VB.Net clases. Opcionalmente, se puede realizar una configuración adicional mediante atributos en las clases y propiedades o mediante una API fluida.

Presentado por: Rowan Miller

Vídeo: WMV | MP4 | WMV (ZIP)

Requisitos previos

Tendrá que tener instalado al menos Visual Studio 2010 o Visual Studio 2012 para completar este tutorial.

Si usa Visual Studio 2010, también deberá tener NuGet instalado.

1. Creación de la aplicación

Para simplificar las cosas, vamos a crear una aplicación de consola básica que use Code First para realizar el acceso a datos.

  • Apertura de Visual Studio
  • Archivo -> Nuevo -> Proyecto...
  • Seleccione Windows en el menú de la izquierda y aplicación de consola.
  • Escriba CodeFirstNewDatabaseSample como nombre.
  • Seleccione Aceptar.

2. Crear el modelo

Vamos a definir un modelo muy sencillo mediante clases. Solo los definimos en el archivo Program.cs, pero en una aplicación real dividiría las clases en archivos independientes y potencialmente un proyecto independiente.

Debajo de la definición de clase Program en Program.cs agregue las dos clases siguientes.

public class Blog
{
    public int BlogId { get; set; }
    public string Name { get; set; }

    public virtual 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 virtual Blog Blog { get; set; }
}

Observará que estamos convirtiendo en virtuales las dos propiedades de navegación (Blog.Posts y Post.Blog). Esto habilita la característica Carga diferida de Entity Framework. La carga diferida significa que el contenido de estas propiedades se cargará automáticamente desde la base de datos al intentar acceder a ellas.

3. Crear un contexto

Ahora es el momento de definir un contexto derivado, que representa una sesión con la base de datos, lo que nos permite consultar y guardar datos. Definimos un contexto que deriva de System.Data.Entity.DbContext y expone un DbSet< de TEntity> con tipo para cada clase del modelo.

Ahora estamos empezando a usar tipos de Entity Framework, por lo que es necesario agregar el paquete NuGet EntityFramework.

  • Proyecto:> administrar paquetes NuGet... Nota: Si no tiene la opción Administrar paquetes NuGet... debe instalar la versión más reciente de NuGet.
  • Seleccione la pestaña En línea .
  • Seleccione el paquete EntityFramework .
  • Haz clic en Instalar

Agregue una instrucción using para System.Data.Entity en la parte superior de Program.cs.

using System.Data.Entity;

Debajo de la clase Post en Program.cs agregue el siguiente contexto derivado.

public class BloggingContext : DbContext
{
    public DbSet<Blog> Blogs { get; set; }
    public DbSet<Post> Posts { get; set; }
}

Esta es una lista completa de lo que Program.cs debe contener ahora.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Data.Entity;

namespace CodeFirstNewDatabaseSample
{
    class Program
    {
        static void Main(string[] args)
        {
        }
    }

    public class Blog
    {
        public int BlogId { get; set; }
        public string Name { get; set; }

        public virtual 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 virtual Blog Blog { get; set; }
    }

    public class BloggingContext : DbContext
    {
        public DbSet<Blog> Blogs { get; set; }
        public DbSet<Post> Posts { get; set; }
    }
}

Es todo el código que necesitamos para empezar a almacenar y recuperar datos. Obviamente hay bastante actividad detrás de las escenas y lo veremos en un momento, pero primero vamos a verlo en acción.

4. Lectura y escritura de datos

Implemente el método Main en Program.cs como se muestra a continuación. Este código crea una nueva instancia de nuestro contexto y, a continuación, la usa para insertar un nuevo blog. A continuación, usa una consulta LINQ para recuperar todos los blogs de la base de datos ordenadas alfabéticamente por Title.

class Program
{
    static void Main(string[] args)
    {
        using (var db = new BloggingContext())
        {
            // Create and save a new Blog
            Console.Write("Enter a name for a new Blog: ");
            var name = Console.ReadLine();

            var blog = new Blog { Name = name };
            db.Blogs.Add(blog);
            db.SaveChanges();

            // Display all Blogs from the database
            var query = from b in db.Blogs
                        orderby b.Name
                        select b;

            Console.WriteLine("All blogs in the database:");
            foreach (var item in query)
            {
                Console.WriteLine(item.Name);
            }

            Console.WriteLine("Press any key to exit...");
            Console.ReadKey();
        }
    }
}

Ahora puede ejecutar la aplicación y probarla.

Enter a name for a new Blog: ADO.NET Blog
All blogs in the database:
ADO.NET Blog
Press any key to exit...

¿Dónde están mis datos?

Por convención, DbContext ha creado una base de datos para usted.

  • Si hay disponible una instancia local de SQL Express (instalada de forma predeterminada con Visual Studio 2010), Code First ha creado la base de datos en esa instancia.
  • Si SQL Express no está disponible, Code First intentará usar LocalDB (instalado de forma predeterminada con Visual Studio 2012)
  • La base de datos se denomina después del nombre completo del contexto derivado, en nuestro caso es CodeFirstNewDatabaseSample.BloggingContext.

Estas son solo las convenciones predeterminadas y hay varias maneras de cambiar la base de datos que usa Code First, hay más información disponible en el tema How DbContext Discovers the Model and Database Connection (Cómo DbContext detecta el modelo y la conexión de base de datos ). Puede conectarse a esta base de datos mediante el Explorador de servidores en Visual Studio.

  • Vista:> Explorador de servidores

  • Haga clic con el botón derecho en Conexiones de datos y seleccione Agregar conexión...

  • Si nunca se ha conectado a una base de datos desde el Explorador de servidores, deberá seleccionar Microsoft SQL Server como origen de datos.

    Selección del origen de datos

  • Conéctese a LocalDB o SQL Express, dependiendo de cuál haya instalado.

Ahora podemos inspeccionar el esquema que creó Code First.

Esquema inicial

DbContext ha trabajado en qué clases se van a incluir en el modelo examinando las propiedades de DbSet que definimos. A continuación, usa el conjunto predeterminado de convenciones de Code First para determinar nombres de tabla y columna, determinar tipos de datos, buscar claves principales, etc. Más adelante en este tutorial veremos cómo puede invalidar estas convenciones.

5. Tratar con cambios de modelo

Ahora es el momento de realizar algunos cambios en nuestro modelo, cuando realizamos estos cambios, también es necesario actualizar el esquema de la base de datos. Para ello, vamos a utilizar una característica llamada Code First Migrations, o simplemente Migraciones para abreviar.

Las migraciones nos permiten tener un conjunto ordenado de pasos que describen cómo actualizar (y degradar) nuestro esquema de base de datos. Cada uno de estos pasos, conocido como migración, contiene código que describe los cambios que se van a aplicar. 

El primer paso es habilitar migraciones de Code First para BloggingContext.

  • Herramientas -> Administrador de paquetes de biblioteca -> Consola del Administrador de paquetes

  • Ejecute el comando Enable-Migrations en la consola del Administrador de paquetes.

  • Se ha agregado una nueva carpeta Migrations al proyecto que contiene dos elementos:

    • Configuration.cs : este archivo contiene la configuración que las migraciones usarán para migrar BloggingContext. No es necesario cambiar nada para este tutorial, pero aquí es donde puede especificar datos de inicialización, registrar proveedores para otras bases de datos, cambiar el espacio de nombres en el que se generan migraciones, etc.
    • <timestamp>_InitialCreate.cs : esta es la primera migración, representa los cambios que ya se han aplicado a la base de datos para tomarla de ser una base de datos vacía en una que incluya las tablas Blogs y Posts. Aunque dejamos que Code First cree automáticamente estas tablas para nosotros, ahora que hemos optado por Migraciones, han sido convertidas en una migración. Code First también ha registrado en nuestra base de datos local que esta migración ya se ha aplicado. La marca de tiempo del nombre de archivo se usa con fines de ordenación.

    Ahora vamos a realizar un cambio en nuestro modelo, agregue una propiedad Url a la clase Blog:

public class Blog
{
    public int BlogId { get; set; }
    public string Name { get; set; }
    public string Url { get; set; }

    public virtual List<Post> Posts { get; set; }
}
  • Ejecute el comando Add-Migration AddUrl en la consola del Administrador de paquetes. El comando Add-Migration comprueba los cambios desde tu última migración y genera una nueva migración con cualquier cambio encontrado. Podemos asignar un nombre a las migraciones; en este caso, llamamos a la migración "AddUrl". El código generado automáticamente dice que es necesario agregar una columna Url, que puede contener datos de tipo cadena, a la tabla dbo.Blogs. Si fuera necesario, podríamos editar el código esquematizado, pero no lo es en este caso.
namespace CodeFirstNewDatabaseSample.Migrations
{
    using System;
    using System.Data.Entity.Migrations;

    public partial class AddUrl : DbMigration
    {
        public override void Up()
        {
            AddColumn("dbo.Blogs", "Url", c => c.String());
        }

        public override void Down()
        {
            DropColumn("dbo.Blogs", "Url");
        }
    }
}
  • Ejecute el comando Update-Database en la consola del Administrador de paquetes. Este comando aplicará las migraciones pendientes a la base de datos. Nuestra migración InitialCreate ya se ha aplicado, por lo que las migraciones solo aplicarán la nueva migración de AddUrl. Sugerencia: Puede usar el conmutador –Verbose al llamar a Update-Database para ver el SQL que se ejecuta en la base de datos.

La nueva columna Url ahora se agrega a la tabla Blogs de la base de datos:

Esquema con dirección URL

6. Anotaciones de datos

Hasta ahora, hemos dejado que EF detecte el modelo con sus convenciones predeterminadas, pero habrá ocasiones en las que nuestras clases no siguen las convenciones y es necesario poder realizar más configuraciones. Hay dos opciones para esto; Veremos anotaciones de datos en esta sección y, a continuación, la API fluida en la sección siguiente.

  • Vamos a agregar una clase User a nuestro modelo
public class User
{
    public string Username { get; set; }
    public string DisplayName { get; set; }
}
  • También es necesario agregar un conjunto al contexto derivado.
public class BloggingContext : DbContext
{
    public DbSet<Blog> Blogs { get; set; }
    public DbSet<Post> Posts { get; set; }
    public DbSet<User> Users { get; set; }
}
  • Si intentamos agregar una migración, obtendríamos un error que indica que "EntityType 'User' no tiene ninguna clave definida. Defina la clave para este EntityType". porque EF no tiene forma de saber que El nombre de usuario debe ser la clave principal para el usuario.
  • Ahora vamos a usar anotaciones de datos, por lo que es necesario agregar una instrucción using en la parte superior de Program.cs
using System.ComponentModel.DataAnnotations;
  • Ahora anota la propiedad Username para identificar que es la clave principal
public class User
{
    [Key]
    public string Username { get; set; }
    public string DisplayName { get; set; }
}
  • Utilice el comando Add-Migration AddUser para generar una migración que aplique estos cambios a la base de datos.
  • Ejecute el comando Update-Database para aplicar la nueva migración a la base de datos.

La nueva tabla ahora se agrega a la base de datos:

Esquema con usuarios

La lista completa de anotaciones admitidas por EF es:

7. Fluent API

En la sección anterior analizamos el uso de anotaciones de datos para complementar o invalidar lo que se detectó por convención. La otra manera de configurar el modelo es a través de code First fluent API.

La mayoría de la configuración del modelo se puede realizar mediante anotaciones de datos simples. La API fluida es una manera más avanzada de especificar la configuración del modelo que cubre todo lo que las anotaciones de datos pueden hacer, además de alguna configuración más avanzada que no es posible con anotaciones de datos. Las anotaciones de datos y la API fluida se pueden usar juntas.

Para acceder a la API fluida, invalide el método OnModelCreating en DbContext. Supongamos que queríamos cambiar el nombre de la columna en la que se almacena User.DisplayName en a display_name.

  • Invalide el método OnModelCreating en BloggingContext con el código siguiente
public class BloggingContext : DbContext
{
    public DbSet<Blog> Blogs { get; set; }
    public DbSet<Post> Posts { get; set; }
    public DbSet<User> Users { get; set; }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        modelBuilder.Entity<User>()
            .Property(u => u.DisplayName)
            .HasColumnName("display_name");
    }
}
  • Utiliza el comando Add-Migration ChangeDisplayName para generar una migración que aplique estos cambios a la base de datos.
  • Ejecute el comando Update-Database para aplicar la nueva migración a la base de datos.

Ahora se cambia el nombre de la columna DisplayName a display_name:

Esquema con nombre para mostrar cambiado

Resumen

En este tutorial hemos visto el desarrollo de Code First mediante una nueva base de datos. Definimos un modelo mediante clases que, a continuación, usamos ese modelo para crear una base de datos y almacenar y recuperar datos. Una vez creada la base de datos, usamos Migraciones de Code First para cambiar el esquema a medida que evoluciona nuestro modelo. También hemos visto cómo configurar un modelo mediante anotaciones de datos y la API fluent.

  • Last updated on