Tutorial: Introducción a Entity Framework 6 Code First con MVC 5

  • Artículo
  • Tiempo de lectura: 22 minutos

Note

En el desarrollo nuevo, se recomienda ASP.NET Core Razor pages a través de los controladores y vistas de MVC de ASP.net. Para obtener una serie de tutoriales similar a esta con Razor Pages, consulte Tutorial: Introducción a la Razor pages en ASP.net Core. El nuevo tutorial:

  • Es más fácil de seguir.
  • Proporciona más procedimientos recomendados de EF Core.
  • Usa consultas más eficaces.
  • Es más actual en relación con la API más reciente.
  • Abarca más características.
  • Es el método preferido para el desarrollo de nuevas aplicaciones.

En esta serie de tutoriales, aprenderá a crear una aplicación ASP.NET MVC 5 que usa Entity Framework 6 para el acceso a datos. En este tutorial se usa el flujo de trabajo Code First. Para obtener información sobre cómo elegir entre Code First, Database First y Model First, vea crear un modelo.

En esta serie de tutoriales se explica cómo crear la aplicación de ejemplo contoso University. La aplicación de ejemplo es un sitio web sencillo de la Universidad. Con ella, puede ver y actualizar la información de estudiantes, cursos e instructores. A continuación se muestran dos de las pantallas que se crean:

Students_Index_page

Editar estudiante

En este tutorial va a:

  • Creación de una aplicación Web de MVC
  • Configurar el estilo del sitio
  • Instalación de Entity Framework 6
  • Crear el modelo de datos
  • Crear el contexto de base de datos
  • Inicializa la base de datos con datos de prueba
  • Configurar EF 6 para usar LocalDB
  • Crea un controlador y vistas
  • Consulta la base de datos

Requisitos previos

Creación de una aplicación Web de MVC

  1. Abra Visual Studio y cree un C# proyecto web con la plantilla aplicación Web de ASP.net (.NET Framework) . Asigne al proyecto el nombre ContosoUniversity y seleccione Aceptar.

    Cuadro de diálogo nuevo proyecto en Visual Studio

  2. En nueva aplicación Web de ASP.net-ContosoUniversity, seleccione MVC.

    Cuadro de diálogo Nueva aplicación web en Visual Studio

    Note

    De forma predeterminada, la opción de autenticación está establecida en sin autenticación. En este tutorial, la aplicación web no requiere que los usuarios inicien sesión. Además, no restringe el acceso en función de quién haya iniciado sesión.

  3. Seleccione Aceptar para crear el proyecto.

Configurar el estilo del sitio

Con algunos cambios sencillos se configura el menú del sitio, el diseño y la página principal.

  1. Abra Views\Shared\_Layout. cshtmly realice los cambios siguientes:

    • Cambie todas las apariciones de "My ASP.NET Application" y "Application name" por "Contoso University".
    • Agregue entradas de menú para estudiantes, cursos, instructores y departamentos, y elimine la entrada de contacto.

    Los cambios se resaltan en el siguiente fragmento de código:

    <!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>@ViewBag.Title - Contoso University</title>
    @Styles.Render("~/Content/css")
    @Scripts.Render("~/bundles/modernizr")
</head>
<body>
    <div class="navbar navbar-inverse navbar-fixed-top">
        <div class="navbar-inner">
            <div class="container">
                <button type="button" class="btn btn-navbar" data-toggle="collapse" data-target=".nav-collapse">
                    <span class="icon-bar"></span>
                    <span class="icon-bar"></span>
                    <span class="icon-bar"></span>
                </button>
                @Html.ActionLink("Contoso University", "Index", "Home", new { area = "" }, new { @class = "navbar-brand" })
                <div class="nav-collapse collapse">
                    <ul class="nav">
                        <li>@Html.ActionLink("Home", "Index", "Home")</li>
                        <li>@Html.ActionLink("About", "About", "Home")</li>
                        <li>@Html.ActionLink("Students", "Index", "Student")</li>
                        <li>@Html.ActionLink("Courses", "Index", "Course")</li>
                        <li>@Html.ActionLink("Instructors", "Index", "Instructor")</li>
                        <li>@Html.ActionLink("Departments", "Index", "Department")</li>
                    </ul>
                </div>
            </div>
        </div>
    </div>

    <div class="container">
        @RenderBody()
        <hr />
        <footer>
            <p>&copy; @DateTime.Now.Year - Contoso University</p>
        </footer>
    </div>

    @Scripts.Render("~/bundles/jquery")
    @Scripts.Render("~/bundles/bootstrap")
    @RenderSection("scripts", required: false)
</body>
</html>

  2. En Views\Home\Index.cshtml, reemplace el contenido del archivo por el código siguiente para reemplazar el texto sobre ASP.net y MVC por texto sobre esta aplicación:

    @{
    ViewBag.Title = "Home Page";
}

<div class="jumbotron">
    <h1>Contoso University</h1>
</div>
<div class="row">
    <div class="col-md-4">
        <h2>Welcome to Contoso University</h2>
        <p>Contoso University is a sample application that
        demonstrates how to use Entity Framework 6 in an 
        ASP.NET MVC 5 web application.</p>
    </div>
    <div class="col-md-4">
        <h2>Build it from scratch</h2>
        <p>You can build the application by following the steps in the tutorial series on the ASP.NET site.</p>
        <p><a class="btn btn-default" href="http://www.asp.net/mvc/tutorials/getting-started-with-ef-using-mvc/">See the tutorial &raquo;</a></p>
    </div>
    <div class="col-md-4">
        <h2>Download it</h2>
        <p>You can download the completed project.</p>
        <p><a class="btn btn-default" href="https://webpifeed.blob.core.windows.net/webpifeed/Partners/ASP.NET%20MVC%20Application%20Using%20Entity%20Framework%20Code%20First.zip">Download &raquo;</a></p>
    </div>
</div>

  3. Presione Ctrl + F5 para ejecutar el sitio Web. Verá la Página principal con el menú principal.

Instalación de Entity Framework 6

  1. En el menú herramientas , elija Administrador de paquetes NuGety, a continuación, seleccione consola del administrador de paquetes.

  2. En la ventana Consola del Administrador de paquetas , escriba el siguiente comando:

    Install-Package EntityFramework

Este paso es uno de los pasos que este tutorial tiene manualmente, pero esto podría haber sido realizado automáticamente por la característica de scaffolding de ASP.NET MVC. Los está haciendo manualmente para que pueda ver los pasos necesarios para usar Entity Framework (EF). Usará la técnica scaffolding más adelante para crear el controlador y las vistas de MVC. Una alternativa consiste en permitir que la técnica scaffolding instale automáticamente el paquete de NuGet de EF, cree la clase de contexto de base de datos y cree la cadena de conexión. Cuando esté listo para hacerlo, lo único que tiene que hacer es omitir esos pasos y aplicar la técnica scaffolding al controlador MVC después de crear las clases de entidad.

Crear el modelo de datos

A continuación podrá crear las clases de entidad para la aplicación Contoso University. Empezará con las tres entidades siguientes:

Curso <-> inscripción <-> estudiante

Entidades Relación
Curso para la inscripción Uno a varios
Estudiante para inscribirse Uno a varios

Hay una relación uno a varios entre las entidades Student y Enrollment, y también entre las entidades Course y Enrollment. En otras palabras, un estudiante se puede inscribir en cualquier número de cursos y un curso puede tener cualquier número de alumnos inscritos.

En las secciones siguientes, creará una clase para cada una de estas entidades.

Note

Si intenta compilar el proyecto antes de terminar de crear todas estas clases de entidad, obtendrá errores del compilador.

La entidad Student

  • En la carpeta Models , cree un archivo de clase denominado Student.CS ; para ello, haga clic con el botón derecho en la carpeta en Explorador de soluciones y elija Agregar > clase. Reemplace el código de plantilla por el código siguiente:

    using System;
using System.Collections.Generic;

namespace ContosoUniversity.Models
{
    public class Student
    {
        public int ID { get; set; }
        public string LastName { get; set; }
        public string FirstMidName { get; set; }
        public DateTime EnrollmentDate { get; set; }
        
        public virtual ICollection<Enrollment> Enrollments { get; set; }
    }
}

La propiedad ID se convertirá en la columna de clave principal de la tabla de base de datos que corresponde a esta clase. De forma predeterminada, Entity Framework interpreta una propiedad denominada ID o classname ID como clave principal.

La propiedad Enrollments es una propiedad de navegación. Las propiedades de navegación contienen otras entidades relacionadas con esta entidad. En este caso, la propiedad Enrollments de una entidad Student contendrá todas las entidades Enrollment que están relacionadas con esa entidad de Student. En otras palabras, si una fila de Student determinada de la base de datos tiene dos filas de Enrollment relacionadas (filas que contienen el valor de clave principal de ese estudiante en la columna de clave externa de StudentID), la propiedad de navegación Enrollments de la entidad Student contendrá las dos entidades de Enrollment.

Las propiedades de navegación se definen normalmente como virtual para que puedan beneficiarse de ciertas funcionalidades de Entity Framework, como la carga diferida. (La carga diferida se explicará más adelante, en el tutorial leer datos relacionados más adelante en esta serie).

Si una propiedad de navegación puede contener varias entidades (como en las relaciones de varios a varios o uno a varios), su tipo debe ser una lista a la que se puedan agregar las entradas, eliminarlas y actualizarlas, como ICollection.

La entidad Enrollment

  • En la carpeta Models, cree Enrollment.cs y reemplace el código existente con el código siguiente:

    namespace ContosoUniversity.Models
{
    public enum Grade
    {
        A, B, C, D, F
    }

    public class Enrollment
    {
        public int EnrollmentID { get; set; }
        public int CourseID { get; set; }
        public int StudentID { get; set; }
        public Grade? Grade { get; set; }
        
        public virtual Course Course { get; set; }
        public virtual Student Student { get; set; }
    }
}

La propiedad EnrollmentID será la clave principal; esta entidad usa el patrón classname ID en lugar de ID por sí solo como se vio en la entidad Student. Normalmente debería elegir un patrón y usarlo en todo el modelo de datos. En este caso, la variación muestra que se puede usar cualquiera de los patrones. En un tutorial posterior, verá cómo usar ID sin classname facilita la implementación de la herencia en el modelo de datos.

La propiedad Grade es una enumeración. El signo de interrogación después de la declaración de tipo Grade indica que la propiedad Gradeacepta valores NULL. Una calificación que es NULL es diferente de un grado cero: null significa que no se conoce una calificación o que todavía no se ha asignado.

La propiedad StudentID es una clave externa y la propiedad de navegación correspondiente es Student. Una entidad Enrollment está asociada con una entidad Student, por lo que la propiedad solo puede contener un única entidad Student (a diferencia de la propiedad de navegación Student.Enrollments que se vio anteriormente, que puede contener varias entidades Enrollment).

La propiedad CourseID es una clave externa y la propiedad de navegación correspondiente es Course. Una entidad Enrollment está asociada con una entidad Course.

Entity Framework interpreta una propiedad como una propiedad de clave externa si se denomina <nombre de propiedad de navegación><nombre de propiedad de clave principal> (por ejemplo, StudentID para la propiedad de navegación Student porque la clave principal de la entidad Student es ID). Las propiedades de clave externa también se pueden denominar simplemente <nombre de propiedad de clave principal> (por ejemplo, CourseID porque la clave principal de la entidad de Course es CourseID).

La entidad Course

  • En la carpeta Models , cree Course.CSy reemplace el código de plantilla por el código siguiente:

    using System.Collections.Generic;
using System.ComponentModel.DataAnnotations.Schema;

namespace ContosoUniversity.Models
{
    public class Course
    {
        [DatabaseGenerated(DatabaseGeneratedOption.None)]
        public int CourseID { get; set; }
        public string Title { get; set; }
        public int Credits { get; set; }
        
        public virtual ICollection<Enrollment> Enrollments { get; set; }
    }
}

La propiedad Enrollments es una propiedad de navegación. Una entidad Course puede estar relacionada con cualquier número de entidades Enrollment.

En un tutorial posterior de esta serie, hablaremos sobre el atributo DatabaseGeneratedAttribute. Básicamente, este atributo permite escribir la clave principal para el curso en lugar de hacer que la base de datos lo genere.

Crear el contexto de base de datos

La clase principal que coordina Entity Framework funcionalidad para un modelo de datos determinado es la clase de contexto de base de datos. Cree esta clase derivando de la clase System. Data. Entity. DbContext . En el código, especifique qué entidades se incluyen en el modelo de datos. También se puede personalizar determinado comportamiento de Entity Framework. En este proyecto, la clase se denomina SchoolContext.

  • Para crear una carpeta en el proyecto ContosoUniversity, haga clic con el botón secundario en el proyecto en Explorador de soluciones , haga clic en Agregary, a continuación, haga clic en nueva carpeta. Asigne a la nueva carpeta el nombre Dal (para capa de acceso a datos). En esa carpeta, cree un nuevo archivo de clase denominado SchoolContext.CSy reemplace el código de plantilla por el código siguiente:

    using ContosoUniversity.Models;
using System.Data.Entity;
using System.Data.Entity.ModelConfiguration.Conventions;

namespace ContosoUniversity.DAL
{
    public class SchoolContext : DbContext
    {
    
        public SchoolContext() : base("SchoolContext")
        {
        }
        
        public DbSet<Student> Students { get; set; }
        public DbSet<Enrollment> Enrollments { get; set; }
        public DbSet<Course> Courses { get; set; }

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();
        }
    }
}

Especificar conjuntos de entidades

Este código crea una propiedad DbSet para cada conjunto de entidades. En Entity Framework terminología, un conjunto de entidades se corresponde normalmente con una tabla de base de datos y una entidad corresponde a una fila de la tabla.

Note

Puede omitir las instrucciones DbSet<Enrollment> y DbSet<Course> y funcionaría igual. Entity Framework incluiría implícitamente porque la entidad Student hace referencia a la entidad Enrollment y la entidad Enrollment hace referencia a la entidad Course.

Especificar la cadena de conexión

El nombre de la cadena de conexión (que agregará al archivo Web. config más adelante) se pasa al constructor.

public SchoolContext() : base("SchoolContext")
{
}

También puede pasar la cadena de conexión en lugar del nombre de una que esté almacenada en el archivo Web. config. Para obtener más información sobre las opciones para especificar la base de datos que se va a usar, consulte cadenas y modelos de conexión.

Si no especifica una cadena de conexión o el nombre de una explícitamente, Entity Framework supone que el nombre de la cadena de conexión es el mismo que el nombre de la clase. En este ejemplo, el nombre de la cadena de conexión predeterminada se SchoolContext, igual que el que se especifica explícitamente.

Especificar nombres de tabla en singular

La instrucción modelBuilder.Conventions.Remove en el método OnModelCreating impide que los nombres de tabla se confirmen. Si no lo hizo, las tablas generadas en la base de datos se denominarán Students, Coursesy Enrollments. En su lugar, los nombres de tabla se Student, Coursey Enrollment. Los desarrolladores están en desacuerdo sobre si los nombres de tabla deben ser plurales o no. En este tutorial se usa la forma singular, pero lo importante es que puede seleccionar cualquier forma que prefiera incluyendo u omitiendo esta línea de código.

Inicializa la base de datos con datos de prueba

Entity Framework puede crear (o quitar y volver a crear) automáticamente una base de datos cuando se ejecuta la aplicación. Puede especificar que esto se realice cada vez que se ejecute la aplicación o solo cuando el modelo no esté sincronizado con la base de datos existente. También puede escribir un método Seed que Entity Framework llama automáticamente después de crear la base de datos con el fin de rellenarla con datos de prueba.

El comportamiento predeterminado es crear una base de datos solo si no existe (y producir una excepción si el modelo ha cambiado y la base de datos ya existe). En esta sección, especificará que la base de datos debe quitarse y volver a crearse cada vez que cambie el modelo. Al quitar la base de datos, se pierden todos los datos. Por lo general, es correcto durante el desarrollo, porque el método de Seed se ejecutará cuando se vuelva a crear la base de datos y volverá a crear los datos de prueba. Pero en producción por lo general no desea perder todos los datos cada vez que necesite cambiar el esquema de la base de datos. Más adelante, verá cómo controlar los cambios del modelo mediante Migraciones de Code First para cambiar el esquema de la base de datos en lugar de quitar y volver a crear la base de datos.

  1. En la carpeta DAL, cree un nuevo archivo de clase denominado SchoolInitializer.CS y reemplace el código de plantilla por el código siguiente, que hace que se cree una base de datos cuando sea necesario y carga los datos de prueba en la nueva base de datos.

    using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Data.Entity;
using ContosoUniversity.Models;

namespace ContosoUniversity.DAL
{
    public class SchoolInitializer : System.Data.Entity. DropCreateDatabaseIfModelChanges<SchoolContext>
    {
        protected override void Seed(SchoolContext context)
        {
            var students = new List<Student>
            {
            new Student{FirstMidName="Carson",LastName="Alexander",EnrollmentDate=DateTime.Parse("2005-09-01")},
            new Student{FirstMidName="Meredith",LastName="Alonso",EnrollmentDate=DateTime.Parse("2002-09-01")},
            new Student{FirstMidName="Arturo",LastName="Anand",EnrollmentDate=DateTime.Parse("2003-09-01")},
            new Student{FirstMidName="Gytis",LastName="Barzdukas",EnrollmentDate=DateTime.Parse("2002-09-01")},
            new Student{FirstMidName="Yan",LastName="Li",EnrollmentDate=DateTime.Parse("2002-09-01")},
            new Student{FirstMidName="Peggy",LastName="Justice",EnrollmentDate=DateTime.Parse("2001-09-01")},
            new Student{FirstMidName="Laura",LastName="Norman",EnrollmentDate=DateTime.Parse("2003-09-01")},
            new Student{FirstMidName="Nino",LastName="Olivetto",EnrollmentDate=DateTime.Parse("2005-09-01")}
            };

            students.ForEach(s => context.Students.Add(s));
            context.SaveChanges();
            var courses = new List<Course>
            {
            new Course{CourseID=1050,Title="Chemistry",Credits=3,},
            new Course{CourseID=4022,Title="Microeconomics",Credits=3,},
            new Course{CourseID=4041,Title="Macroeconomics",Credits=3,},
            new Course{CourseID=1045,Title="Calculus",Credits=4,},
            new Course{CourseID=3141,Title="Trigonometry",Credits=4,},
            new Course{CourseID=2021,Title="Composition",Credits=3,},
            new Course{CourseID=2042,Title="Literature",Credits=4,}
            };
            courses.ForEach(s => context.Courses.Add(s));
            context.SaveChanges();
            var enrollments = new List<Enrollment>
            {
            new Enrollment{StudentID=1,CourseID=1050,Grade=Grade.A},
            new Enrollment{StudentID=1,CourseID=4022,Grade=Grade.C},
            new Enrollment{StudentID=1,CourseID=4041,Grade=Grade.B},
            new Enrollment{StudentID=2,CourseID=1045,Grade=Grade.B},
            new Enrollment{StudentID=2,CourseID=3141,Grade=Grade.F},
            new Enrollment{StudentID=2,CourseID=2021,Grade=Grade.F},
            new Enrollment{StudentID=3,CourseID=1050},
            new Enrollment{StudentID=4,CourseID=1050,},
            new Enrollment{StudentID=4,CourseID=4022,Grade=Grade.F},
            new Enrollment{StudentID=5,CourseID=4041,Grade=Grade.C},
            new Enrollment{StudentID=6,CourseID=1045},
            new Enrollment{StudentID=7,CourseID=3141,Grade=Grade.A},
            };
            enrollments.ForEach(s => context.Enrollments.Add(s));
            context.SaveChanges();
        }
    }
}

    El método Seed toma el objeto de contexto de base de datos como parámetro de entrada y el código del método usa ese objeto para agregar nuevas entidades a la base de datos. Para cada tipo de entidad, el código crea una colección de nuevas entidades, las agrega a la propiedad DbSet adecuada y, a continuación, guarda los cambios en la base de datos. No es necesario llamar al método SaveChanges después de cada grupo de entidades, como se hace aquí, pero hacerlo le ayuda a localizar el origen de un problema si se produce una excepción mientras el código está escribiendo en la base de datos.

  2. Para indicar a Entity Framework que use la clase de inicializador, agregue un elemento al elemento entityFramework en el archivo Web. config de la aplicación (el de la carpeta raíz del proyecto), tal como se muestra en el ejemplo siguiente:

    <entityFramework>
  <contexts>
    <context type="ContosoUniversity.DAL.SchoolContext, ContosoUniversity">
      <databaseInitializer type="ContosoUniversity.DAL.SchoolInitializer, ContosoUniversity" />
    </context>
  </contexts>
  <defaultConnectionFactory type="System.Data.Entity.Infrastructure.LocalDbConnectionFactory, EntityFramework">
    <parameters>
      <parameter value="v11.0" />
    </parameters>
  </defaultConnectionFactory>
  <providers>
    <provider invariantName="System.Data.SqlClient" type="System.Data.Entity.SqlServer.SqlProviderServices, EntityFramework.SqlServer" />
  </providers>
</entityFramework>

    El context type especifica el nombre completo de la clase de contexto y el ensamblado en el que se encuentra, y el databaseinitializer type especifica el nombre completo de la clase de inicializador y el ensamblado en el que se encuentra. (Si no desea que EF use el inicializador, puede establecer un atributo en el elemento context: disableDatabaseInitialization="true"). Para obtener más información, consulte Configuración del archivo de configuración.

    Una alternativa al establecimiento del inicializador en el archivo Web. config es hacerlo en el código agregando una instrucción Database.SetInitializer al método Application_Start en el archivo global.asax.CS . Para obtener más información, vea Descripción de los inicializadores de base de datos en Entity Framework Code First.

Ahora la aplicación está configurada de modo que, al tener acceso a la base de datos por primera vez en una ejecución determinada de la aplicación, Entity Framework Compare la base de datos con el modelo (las clases de entidad y SchoolContext). Si hay una diferencia, la aplicación quita y vuelve a crear la base de datos.

Note

Al implementar una aplicación en un servidor Web de producción, debe quitar o deshabilitar el código que quita y vuelve a crear la base de datos. Lo hará en un tutorial posterior de esta serie.

Configurar EF 6 para usar LocalDB

LocalDB es una versión ligera del motor de base de datos de SQL Server Express. Es fácil de instalar y configurar, inicia a petición y se ejecuta en modo de usuario. LocalDB se ejecuta en un modo de ejecución especial de SQL Server Express que le permite trabajar con bases de datos como archivos . MDF . Puede colocar los archivos de base de datos de LocalDB en la carpeta App_Data de un proyecto web si desea poder copiar la base de datos con el proyecto. La característica de instancia de usuario de SQL Server Express también le permite trabajar con archivos . MDF , pero la característica de instancia de usuario está en desuso. por lo tanto, se recomienda LocalDB para trabajar con archivos . MDF . LocalDB se instala de forma predeterminada con Visual Studio.

Normalmente, SQL Server Express no se utiliza para las aplicaciones Web de producción. En concreto, LocalDB no se recomienda para su uso en producción con una aplicación web porque no está diseñado para funcionar con IIS.

  • En este tutorial, trabajará con LocalDB. Abra el archivo Web. config de la aplicación y agregue un elemento connectionStrings que preceda al elemento appSettings, tal y como se muestra en el ejemplo siguiente. (Asegúrese de actualizar el archivo Web. config en la carpeta raíz del proyecto. También hay un archivo Web. config en la subcarpeta views que no necesita actualizar).

    <connectionStrings>
    <add name="SchoolContext" connectionString="Data Source=(LocalDb)\MSSQLLocalDB;Initial Catalog=ContosoUniversity1;Integrated Security=SSPI;" providerName="System.Data.SqlClient"/>
</connectionStrings>
<appSettings>
  <add key="webpages:Version" value="3.0.0.0" />
  <add key="webpages:Enabled" value="false" />
  <add key="ClientValidationEnabled" value="true" />
  <add key="UnobtrusiveJavaScriptEnabled" value="true" />
</appSettings>

La cadena de conexión que ha agregado especifica que Entity Framework usará una base de datos LocalDB denominada ContosoUniversity1. MDF. (La base de datos no existe todavía, pero EF la creará). Si desea crear la base de datos en la aplicación_ carpeta de datos, puede Agregar AttachDBFilename=|DataDirectory|\ContosoUniversity1.mdf a la cadena de conexión. Para obtener más información sobre las cadenas de conexión, vea SQL Server cadenas de conexión para las aplicaciones Web de ASP.net.

En realidad, no se necesita una cadena de conexión en el archivo Web. config . Si no proporciona una cadena de conexión, Entity Framework utiliza una cadena de conexión predeterminada basada en la clase de contexto. Para obtener más información, vea code First en una nueva base de datos.

Crea un controlador y vistas

Ahora creará una página web para mostrar los datos. El proceso de solicitar los datos desencadena automáticamente la creación de la base de datos. Comenzará creando un nuevo controlador. Pero antes de hacerlo, compile el proyecto para que el modelo y las clases de contexto estén disponibles para el scaffolding del controlador de MVC.

  1. Haga clic con el botón secundario en la carpeta Controllers en Explorador de soluciones, seleccione Agregary, a continuación, haga clic en nuevo elemento con scaffolding.

  2. En el cuadro de diálogo Agregar scaffold , seleccione controlador de MVC 5 con vistas, usando Entity Frameworky, a continuación, elija Agregar.

    Cuadro de diálogo Agregar scaffolding en Visual Studio

  3. En el cuadro de diálogo Agregar controlador , realice las siguientes selecciones y, a continuación, elija Agregar:

    • Clase de modelo: Student (ContosoUniversity. Models) . (Si no ve esta opción en la lista desplegable, compile el proyecto y vuelva a intentarlo).

    • Clase de contexto de datos: SchoolContext (ContosoUniversity. Dal) .

    • Nombre del controlador: StudentController (no StudentsController).

    • Deje los valores predeterminados para los demás campos.

      Al hacer clic en Agregar, el scaffolding crea un archivo StudentController.CS y un conjunto de vistas (archivos . cshtml ) que funcionan con el controlador. En el futuro, cuando cree proyectos que utilicen Entity Framework, también puede aprovechar algunas funciones adicionales del scaffolding: crear su primera clase de modelo, no crear una cadena de conexión y, a continuación, en el cuadro Agregar controlador especifique el nuevo contexto de datos seleccionando el botón + junto a clase de contexto de datos. El scaffolding creará la clase de DbContext y la cadena de conexión, así como el controlador y las vistas.

  4. Visual Studio abre el archivo Controllers\StudentController.CS . Verá que se ha creado una variable de clase que crea instancias de un objeto de contexto de base de datos:

    private SchoolContext db = new SchoolContext();

    El método de acción Index obtiene una lista de estudiantes del conjunto de entidades Students mediante la lectura de la propiedad Students de la instancia de contexto de base de datos:

    public ViewResult Index()
{
    return View(db.Students.ToList());
}

    La vista Student\Index.cshtml muestra esta lista en una tabla:

    <table>
    <tr>
        <th>
            @Html.DisplayNameFor(model => model.LastName)
        </th>
        <th>
            @Html.DisplayNameFor(model => model.FirstMidName)
        </th>
        <th>
            @Html.DisplayNameFor(model => model.EnrollmentDate)
        </th>
        <th></th>
    </tr>

@foreach (var item in Model) {
    <tr>
        <td>
            @Html.DisplayFor(modelItem => item.LastName)
        </td>
        <td>
            @Html.DisplayFor(modelItem => item.FirstMidName)
        </td>
        <td>
            @Html.DisplayFor(modelItem => item.EnrollmentDate)
        </td>
        <td>
            @Html.ActionLink("Edit", "Edit", new { id=item.ID }) |
            @Html.ActionLink("Details", "Details", new { id=item.ID }) |
            @Html.ActionLink("Delete", "Delete", new { id=item.ID })
        </td>
    </tr>
}

  5. Presione Ctrl+F5 para ejecutar el proyecto. (Si obtiene el error "no se puede crear la instantánea", cierre el explorador e inténtelo de nuevo).

    Haga clic en la pestaña Students para ver los datos de prueba que insertó el método Seed. En función de la restricción de la ventana del explorador, verá el vínculo de la pestaña Student en la barra de direcciones superior o tendrá que hacer clic en la esquina superior derecha para ver el vínculo.

    Botón de menú

Consulta la base de datos

Cuando ejecutó la página Students y la aplicación intentó tener acceso a la base de datos, EF detectó que no había ninguna base de datos y creó una. EF ejecutó el método de inicialización para rellenar la base de datos con datos.

Puede usar Explorador de servidores o Explorador de objetos de SQL Server (SSOX) para ver la base de datos en Visual Studio. En este tutorial, usará Explorador de servidores.

  1. Cierre el explorador.

  2. En Explorador de servidores, expanda conexiones de datos (es posible que deba seleccionar primero el botón actualizar), expanda contexto de escuela (ContosoUniversity) y, a continuación, expanda tablas para ver las tablas de la base de datos nueva.

  3. Haga clic con el botón secundario en la tabla Student y haga clic en Mostrar datos de tabla para ver las columnas que se crearon y las filas que se insertaron en la tabla.

  4. Cierre la conexión Explorador de servidores .

Los archivos de base de datos ContosoUniversity1. MDF y . ldf se encuentran en la carpeta % userprofile% .

Dado que está usando el inicializador de DropCreateDatabaseIfModelChanges, ahora puede realizar un cambio en la clase Student, ejecutar de nuevo la aplicación y la base de datos se volverá a crear automáticamente para que coincida con el cambio. Por ejemplo, si agrega una propiedad EmailAddress a la clase Student, vuelve a ejecutar la página Students y, a continuación, vuelve a examinar la tabla, verá una nueva columna EmailAddress.

Convenciones

La cantidad de código que tenía que escribir para que Entity Framework pueda crear una base de datos completa es mínima debido a las convencioneso suposiciones que realiza Entity Framework. Algunos de ellos ya se han anotado o se usaron sin ser consciente de ellos:

  • Las formas en plural de los nombres de clase de entidad se usan como nombres de tabla.
  • Los nombres de propiedad de entidad se usan para los nombres de columna.
  • Las propiedades de entidad que se denominan ID o classname ID se reconocen como propiedades de clave principal.
  • Una propiedad se interpreta como una propiedad de clave externa si se denomina <nombre de propiedad de navegación><nombre de la propiedad de clave principal> (por ejemplo, StudentID para la propiedad de navegación Student porque la clave principal de la entidad Student es ID). Las propiedades de clave externa también se pueden denominar simplemente <nombre de propiedad de clave principal> (por ejemplo, EnrollmentID porque la clave principal de la entidad de Enrollment es EnrollmentID).

Ha visto que las convenciones se pueden invalidar. Por ejemplo, si especificó que los nombres de tabla no se deben pluralar, verá más adelante cómo marcar explícitamente una propiedad como una propiedad de clave externa.

Obtención del código

Descargar proyecto completado

Recursos adicionales

Para obtener más información sobre EF 6, consulte estos artículos:

Pasos siguientes

En este tutorial va a:

  • Se creó una aplicación Web de MVC
  • Configurar el estilo del sitio
  • Instalado Entity Framework 6
  • Creado el modelo de datos
  • Creado el contexto de la base de datos
  • Inicializado la base de datos con datos de prueba
  • Configurar EF 6 para usar LocalDB
  • Creado un controlador y vistas
  • Consultado la base de datos

Avance al siguiente artículo para aprender a revisar y personalizar el código de creación, lectura, actualización y eliminación (CRUD) en los controladores y las vistas.

Implementación de la funcionalidad CRUD básica