Alura > Cursos de Programação > Cursos de .NET > Conteúdos de .NET > Primeiras aulas do curso Entity Framework Core parte 1: mapeando um banco pré-existente

Entity Framework Core parte 1: mapeando um banco pré-existente

Configurando nomes de tabelas e colunas - Apresentação

Olá, sou Daniel Portugal, instrutor da Alura e da Caelum.

No curso anterior de "Entity Framework Core: Banco de dados de forma eficiente", aprendemos que o Entity é uma ferramenta ORM (Mapeamento Objeto-Relacional), ou seja, ela é responsável por fazer o mapeamento do mundo orientado do objeto ao mundo relacional dentro da plataforma .Net.

Para isto, utilizaremos um projeto em que íamos criando as classes C#, e evoluindo o banco de dados a partir delas. Uma situação típica de quem faz uso do Entity é assumir um projeto de manutenção em que o banco de dados já estará criado e populado. Nesses casos, teremos de usar a tabelas e recursos já existentes.

Neste curso, são apresentados os conhecimentos necessários para integrar o Entity em um banco de dados legado. Para tornar o curso mais fluido e didático, o conteúdo foi organizando em duas partes. Na primeira, aprenderemos a configurar classes e atributos a tabelas e colunas com nomes específicos. Aprenderemos a configurar o tipo e tamanho das colunas, bem como determinar se uma coluna é null ou notnull.

Aprenderemos o que fazer quando uma coluna não for necessária na camada de negócios. Iremos, ainda, revisar e configurar relacionamentos entre classes. Tudo isso utilizando as melhores de orientação ao objeto para separar as responsabilidades do seu código de configuração.

Na segunda parte, conheceremos as regras que o Entity segue para mapear herança e tipos numerados. Iremos aprender a configurar índices, chaves compostas, restrições unique, restrições check e veremos o que fazer quando tivermos view stored procedures no banco de dados.

Como qualquer ferramenta, o Entity possui suas limitações, iremos conhecê-las e superá-las. Nos momentos em que o Entity não atender às necessidades específicas que surgirem, saberemos como assumir o controle da geração do SQL.

Para demonstrar todos os conceitos, usaremos um banco de dados legado, chamando "Alura Filmes". Tentaremos mapear as tabelas às classes. A ferramenta que usaremos é o Visual Studio 2017 e um projeto do tipo console.

Você precisará conhecer SQL, pois faremos uso extensivo de comandos dessa linguagem, inclusive em algumas ferramentas que o próprio Visual Studio fornece.

Tentaremos replicar o banco de dados legado, checaremos, assim, se o Entity está gerando a estrutura de dados corretamente.

Configurando nomes de tabelas e colunas - Preparando o ambiente

Primeiramente, vamos preparar o ambiente para iniciar o curso. Precisaremos dos seguintes softwares: Visual Studio 2017 (pode ser a versão Community) e .Net Framework versão 4.7, pois iniciaremos o projeto utilizando o Entity Framework Core 2.0.

Precisaremos, também, do SQL Server Express, que será o banco de dados usado no curso.

Você precisará baixar o Visual Studio. Caso não tenha os outros softwares instalados, acesse o Visual Studio Installer e selecione a opção "modificar".

instalar

Na parte superior da tela, haverá a aba "Componentes Individuais". Marcaremos o componente ".NET Framework 4.7". Você pode selecionar as outras versões para testar em projetos variados.

NET

No fim da janela, encontraremos a opção "Nuvem, banco de dados e servidor".

banco de dados

Nela, marcaremos a opção a opção "SQL Server Data Tools" e "SQL Server Express 2016 LocalDB". Precisaremos, ainda, fazer o download do projeto em que iremos trabalhar.

Ao descompactar o arquivo, teremos o projeto "Alura.Filmes". Trabalharemos com um banco de dados legado relacionado a filmes e atores, similar ao IMDB.

O projeto é do tipo console, com isso, podemos focar na tecnologia nova que estamos aprendendo. No caso, estaremos focando no Entity Framework e nas classes de negócio.

Ao selecionarmos a opção "Program.cs" no campo "Gerenciador de Soluções" ao lado direito da ela, perceberemos que não existem muitos elementos dentro do projeto. Há uma classe que está vazia, por enquanto.

namespace Alura.Filmes.App
{
    class Program
    {
        static void Main(string[]) args)
        {

        }
    }
} 

Temos alguns diretórios. Em "Dados", colocaremos a nossa classe de contexto (que realiza a conexão entre o Entity e as classes de negócio). Em "Negocios" armazenaremos as classes relacionadas com negócio. Nosso objetivo é integrar o Entity Framework a um banco de dados já existente. Portanto, criaremos o banco de dados e iremos popula-lo, criar estrutura de tabelas e inserir registros para simular um banco de dados legado.

diretorios

Na pasta "Script", temos o script que criará a estrutura de banco de dados (alurafilmes-estrutura.sql) e outro que fará a carga (alurafilmes-cargainicial.sql).

script

Para criar a estrutura, selecionaremos o script correspondente (alurafilmes-estrutura.sql). Ao tentarmos executá-lo, veremos que não há nenhuma conexão com um banco de dados.

execucao

Uma dica é observar no canto inferior esquerdo da tela o status do script.

desconectado

Nós não temos nenhum banco de dados para executar o script. No cabeçalho de ferramentas, selecionaremos "Exibir > Pesquisar Objetos do SQL Server". Surgirá a caixa de diálogo que contém todos os servidores disponíveis na máquina.

Teremos o servidor local do SQL Server Express e nenhum banco de dados existente.

pesquisador

Vamos abrir a pasta "Banco de Dados" e com o botão direito escolheremos a opção "Adicionar Novo Banco de Dados". Nomearemos o banco como "Alura Filmes."

alurafilmes

Teremos um banco de dados novo, mas sem nenhuma tabela.

tabela

Na parte superior esquerda da tela, selecionaremos o ícone de conexão.

conectar

Na caixa de diálogo aberta, conectaremos no servidor local. Na parte inferior da caixa, teremos as informações de como será realizada essa conexão. Usaremos a autenticação do Windows e o banco de dados "Alura Filmes", que acabamos de criar.

conectaremos

Ao executarmos o script, teremos a mensagem de comando concluído com êxito.

exito

Ao observarmos novamente o "Pesquisador de Objetos do SQL Server", selecionamos o banco de dados "Alura Filmes" e verificamos a existência das tabelas, muito embora elas ainda não tenham dados.

tabelas existem

Usaremos o script alurafilmes-cargainicial.sql para colocar dados no banco que criamos. Selecionamos novamente o ícone de conexão na parte superior esquerda da tela para termos acesso à caixa de diálogo. Faremos a conexão local novamente, e selecionaremos o banco de dados "Alura Filmes."

conectaremos

Executaremos a carga inicial e receberemos uma mensagem de que o procedimento foi executado com êxito.

carga

Temos um banco de dados criado e com valores. No "Pesquisador de Objetos" selecionaremos a primeira tabela, clicaremos com o botão direito e escolheremos a opção "Exibir Dados".

exibir dados

A primeira tabela (actor), por exemplo, diz respeito aos atores. Teremos outras com outras informações.

atores

Configurando nomes de tabelas e colunas - Mapeando atores

A nossa primeira tarefa nesta aula é mapear as classes do diagrama da nossa aplicação "Alura Filmes", para as tabelas do banco de dados.

Abaixo temos nosso diagrama de classes:

diagrama de classes

As entidades a serem relacionadas:

entidades

Primeiramente selecionaremos a classe Ator...

classe ator

Para em seguida, mapeá-la à tabela actor.

tabela actor

Abriremos o Visual Studio para executar as próximas etapas. Como queremos integrar as informações ao Entity, precisamos criar uma classe de contexto. Colocaremos a nossa classe dentro da pasta "Dados". Na área do "Gerenciador de Soluções", clicaremos com o botão direito na pasta e selecionaremos "Adicionar > Classe".

dados

A classe se chamará AluraFilmesContexto.

classe contexto

A classe contexto precisa relacionar três informações: a primeira é o Entity. Isso será feito por meio da herança com a classe DbContext.

namespace Alura.Filmes.App.Dados
{
    public class AluraFilmesContexto : DbContext
    {
    }

}

A segunda informação é a conexão com o banco de dados, ou seja, qual banco de dados o Entity ira se direcionar. Uma das maneiras de realizar esse direcionamento é utilizando o método OnConfiguring(). Adicionaremos, ainda, o optionsBuilder para indicar que usaremos o SqlServer, que foi o provider instalado. Utilizamos a string de conexão que usamos como argumento do método SqlServer.


namespace Alura.Filmes.App.Dados
{
    public class AluraFilmesContexto : DbContext
    {
        protected override void OnConfiguring(DbContextOptionsBuild optionsBuilder)
        {
            optionsBuilder.UseSqlServer("Server=(localdb)mssqllocaldb;Database=AluraFilmes;Trusted_connection=true;");
        }
    }
}

A terceira informação é especificar quais propriedades devem ser gerenciadas pelo Entity. Faremos isso usando a propriedade DbSet para classe Ator. Chamaremos a propriedade de Atores.

 using Microsoft.EntityFrameworkCore;

namespace Alura.Filmes.App.Dados
{
    public class AluraFilmesContexto : DbContext
    {
        public DbSet<Ator> ATORES { get; set;}

        protected override void OnConfiguring(DbContextOptionsBuild optionsBuilder)
        {
            optionsBuilder.UseSqlServer("Server=(localdb)mssqllocaldb;Database=AluraFilmes;Trusted_connection=true;");
        }
    }
}

A classe Ator ainda não existe. Iremos colocar todas as classes de negócio na pasta "Negocio", localizada na área "Gerenciador de Soluções". Clicaremos sob a pasta com o botão direito e selecionamos "Adicionar > Classe". Criamos, então, a classe Ator.

classe nova

Ao criar a classe Ator, devemos nos lembrar das propriedades do diagrama de classes: Id, PrimeiroNome e UltimoNome. Faremos elas, portanto.

classe ator

namespace Alura.Filmes.App.Negocio
{
    public class Ator
    {
        public int Id {get; set;}
        public string PrimeiroNome { get; set; }
        public string UltimoNome { get; set; }
    }
}

Importaremos a classe para o contexto. Com isso, ele irá conter as três informações necessárias.

importando

Neste ponto, podemos realizar um teste básico para sabermos se os registros da tabela de atores pode ser acessado. O teste será um select em Program. Para realizar isso usando o Entity, criaremos uma instância daquele contexto, no caso, será AluraFilmesContexto.

namespace Alura.Filmes.App
{
    class Program
    {
        static void Main(string[] args)
        {
            //select * from actor
            using (var contexto = new AluraFilmesContexto())
            {

            }
        }
    }
}

Faremos o foreach que irá percorrer a propriedade Atores. Quando a propriedade for percorrida, o Entity irá popula-la e fará isso utilizando select. Depois das modificações, iremos iniciar a aplicação.

namespace Alura.Filmes.App
{
    class Program
    {
        static void Main(string[] args)
        {
            //select * from actor
            using (var contexto = new AluraFilmesContexto())
            {
                foreach (var ator in contexto.Atores)
                {
                    System.Console.WriteLine();
                }

            }
        }
    }
}

Perceberemos que ocorrerá um erro *invalid object name "Atores".

erro

Atores é o nome da propriedade que definimos para o DbSet da classe Ator. Mudaremos o nome da propriedade para ConjuntoDeAtores e executaremos novamente o programa.


using Alura.Filmes.App.Negocio;
using Microsoft.EntityFrameworkCore;

namespace Alura.Filmes.App.Dados
{
    public class AluraFilmesContexto : DbContext
    {
        public DbSet<Ator> ConjuntoDeAtores { get; set;}

        protected override void OnConfiguring(DbContextOptionsBuild optionsBuilder)
        {
            optionsBuilder.UseSqlServer("Server=(localdb)mssqllocaldb;Database=AluraFilmes;Trusted_connection=true;");
        }
    }
}

Novamente o programa anunciará um erro. Perceberemos que nesse caso o erro foi Invalid object name "ConjuntoDeAtores". O Entity, para poder mapear o nome da tabela correspondente à classe Ator, está se valendo do nome da propriedade DbSet da mesma classe. Essa é uma regra de execução implícita do Entity.

erro de novo

Renomearemos a propriedade para Atores.

using Alura.Filmes.App.Negocio;
using Microsoft.EntityFrameworkCore;

namespace Alura.Filmes.App.Dados
{
    public class AluraFilmesContexto : DbContext
    {
        public DbSet<Ator> Atores { get; set;}

        protected override void OnConfiguring(DbContextOptionsBuild optionsBuilder)
        {
            optionsBuilder.UseSqlServer("Server=(localdb)mssqllocaldb;Database=AluraFilmes;Trusted_connection=true;");
        }
    }
}

Denominam-se "convenções" as regras implícitas de execução do Entity. O software utiliza um sistema de convenções para simplificar o trabalho do desenvolvedor, ou seja, ele não precisa mapear todas as classes e propriedades, basta que você siga algumas convenções para o Entity execute certos comandos. Portanto, a primeira regra implícita que conhecemos é: ao mapear nome de casse como nome de tabela, o Entity faz uso do nome da propriedade DbSet. O problema é que o nome da tabela não é o mesmo nome da classe no caso do banco legado, logo, teremos de quebrar essa regra implícita.

Sobre o curso Entity Framework Core parte 1: mapeando um banco pré-existente

O curso Entity Framework Core parte 1: mapeando um banco pré-existente possui 198 minutos de vídeos, em um total de 68 atividades. Gostou? Conheça nossos outros cursos de .NET em Programação, ou leia nossos artigos de Programação.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

Aprenda .NET acessando integralmente esse e outros cursos, comece hoje!

Plus

  • Acesso a TODOS os cursos da plataforma

    Mais de 1200 cursos completamente atualizados, com novos lançamentos todas as semanas, em Programação, Front-end, UX & Design, Data Science, Mobile, DevOps e Inovação & Gestão.

  • Alura Challenges

    Desafios temáticos para você turbinar seu portfólio. Você aprende na prática, com exercícios e projetos que simulam o dia a dia profissional.

  • Alura Cases

    Webséries exclusivas com discussões avançadas sobre arquitetura de sistemas com profissionais de grandes corporações e startups.

  • Certificado

    Emitimos certificados para atestar que você finalizou nossos cursos e formações.

  • Alura Língua (incluindo curso Inglês para Devs)

    Estude a língua inglesa com um curso 100% focado em tecnologia e expanda seus horizontes profissionais.

12X
R$85
à vista R$1.020
Matricule-se

Pro

  • Acesso a TODOS os cursos da plataforma

    Mais de 1200 cursos completamente atualizados, com novos lançamentos todas as semanas, em Programação, Front-end, UX & Design, Data Science, Mobile, DevOps e Inovação & Gestão.

  • Alura Challenges

    Desafios temáticos para você turbinar seu portfólio. Você aprende na prática, com exercícios e projetos que simulam o dia a dia profissional.

  • Alura Cases

    Webséries exclusivas com discussões avançadas sobre arquitetura de sistemas com profissionais de grandes corporações e startups.

  • Certificado

    Emitimos certificados para atestar que você finalizou nossos cursos e formações.

  • Alura Língua (incluindo curso Inglês para Devs)

    Estude a língua inglesa com um curso 100% focado em tecnologia e expanda seus horizontes profissionais.

12X
R$120
à vista R$1.440
Matricule-se
Conheça os Planos para Empresas

Acesso completo
durante 1 ano

Estude 24h/dia
onde e quando quiser

Novos cursos
todas as semanas