Crear clases de modelo con Entity Framework (C#)

por Microsoft

En este tutorial, aprenderá a usar ASP.NET MVC con Microsoft Entity Framework. Aprenderá a usar el Asistente para entidades para crear una instancia de Entity Data Model de ADO.NET. A lo largo de este tutorial, crearemos una aplicación web que ilustre cómo seleccionar, insertar, actualizar y eliminar datos de base de datos mediante Entity Framework.

El objetivo de este tutorial es explicar cómo puede crear clases de acceso a datos mediante Microsoft Entity Framework al compilar una aplicación ASP.NET MVC. En este tutorial se da por hecho que no existe un conocimiento previo de Microsoft Entity Framework. Al final de este tutorial, comprenderá cómo usar Entity Framework para seleccionar, insertar, actualizar y eliminar registros de base de datos.

Microsoft Entity Framework es una herramienta de asignación relacional de objetos (O/RM) que permite generar automáticamente una capa de acceso a datos desde una base de datos. Entity Framework elimina el trabajo tedioso de crear las clases de acceso a datos a mano.

Para ilustrar cómo puede usar Microsoft Entity Framework con ASP.NET MVC, crearemos una aplicación de ejemplo sencilla. Crearemos la aplicación de base de datos Movie para mostrar y editar registros de base de datos de películas.

En este tutorial se supone que tiene Visual Studio 2008 o Visual Web Developer 2008 con Service Pack 1. Necesita Service Pack 1 para usar Entity Framework. Puede descargar Visual Studio 2008 Service Pack 1 o Visual Web Developer con Service Pack 1 desde la siguiente dirección:

https://www.asp.net/downloads/

Nota:

No hay ninguna conexión esencial entre ASP.NET MVC y Microsoft Entity Framework. Hay varias alternativas a Entity Framework que puede usar con ASP.NET MVC. Por ejemplo, puede compilar las clases de modelo de MVC mediante otras herramientas de O/RM, como Microsoft LINQ to SQL, NHibernate o SubSonic.

Creación de la base de datos Movie de ejemplo

La aplicación de base de datos Movie usa una tabla de base de datos denominada Películas que contiene las columnas siguientes:

Nombre de la columna	Tipo de datos	¿Permitir valores null?	¿Es la clave principal?
Identificador	int	False	True
Título	nvarchar(100)	False	False
Director	nvarchar(100)	False	False

Puede agregar esta tabla a un proyecto de ASP.NET MVC siguiendo estos pasos:

1. Haga clic con el botón derecho en la carpeta App_Data de la ventana Explorador de soluciones y seleccione la opción de menú Agregar, Nuevo elemento.
2. En el cuadro de diálogo Agregar nuevo elemento, seleccione Base de datos SQL Server, asigne a la base de datos el nombre MoviesDB.mdf y haga clic en el botón Agregar.
3. Haga doble clic en el archivo MoviesDB.mdf para abrir la ventana Explorador de servidores o Explorador de bases de datos.
4. Expanda la conexión de base de datos MoviesDB.mdf, haga clic con el botón derecho en la carpeta Tablas y seleccione la opción de menú Agregar nueva tabla.
5. En el Diseñador de tablas, agregue las columnas Id., Title y Director.
6. Haga clic en el botón Guardar (tiene el icono de disquete) para guardar la nueva tabla con el nombre Movies.

Después de crear la tabla de base de datos Movies, debe agregar algunos datos de ejemplo a la tabla. Haga clic con el botón derecho en la tabla Movies y seleccione la opción de menú Mostrar datos de tabla. Puede escribir datos falsos de películas en la cuadrícula que aparece.

Creación de la instancia de Entity Data Model de ADO.NET

Para usar Entity Framework, debe crear una instancia de Entity Data Model. Puede usar el Asistente para Entity Data Model de Visual Studio para generar una instancia de Entity Data Model a partir de una base de datos automáticamente.

Siga estos pasos:

1. Haga clic con el botón derecho en la carpeta Models de la ventana Explorador de soluciones y seleccione la opción de menú Agregar, Nuevo elemento.
2. En el cuadro de diálogo Agregar nuevo elemento, seleccione la categoría Datos (vea la figura 1).
3. Seleccione la plantilla Entity Data Model de ADO.NET, asigne a la instancia de Entity Data Model el nombre MoviesDBModel.edmx y haga clic en el botón Agregar. Al hacer clic en el botón Agregar, se inicia el Asistente para modelos de datos.
4. En el paso Elegir contenido del modelo, elija la opción Generar desde una base de datos y haga clic en el botón Siguiente (vea la figura 2).
5. En el paso Elegir la conexión de datos, seleccione la conexión de base de datos MoviesDB.mdf, escriba el nombre de la configuración de conexión de entidades MoviesDBEntities y haga clic en el botón Siguiente (vea la figura 3).
6. En el paso Elegir los objetos de base de datos, seleccione la tabla de base de datos Movies y haga clic en el botón Finalizar (vea la figura 4).

Después de completar estos pasos, se abre el Diseñador de Entity Data Model de ADO.NET (Entity Designer).

Figura 1: Creación de una nueva instancia de Entity Data Model

Figura 2: Paso Elegir contenido del modelo

Figura 3: Elección de la conexión de datos

Figura 4: Elección de los objetos de base de datos

Modificación de la instancia de Entity Data Model de ADO.NET

Después de crear una instancia de Entity Data Model, puede modificar el modelo con Entity Designer (vea la figura 5). Puede abrir Entity Designer en cualquier momento haciendo doble clic en el archivo MoviesDBModel.edmx incluido en la carpeta Modelos dentro de la ventana del Explorador de soluciones.

Figura 5: Diseñador de Entity Data Model de ADO.NET

Por ejemplo, puede usar Entity Designer para cambiar los nombres de las clases que genera el Asistente para Entity Data Model. El Asistente creó una nueva clase de acceso a datos denominada Movies. En otras palabras, el Asistente dio a la clase el mismo nombre que el de la tabla de base de datos. Dado que usaremos esta clase para representar una instancia determinada de Movie, deberíamos cambiar el nombre de la clase de Movies a Movie.

Si quiere cambiar el nombre de una clase de entidad, puede hacer doble clic en el nombre de clase en Entity Designer y escribir un nombre nuevo (vea la figura 6). Como alternativa, puede cambiar el nombre de una entidad en el ventana Propiedades después de seleccionar una entidad en Entity Designer.

Figura 6: Cambio de un nombre de entidad

Recuerde guardar su instancia de Entity Data Model después de realizar una modificación haciendo clic en el botón Guardar (el icono de disquete). En segundo plano, Entity Designer genera un conjunto de clases de C#. Puede ver estas clases abriendo el archivo MoviesDBModel.Designer.cs desde la ventana del Explorador de soluciones.

No modifique el código del archivo Designer.cs, ya que los cambios se sobrescribirán la próxima vez que use Entity Designer. Si desea ampliar la funcionalidad de las clases de entidad definidas en el archivo Designer.cs, puede crear clases parciales en distintos archivos.

Selección de registros de base de datos con Entity Framework

Para comenzar, vamos a crear nuestra aplicación Base de datos de películas mediante la creación de una página que muestre una lista de registros de películas. El controlador Home de la lista 1 expone una acción denominada Index(). La acción Index() devuelve todos los registros de película de la tabla de base de datos Película usando Entity Framework.

Lista 1: Controllers\HomeController.cs

using System.Linq;
using System.Web.Mvc;
using MovieEntityApp.Models;

namespace MovieEntityApp.Controllers
{
    [HandleError]
    public class HomeController : Controller
    {
        MoviesDBEntities _db;

        public HomeController()
        {
            _db = new MoviesDBEntities();
        }

        public ActionResult Index()
        {
            ViewData.Model = _db.MovieSet.ToList();
            return View();
        }

    }
}

Observe que el controlador de la lista 1 incluye un constructor. El constructor inicializa un campo de nivel de clase denominado _db. El campo _db representa las entidades de base de datos generadas por Microsoft Entity Framework. El campo _db es una instancia de la clase MoviesDBEntities generada por Entity Designer.

Para usar la clase MoviesDBEntities en el controlador Home, debe importar el espacio de nombres MovieEntityApp.Models (MVCProjectName.Models).

El campo _db se usa dentro de la acción Index() para recuperar los registros de la tabla Base de datos de películas. La expresión _db.MovieSet representa todos los registros de la tabla Base de datos de películas. El método ToList() se usa para convertir el conjunto de películas en una colección genérica de objetos Movie (List<Movie>).

Los registros de películas se recuperan con la ayuda de LINQ to Entities. La acción Index() de la lista 1 usa la sintaxis del método de LINQ para recuperar el conjunto de registros de base de datos. Si lo prefiere, puede usar la sintaxis de consulta de LINQ en su lugar. Las dos instrucciones siguientes hacen lo mismo:

ViewData.Model = _db.MovieSet.ToList();
ViewData.Model = (from m in _db.MovieSet select m).ToList();

Use la sintaxis de LINQ ( sintaxis de método o sintaxis de consulta) que encuentre más intuitiva. No hay ninguna diferencia en el rendimiento entre los dos enfoques, la única diferencia es el estilo.

La vista de la lista 2 se usa para mostrar los registros de películas.

Lista 2: Views\Home\Index.aspx

<%@ Page Language="C#"  
  Inherits="System.Web.Mvc.ViewPage<List<MovieEntityApp.Models.Movie>>" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title>Index</title>
</head>
<body>
    <div>
    
<% foreach (var m in ViewData.Model)
   { %>

    Title: <%= m.Title %>
    <br />
    Director: <%= m.Director %>
    <br />
    <%= Html.ActionLink("Edit", "Edit", new { id = m.Id })%>
    <%= Html.ActionLink("Delete", "Delete", new { id = m.Id })%>
       
        <hr />
<% } %>

<%= Html.ActionLink("Add Movie", "Add") %>
    
    </div>
</body>
</html>

La vista de la lista 2 contiene un bucle foreach que recorre en iteración cada registro de película y muestra los valores de las propiedades Title y Director del registro de película. Observe que se muestra un vínculo Editar y eliminar junto a cada registro. Además, aparece un vínculo Agregar película en la parte inferior de la vista (vea la figura 7).

Figura 7: La vista Index

La vista Index es una vista con tipo. La vista Index incluye una directiva <%@ Page %> con un atributo Inherits que convierte la propiedad Model en una colección List genérica fuertemente tipada de objetos Movie (List<Movie).

Inserción de registros de base de datos con Entity Framework

Puede usar Entity Framework para facilitar la inserción de nuevos registros en una tabla de base de datos. La lista 3 contiene dos nuevas acciones agregadas al controlador Home que puede usar para insertar nuevos registros en la tabla de base de datos Movie.

Lista 3: Controllers\HomeController.cs (Agregar métodos)

public ActionResult Add()
{
    return View();
}

[AcceptVerbs(HttpVerbs.Post)]
public ActionResult Add(FormCollection form)
{
    var movieToAdd = new Movie();

    // Deserialize (Include white list!)
    TryUpdateModel(movieToAdd, new string[] { "Title", "Director" }, form.ToValueProvider());

    // Validate
    if (String.IsNullOrEmpty(movieToAdd.Title))
        ModelState.AddModelError("Title", "Title is required!");
    if (String.IsNullOrEmpty(movieToAdd.Director))
        ModelState.AddModelError("Director", "Director is required!");

    // If valid, save movie to database
    if (ModelState.IsValid)
    {
        _db.AddToMovieSet(movieToAdd);
        _db.SaveChanges();
        return RedirectToAction("Index");
    }

    // Otherwise, reshow form
    return View(movieToAdd);
}

La primera acción Agregar() simplemente devuelve una vista. La vista contiene un formulario para agregar un nuevo registro de base de datos de películas(vea la figura 8). Al enviar el formulario, se invoca la segunda acción Add().

Observe que la segunda acción Add() está decorada con el atributo AcceptVerbs. Esta acción solo se puede invocar al realizar una operación HTTP POST. En otras palabras, esta acción solo se puede invocar al publicar un formulario HTML.

La segunda acción Add() crea una nueva instancia de la clase Movie de Entity Framework con la ayuda del método TryUpdateModel() de ASP.NET MVC. El método TryUpdateModel() toma los campos del elemento FormCollection pasado al método Add() y asigna los valores de estos campos de formulario HTML a la clase Movie.

Al usar Entity Framework, debe proporcionar una "lista segura" de propiedades cuando se emplean los métodos TryUpdateModel o UpdateModel para actualizar las propiedades de una clase de entidad.

A continuación, la acción Add() realiza alguna validación de formulario simple. La acción comprueba que las propiedades Title y Director tienen valores. Si se produce un error de validación, se agrega un mensaje de error de validación a ModelState.

Si no hay errores de validación, se agrega un nuevo registro de película a la tabla de base de datos Movies con la ayuda de Entity Framework. El nuevo registro se agrega a la base de datos con las dos líneas de código siguientes:

_db.AddToMovieSet(movieToAdd);
_db.SaveChanges();

La primera línea de código agrega la nueva entidad Movie al conjunto de películas de las que Entity Framework realiza el seguimiento. La segunda línea de código guarda en la base de datos subyacente los cambios que se hayan realizado en las películas objeto de seguimiento.

Figura 8: La vista Agregar

Actualización de registros de base de datos con Entity Framework

Puede seguir casi el mismo enfoque para editar un registro de base de datos con Entity Framework como el enfoque que acabamos de seguir para insertar un nuevo registro de base de datos. La lista 4 contiene dos nuevas acciones de controlador denominadas Edit(). La primera acción Edit() devuelve un formulario HTML para editar un registro de película. La segunda acción Edit() intenta actualizar la base de datos.

Lista 4: Controllers\HomeController.cs (métodos Edit)

public ActionResult Edit(int id)
{
    // Get movie to update
    var movieToUpdate = _db.MovieSet.First(m => m.Id == id);

    ViewData.Model = movieToUpdate;
    return View();
}

[AcceptVerbs(HttpVerbs.Post)]
public ActionResult Edit(FormCollection form)
{
    // Get movie to update
    var id = Int32.Parse(form["id"]);
    var movieToUpdate = _db.MovieSet.First(m => m.Id == id);

    // Deserialize (Include white list!)
    TryUpdateModel(movieToUpdate, new string[] { "Title", "Director" }, form.ToValueProvider());

    // Validate
    if (String.IsNullOrEmpty(movieToUpdate.Title))
        ModelState.AddModelError("Title", "Title is required!");
    if (String.IsNullOrEmpty(movieToUpdate.Director))
        ModelState.AddModelError("Director", "Director is required!");

    // If valid, save movie to database
    if (ModelState.IsValid)
    {
        _db.SaveChanges();
        return RedirectToAction("Index");
    }

    // Otherwise, reshow form
    return View(movieToUpdate);
}

La segunda acción Edit() comienza recuperando el registro Movie de la base de datos que coincide con el identificador de la película que se está editando. La siguiente instrucción LINQ to Entities toma el primer registro de base de datos que coincide con un identificador determinado:

var movieToUpdate = _db.MovieSet.First(m => m.Id == id);

A continuación, se usa el método TryUpdateModel() para asignar los valores de los campos de formulario HTML a las propiedades de la entidad movie. Observe que se proporciona una lista segura para especificar las propiedades exactas que se van a actualizar.

A continuación, se realiza una validación sencilla para comprobar que las propiedades Movie Title y Director tienen valores. Si alguna propiedad no tiene un valor, se agrega un mensaje de error de validación a ModelState y ModelState.IsValid devuelve el valor false.

Por último, si no hay errores de validación, la tabla de base de datos Movies subyacente se actualiza con los cambios llamando al método SaveChanges().

Al editar registros de base de datos, debe pasar el identificador del registro que se está editando a la acción del controlador que realiza la actualización de la base de datos. De lo contrario, la acción del controlador no sabrá qué registro actualizar en la base de datos subyacente. La vista Editar, contenida en la lista 5, incluye un campo de formulario oculto que representa el identificador del registro de base de datos que se está editando.

Lista 5: Views\Home\Edit.aspx

<%@ Page Language="C#" 
  Inherits="System.Web.Mvc.ViewPage<MovieEntityApp.Models.Movie>" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title>Edit</title>
    <style type="text/css">
    
    .input-validation-error
    {
        background-color:Yellow;
    }
    
    </style>    
</head>
<body>
    <div>

<h1>Edit Movie</h1>

<form method="post" action="/Home/Edit">

    <!-- Include Hidden Id -->
    <%= Html.Hidden("id") %>

    Title:
    <br />
    <%= Html.TextBox("title") %>
    
    <br /><br />
    Director:
    <br />
    <%= Html.TextBox("director") %>
    
    <br /><br />
    <input type="submit" value="Edit Movie" />
</form>
    
    </div>
</body>
</html>

Eliminación de registros de base de datos con Entity Framework

La operación final de la base de datos, que necesitamos abordar en este tutorial, consiste en eliminar registros de base de datos. Puede usar la acción del controlador en la lista 6 para eliminar un registro de base de datos determinado.

Lista 6: \Controllers\HomeController.cs (acción Eliminar)

public ActionResult Delete(int id)
{
    // Get movie to delete
    var movieToDelete = _db.MovieSet.First(m => m.Id == id);

    // Delete 
    _db.DeleteObject(movieToDelete);
    _db.SaveChanges();

    // Show Index view
    return RedirectToAction("Index");
}

La acción Delete() recupera primero la entidad Movie que coincide con el Id pasado a la acción. A continuación, la película se elimina de la base de datos mediante la llamada al método DeleteObject() seguido del método SaveChanges(). Por último, se redirige al usuario de vuelta a la vista Index.

Resumen

El propósito de este tutorial era demostrar cómo puede crear aplicaciones web controladas por bases de datos aprovechando las ventajas de ASP.NET MVC y Microsoft Entity Framework. Ha aprendido a compilar una aplicación que le permite seleccionar, insertar, actualizar y eliminar registros de base de datos.

Primero, se ha explicado cómo puede usar el Asistente de Entity Data Model para generar una instancia de Entity Data Model desde Visual Studio. A continuación, ha aprendido a usar LINQ to Entities para recuperar un conjunto de registros de base de datos de una tabla de base de datos. Por último, se ha usado Entity Framework para insertar, actualizar y eliminar registros de base de datos.

Siguiente