ASP .NET Core - Scaffolding : criando Controllers e Views via linha de comando - I

 Neste artigo eu vou mostrar como criar Controllers e Views em um projeto ASP .NET Core via linha de comando.

Neste artigo vou criar um projeto ASP .NET Core usando a ferramenta NET CLI e o Visual Studio Code e a seguir mostrar como você pode criar Controllers e Views usando o comando dotnet aspnet-codegenerator.

Primeiro eu vou criar um projeto ASP .NET Core MVC para acessar a tabela Clientes de um banco de dados SQL Server existente chamado Estudo.mdf. Abaixo temos a estrutura da tabela e a string de conexão com o banco de dados:

String de conexão com o banco de dados Estudo:

Data Source=MACORATTI;Initial Catalog=Estudo;Integrated Security=True

Vou usar a ferramenta de linha de comando para realizar o Scaffolding para gerar o modelo de entidades e o contexto a partir do banco de dados usando o comando dotnet ef dbcontext scaffold  e depois eu vou mostrar como gerar o controlador e as views usando a linha de comando.

Recursos usados:

Criando o projeto via linha de comando (NET CLI)

Abra um terminal de comandos no seu ambiente. Eu estou usando o Windows PowerShell.

Crie uma pasta onde o projeto deverá ser hospedado. Eu vou criar uma pasta usando o comando: md AspCore_Scaffolding

A seguir entre na pasta criada : cd AspCore_Scaffolding

Para ver as opções de projetos digite : dotnet new

Vamos escolher o template mvc para criar um projeto ASP .NET Core MVC digitando: dotnet new mvc

Ao final teremos o projeto ASP .NET Core MVC criado na pasta AspCore_Scaffolding :

Temos assim uma aplicação funcional, na verdade , um simples projeto inicial, que é o nosso ponto de partida. Até aqui usamos a ferramenta de linha de comando NET CLI.

Neste momento podemos abrir o projeto no VS Code digitando : code . , e espiar o arquivo de projeto AspCore_Scaffolding.csproj :

Como vamos acessar o banco de dados usando o Entity Framework Core precisamos incluir uma referência a ele em nosso projeto.

Fazemo isso digitando o seguinte comando no terminal : dotnet add package Microsoft.EntityFrameworkCore.SqlServer

Nota: O provedor EntityFrameworkCore.SqlServer permite ao Entity Framework Core ser usado com o Microsoft SQL Server.

Abrindo o arquivo de projeto .csproj novamente agora veremos a referência ao Entity Framework Core incluida conforme abaixo:

Gerando o modelo de entidades e o contexto via Scaffolding

1- Preparando o ambiente

Agora vamos gerar o modelo de entidades e o contexto usando o Scaffolding, onde vamos partir do banco de dados existente Estudo.mdf e da tabela Clientes.

Para poder fazer isso temos que ter acesso ao comando : dotnet ef

Para ter acesso aos comandos dotnet ef temos que incluir as seguintes referências no projeto:

1- Microsoft.EntityFrameworkCore.SqlServer.Design :  Permite acesso as funcionalidades do Entity Framework para realizar o Migrations em tempo de projeto
2- Microsoft.EntityFrameworkCore.Tools :  Ferramenta de linha de comando do Ef Core que permite usar os comandos dotnet ef.
 3- Microsoft.EntityFrameworkCore.Tools.DotNet - Ferramenta de linha de comando do Ef Core que permite usar os comandos dotnet ef. (*)

Vamos instalar primeiro pacote : dotnet add package Microsoft.EntityFrameworkCore.SqlServer.Design

A seguir vamos instalar o segundo pacote : dotnet add package Microsoft.EntityFrameworkCore.Tools

Abrindo o arquivo de projeto .csproj veremos as referências conforme abaixo:

Vamos dar um comando : dotnet restore para restaurar as depêndencias.

Para concluir precisamos incluir uma referência ao pacote Microsoft.EntityFrameworkCore.Tools.DotNet.

Para isso temos que editar o arquivo de projeto .csproj e incluir a referência em um <ItemGroup> como um <DotNetCliToolReference> conforme abaixo:

Nota: Infelizmente até o momento essa é a única forma de incluir referências a ferramentas no projeto.

Agora digite o comando : dotnet restore e a seguir dotnet build

Muito bem. Não temos erros e todas as dependências estão restauradas. Podemos continuar...

Agora para saber se já temos acesso aos comandos do Entity Framework Core digite : dotnet ef

Voilá !!!

Agora podemos usar o Scaffolding usando a ferramenta EF Core Tools para gerar as entidades e o contexto a partir do banco de dados.

A ferramenta EF Core Tools possui outros comandos como:

dotnet ef dbcontext info :  Obtém informação sobre o tipo do DbContext
dotnet ef dbcontext list :  Lista os tipo de DbContext disponíveis.
dotnet ef dbcontext scaffold :  Faz o Scaffold de um DbContext e um entity type para o banco de dados

Para gerar o modelo de entidades a partir do banco de dados existente usamos o comando :

Scaffold-DbContext "string de conexão com o banco de dados" nome_do_provedor_do_banco_de_dados -o nome_da_pasta

Para o nosso exemplo o comando ficará assim:

Scaffold-DbContext "Data Source=.\;Initial Catalog=Estudo;Integrated Security=True" Microsoft.EntityFrameworkCore.SqlServer -o Models

 

Nesta instrução temos :

  1. O comando:  Scaffold-DbContext

  2. A string de conexão do banco de dados : "Data Source=.\;Initial Catalog=Estudo;Integrated Security=True"

  3. O nome do provedor usado :  Microsoft.EntityFrameworkCore.SqlServer

  4. O nome da pasta onde as classes serão geradas: -o Models



Ao final do processamento (nenhuma mensagem é exibida e nenhum erro deve ocorrer) podemos abrir o projeto no VS Code e verificar na pasta Models as classes geradas :



Nota:  Para saber mais sobre os comandos da ferramenta de linha de comando consulte este link : https://docs.microsoft.com/en-us/ef/core/miscellaneous/cli/dotnet

 O processo de engenharia reversa criou a classe de entidade e um contexto derivado baseado no esquema do banco de dados existente. As classes de entidade são objetos C# simples que representam os dados que você estará consultando e salvando. No nosso exemplo as informações de clientes da tabela Clientes.


Acima temos o código gerado para a classe Clientes.  Esta classe representa o nosso modelo de domínio e será mapeada para a tabela Clientes.

 

O código gerado para o contexto esta no arquivo EstudoContext.cs cujo código vemos a seguir:

 

using System;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata;
namespace AspCore_Scaffolding.Models
{
    public partial class EstudoContext : DbContext
    {
        public virtual DbSet<Clientes> Clientes { get; set; }
        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            if (!optionsBuilder.IsConfigured)
            {
                optionsBuilder.UseSqlServer(@"Data Source=.\;Initial Catalog=Estudo;Integrated Security=True");
            }
        }
        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Clientes>(entity =>
            {
                entity.Property(e => e.Email).HasMaxLength(250);
                entity.Property(e => e.Endereco).HasMaxLength(150);
                entity.Property(e => e.Nome)
                    .IsRequired()
                    .HasMaxLength(80);
                entity.Property(e => e.Telefone).HasMaxLength(80);
            });
        }
    }
}

 

A classe EstudoContext é a classe responsável pela interação com os objetos de dados sendo derivada da classe System.Data.Entity.DbContext (muitas vezes referida como o contexto).

Essa classe de contexto administra os objetos entidades durante o tempo de execução, o que inclui preencher objetos com dados de um banco de dados, controlar alterações, e persistir dados para o banco de dados.

Este código cria uma propriedade DbSet para a entidade Clientes. Na terminologia Entity Framework, um conjunto de entidades corresponde a uma tabela de banco de dados e uma entidade corresponde a uma linha na tabela.

Muuito bem... conseguimos fazer o Scaffolding usando as ferramentas do EF Core e gerar o nosso modelo de entidades e o contexto a partir do banco de dados existente.

Na segunda parte do artigo vou mostrar como gerar o Controlador e as Views para o projeto usando a linha de comando.

Antes, como ministros de Deus, tornando-nos recomendáveis em tudo; na muita paciência, nas aflições, nas necessidades, nas angústias,Como contristados, mas sempre alegres; como pobres, mas enriquecendo a muitos; como nada tendo, e possuindo tudo. 
 2 Coríntios 6:4,10
 

Veja os Destaques e novidades do SUPER DVD Visual Basic (sempre atualizado) : clique e confira !

Quer migrar para o VB .NET ?

Quer aprender C# ??

Quer aprender os conceitos da Programação Orientada a objetos ?

Quer aprender o gerar relatórios com o ReportViewer no VS 2013 ?

  Gostou ?   Compartilhe no Facebook   Compartilhe no Twitter

Referências:

José Carlos Macoratti