Criação de classes de modelo com o Entity Framework (C#)

pela Microsoft

Neste tutorial, você aprenderá a usar ASP.NET MVC com o Microsoft Entity Framework. Você aprenderá a usar o Assistente de Entidade para criar um modelo de dados de entidade ADO.NET. Ao longo deste tutorial, criamos um aplicativo Web que ilustra como selecionar, inserir, atualizar e excluir dados de banco de dados usando o Entity Framework.

O objetivo deste tutorial é explicar como você pode criar classes de acesso a dados usando o Microsoft Entity Framework ao criar um aplicativo ASP.NET MVC. Este tutorial pressupõe que nenhum conhecimento anterior do Microsoft Entity Framework. Ao final deste tutorial, você entenderá como usar o Entity Framework para selecionar, inserir, atualizar e excluir registros de banco de dados.

O Microsoft Entity Framework é uma ferramenta O/RM (Mapeamento Relacional de Objetos) que permite gerar uma camada de acesso a dados de um banco de dados automaticamente. O Entity Framework permite que você evite o trabalho tedioso de criar suas classes de acesso a dados manualmente.

Para ilustrar como você pode usar o Microsoft Entity Framework com ASP.NET MVC, criaremos um aplicativo de exemplo simples. Criaremos um aplicativo de Banco de Dados de Filme que permite exibir e editar registros de banco de dados de filme.

Este tutorial pressupõe que você tenha o Visual Studio 2008 ou o Visual Web Developer 2008 com o Service Pack 1. Você precisa do Service Pack 1 para usar o Entity Framework. Você pode baixar o Visual Studio 2008 Service Pack 1 ou o Visual Web Developer com o Service Pack 1 no seguinte endereço:

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

Criando o banco de dados de exemplo de filme

O aplicativo Banco de Dados de Filme usa uma tabela de banco de dados chamada Filmes que contém as seguintes colunas:

Você pode adicionar essa tabela a um projeto ASP.NET MVC seguindo estas etapas:

1. Clique com o botão direito do mouse na pasta App_Data na janela Gerenciador de Soluções e selecione a opção de menu Adicionar, Novo Item.
2. Na caixa de diálogo Adicionar Novo Item, selecione SQL Server Banco de Dados, dê ao banco de dados o nome MoviesDB.mdf e clique no botão Adicionar.
3. Clique duas vezes no arquivo MoviesDB.mdf para abrir a janela Explorer servidor Explorer/banco de dados.
4. Expanda a conexão de banco de dados MoviesDB.mdf, clique com o botão direito do mouse na pasta Tabelas e selecione a opção de menu Adicionar Nova Tabela.
5. Na Designer tabela, adicione as colunas ID, Título e Diretor.
6. Clique no botão Salvar (ele tem o ícone do disquete) para salvar a nova tabela com o nome Filmes.

Depois de criar a tabela de banco de dados Filmes, você deve adicionar alguns dados de exemplo à tabela. Clique com o botão direito do mouse na tabela Filmes e selecione a opção de menu Mostrar Dados da Tabela. Você pode inserir dados falsos de filme na grade exibida.

Criando o modelo de dados de entidade ADO.NET

Para usar o Entity Framework, você precisa criar um modelo de dados de entidade. Você pode aproveitar o Assistente de Modelo de Dados de Entidade do Visual Studio para gerar um Modelo de Dados de Entidade de um banco de dados automaticamente.

Siga estas etapas:

1. Clique com o botão direito do mouse na pasta Modelos na janela Gerenciador de Soluções e selecione a opção de menu Adicionar, Novo Item.
2. Na caixa de diálogo Adicionar Novo Item , selecione a categoria Dados (consulte Figura 1).
3. Selecione o modelo ADO.NET Modelo de Dados de Entidade , dê ao Modelo de Dados de Entidade o nome MoviesDBModel.edmx e clique no botão Adicionar . Clicar no botão Adicionar inicia o Assistente de Modelo de Dados.
4. Na etapa Escolher Conteúdo do Modelo , escolha a opção Gerar de um banco de dados e clique no botão Avançar (consulte a Figura 2).
5. Na etapa Escolher Sua Conexão de Dados , selecione a conexão de banco de dados MoviesDB.mdf, insira as configurações de conexão de entidades nome MoviesDBEntities e clique no botão Avançar (consulte Figura 3).
6. Na etapa Escolher Seus Objetos de Banco de Dados , selecione a tabela Banco de dados Filme e clique no botão Concluir (consulte Figura 4).

Depois de concluir essas etapas, o Designer de Modelo de Dados de Entidade ADO.NET (Entity Designer) é aberto.

Figura 1 – Criando um novo modelo de dados de entidade

Figura 2 – Escolher a Etapa de Conteúdo do Modelo

Figura 3 – escolher sua conexão de dados

Figura 4 – Escolher seus objetos de banco de dados

Modificando o modelo de dados de entidade ADO.NET

Depois de criar um Modelo de Dados de Entidade, você pode modificar o modelo aproveitando o Entity Designer (consulte a Figura 5). Você pode abrir a entidade Designer a qualquer momento clicando duas vezes no arquivo MoviesDBModel.edmx contido na pasta Modelos na janela Gerenciador de Soluções.

Figura 5 – O modelo de dados de entidade ADO.NET Designer

Por exemplo, você pode usar a entidade Designer para alterar os nomes das classes geradas pelo Assistente de Dados do Modelo de Entidade. O Assistente criou uma nova classe de acesso a dados chamada Filmes. Em outras palavras, o Assistente deu à classe o mesmo nome que a tabela de banco de dados. Como usaremos essa classe para representar uma instância de Filme específica, devemos renomear a classe de Filmes para Filme.

Se você quiser renomear uma classe de entidade, clique duas vezes no nome da classe na entidade Designer e insira um novo nome (consulte Figura 6). Como alternativa, você pode alterar o nome de uma entidade no janela Propriedades depois de selecionar uma entidade no Entity Designer.

Figura 6 – Alterando um nome de entidade

Lembre-se de salvar seu Modelo de Dados de Entidade depois de fazer uma modificação clicando no botão Salvar (o ícone do disquete). Nos bastidores, a entidade Designer gera um conjunto de classes C#. Você pode exibir essas classes abrindo o MoviesDBModel. arquivo Designer.cs da janela Gerenciador de Soluções.

Não modifique o código no arquivo Designer.cs, pois as alterações serão substituídas na próxima vez que você usar a entidade Designer. Se você quiser estender a funcionalidade das classes de entidade definidas no arquivo Designer.cs, poderá criar classes parciais em arquivos separados.

Selecionando registros de banco de dados com o Entity Framework

Vamos começar a criar nosso aplicativo de Banco de Dados de Filme criando uma página que exibe uma lista de registros de filmes. O controlador Home na Listagem 1 expõe uma ação chamada Index(). A ação Index() retorna todos os registros de filme da tabela de banco de dados Movie aproveitando o Entity Framework.

Listagem 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 o controlador na Listagem 1 inclui um construtor. O construtor inicializa um campo de nível de classe chamado _db. O campo _db representa as entidades de banco de dados geradas pelo Microsoft Entity Framework. O campo _db é uma instância da classe MoviesDBEntities que foi gerada pelo Entity Designer.

Para usar a classeMoviesDBEntities no controlador Home, você deve importar o namespace MovieEntityApp.Models (MVCProjectName). Modelos).

O campo _db é usado na ação Index() para recuperar os registros da tabela de banco de dados Movies. A expressão _db. MovieSet representa todos os registros da tabela de banco de dados Filmes. O método ToList() é usado para converter o conjunto de filmes em uma coleção genérica de objetos Movie (List<Movie>).

Os registros do filme são recuperados com a ajuda de LINQ to Entities. A ação Index() na Listagem 1 usa a sintaxe do método LINQ para recuperar o conjunto de registros de banco de dados. Se preferir, você pode usar a sintaxe de consulta LINQ. As duas instruções a seguir fazem a mesma coisa:

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

Use qualquer sintaxe LINQ – sintaxe de método ou sintaxe de consulta – que você achar mais intuitiva. Não há diferença no desempenho entre as duas abordagens – a única diferença é o estilo.

O modo de exibição na Listagem 2 é usado para exibir os registros do filme.

Listagem 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>

O modo de exibição na Listagem 2 contém um loop foreach que itera em cada registro de filme e exibe os valores das propriedades Title e Director do registro de filme. Observe que um link Editar e Excluir é exibido ao lado de cada registro. Além disso, um link Adicionar Filme aparece na parte inferior da exibição (consulte Figura 7).

Figura 7 – A exibição Índice

A exibição Índice é uma exibição tipada. A exibição Index inclui uma <diretiva %@ Page %> com um atributo Inherits que converte a propriedade Model em uma coleção list genérica fortemente tipada de objetos Movie (List<Movie).

Inserindo registros de banco de dados com o Entity Framework

Você pode usar o Entity Framework para facilitar a inserção de novos registros em uma tabela de banco de dados. A listagem 3 contém duas novas ações adicionadas à classe de controlador Home que você pode usar para inserir novos registros na tabela de banco de dados Movie.

Listagem 3 – Controllers\HomeController.cs (Adicionar 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);
}

A primeira ação Add() simplesmente retorna uma exibição. O modo de exibição contém um formulário para adicionar um novo registro de banco de dados de filme (consulte a Figura 8). Quando você envia o formulário, a segunda ação Add() é invocada.

Observe que a segunda ação Add() é decorada com o atributo AcceptVerbs. Essa ação só pode ser invocada ao executar uma operação HTTP POST. Em outras palavras, essa ação só pode ser invocada ao postar um formulário HTML.

A segunda ação Add() cria uma nova instância da classe Entity Framework Movie com a ajuda do método TryUpdateModel() do ASP.NET MVC. O método TryUpdateModel() usa os campos no FormCollection passados para o método Add() e atribui os valores desses campos de formulário HTML à classe Movie.

Ao usar o Entity Framework, você deve fornecer uma "lista de segurança" de propriedades ao usar os métodos TryUpdateModel ou UpdateModel para atualizar as propriedades de uma classe de entidade.

Em seguida, a ação Add() executa alguma validação de formulário simples. A ação verifica se as propriedades Title e Director têm valores. Se houver um erro de validação, uma mensagem de erro de validação será adicionada ao ModelState.

Se não houver erros de validação, um novo registro de filme será adicionado à tabela de banco de dados Filmes com a ajuda do Entity Framework. O novo registro é adicionado ao banco de dados com as duas seguintes linhas de código:

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

A primeira linha de código adiciona a nova entidade Movie ao conjunto de filmes que estão sendo rastreados pelo Entity Framework. A segunda linha de código salva todas as alterações feitas nos Filmes que estão sendo rastreados de volta para o banco de dados subjacente.

Figura 8 – a exibição Adicionar

Atualizando registros de banco de dados com o Entity Framework

Você pode seguir quase a mesma abordagem para editar um registro de banco de dados com o Entity Framework que a abordagem que acabamos de seguir para inserir um novo registro de banco de dados. A listagem 4 contém duas novas ações de controlador chamada Edit(). A primeira ação Edit() retorna um formulário HTML para editar um registro de filme. A segunda ação Editar() tenta atualizar o banco de dados.

Listagem 4 – Controllers\HomeController.cs (Editar métodos)

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);
}

A segunda ação Edit() começa recuperando o registro Movie do banco de dados que corresponde à ID do filme que está sendo editado. A seguinte instrução LINQ to Entities captura o primeiro registro de banco de dados que corresponde a uma ID específica:

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

Em seguida, o método TryUpdateModel() é usado para atribuir os valores dos campos de formulário HTML às propriedades da entidade de filme. Observe que uma lista de segurança é fornecida para especificar as propriedades exatas a serem atualizadas.

Em seguida, alguma validação simples é executada para verificar se as propriedades Título do Filme e Diretor têm valores. Se uma propriedade não tiver um valor, uma mensagem de erro de validação será adicionada a ModelState e ModelState.IsValid retornará o valor false.

Por fim, se não houver erros de validação, a tabela de banco de dados Movies subjacente será atualizada com quaisquer alterações chamando o método SaveChanges().

Ao editar registros de banco de dados, você precisa passar a ID do registro que está sendo editado para a ação do controlador que executa a atualização do banco de dados. Caso contrário, a ação do controlador não saberá qual registro atualizar no banco de dados subjacente. A exibição Editar, contida na Listagem 5, inclui um campo de formulário oculto que representa a ID do registro de banco de dados que está sendo editado.

Listagem 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>

Excluindo registros de banco de dados com o Entity Framework

A operação final do banco de dados, que precisamos abordar neste tutorial, é excluir registros de banco de dados. Você pode usar a ação do controlador na Listagem 6 para excluir um registro de banco de dados específico.

Listagem 6 -- \Controllers\HomeController.cs (ação Excluir)

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");
}

A ação Delete() primeiro recupera a entidade Movie que corresponde à ID passada para a ação. Em seguida, o filme é excluído do banco de dados chamando o método DeleteObject() seguido pelo método SaveChanges(). Por fim, o usuário é redirecionado de volta para a exibição Índice.

Resumo

A finalidade deste tutorial era demonstrar como você pode criar aplicativos Web controlados por banco de dados aproveitando ASP.NET MVC e o Microsoft Entity Framework. Você aprendeu a criar um aplicativo que permite selecionar, inserir, atualizar e excluir registros de banco de dados.

Primeiro, discutimos como você pode usar o Assistente de Modelo de Dados de Entidade para gerar um modelo de dados de entidade de dentro do Visual Studio. Em seguida, você aprenderá a usar LINQ to Entities para recuperar um conjunto de registros de banco de dados de uma tabela de banco de dados. Por fim, usamos o Entity Framework para inserir, atualizar e excluir registros de banco de dados.