CRIAR UM PROJETO

C#.NET CORE
Exercício Disciplina – aula 4
 CRIE UM NOVO PROJETO

Selecione o menu Arquivo e em seguida, no submenu, escolha Novo e então escolha Projeto.
CONTINUANDO
• Na janela Novo Projeto,
escolha Visual C# e em
seguida Aplicativo WEB
ASP.Net Core.
• Defina o nome do Projeto
• Escolha o local onde o
projeto será gravado. Utilize
o botão Procurar...
• Clique em OK para
confirmar.
Escolha a opção “Aplicativo
Web (Modelo-Exibição-
Controlador) e então clique
no botão OK.
Utilize as demais
configurações como
proposto pelo Visual Studio.

Este Projeto será criado sem

Autenticação.
Com o Projeto criado, analise a janela Gerenciador de Soluções.
Note as pastas Controllers, Models e Views.
A existência destas pasta indica que você escolheu o Uso do
modelo MVC.
O Projeto é criado um com alguns conteúdos.
Na pasta Controllers existirá o HomeController.cs que é responsável
pelas operações existentes na página Principal.
Na pasta Models, existirá a classe ErrorViewModel.cs responsável
por alguns tratamentos de erros.
Na pasta Views, existem duas subpastas: Home e Shared.
A Shared contém arquivos utilizados como lay-out padrão para as
demais pastas e a pasta Home, contem as páginas que estão
disponíveis ao clicar nas opções dos menus na página principal.
• Qualquer classe criada para representar informações sobre objetos, deverá ser alocada na pasta
Model para manter a organização do projeto.
• Na pasta Controllers, ficam as classes responsável pelas regras de negócio do seu aplicativos,
estas classes utilizarão as classes existentes em Model para conhecer os atributos que os objetos
representados possuem.
• A pasta Views receberá novas subspastas a medida que o projeto cresce e novas
funcionalidades são criadas. Basicamente cada subpasta é destina as páginas de visualização
de informações relacionadas aos Controllers.
• EX. para a situação de uma classe representando Professores, com as operações de CRUD
(Create, Request, Update e Delete) será criado em Model a classe que presentará os atributos do
Professor. Em Controllers, será criada a classe que será responsável pelas regras de negócio e
operações CRUD. Em Views serão criadas as páginas que exibirão os dados para o operador do
sistema. Normalmente uma página para cada tipo de operação.
CRIANDO UMA CLASSE
• Na pasta Model, clique com o
botão direito do mouse e
escolha a opção Adicional e
depois escolha Classe.
• Na janela, escolha a opção
Classe do ASP.NET Core.
• Defina um nome para a
Classe.
• Utilize nomes no SINGULAR e
com a primeira letra em
MAIÚSCULO.
• Com a classe criada, verifique que na linha 8 (neste
exemplo) está a indicação do pacote onde a classe foi
inserida, neste caso “namespace WebApplication1.Models,
ou seja, a classe está na pasta Models do projeto
Webapplication1 (nome do projeto que está em uso)
• Em seguida vem o nome da classe, neste caso Professor.

• Insira os comandos:
• using System.ComponenteModel.DataAnnotations;
• Este comandos permitem o uso de anotações na
classe
• using
System.ComponenteModel.DataAnnotations.Schema;
• Definição do tratamento de chaves primárias, nome
da tabela, nome do campo, e outras características
existentes em tabelas do banco de dados.
• Neste código foram criados 4 atributos
privados e os respectivos métodos de acesso
publico. Segue descrição das anotações:
• [Key] – indica que o atributo é um
identificador, normalmente tratado no DB
como chave primária.
• [DatabaseGenerated(DatabaseGeneratedO
ption.None)] – indica que o identificador será
fornecido e o banco de dados nem o
EntityFrameWork(veremos posteriormente)
serão responsáveis por esta informação.
• [Display(Name=“”)] Determina o nome que
será usado para o atributo quando for
exibido em Views.
• [MaxLength(10)] – Determina que o campo
aceitará no máximo 10 caracteres.
• [Requered] – Determina que o
preenchimento é obrigatório.
• [DataType(DataType.Date)] – Determina um
atributo do tipo DateTime, mas apenas a
parte Date será utilizada.
• [Range(100,300)] – Determinas valor mínimo e
máximo para o atributo numérico.
CRIANDO UM CONTROLLER
• Na pasta Controller,
clique com o botão
direito do mouse e
escolha a opção
Adicional e depois
escolha Controlador.

• Opcionalmente, você
pode utilizar “Novo item
com scaffold”, neste caso
as Views e os métodos do
Controller serão criados
automaticamente
baseados na Classe
selecionada.
Selecione o Indicado.

Se optou por utilizar o

método Scaffold,
selecione o
Controlador MVC com
exibições, usando
Entity Framework.
Se foi selecionado

Defina o nome do Controlador.

NÃO APAGUE O CONTEUDO “CONTROLLER”
DO NOME.
Defina o nome do controler com o mesmo
nome da classe que ele irá manipular, mas
mantendo o conteúdo “CONTROLLER” no
final do nome.
Sugiro fortemente o uso do nome da classe
nas no plural.
Ex. classe: Professor
controller: ProfessoresController
Se escolheu

Este processo cria o Controle e as Views

para a classe selecionada.
1 – Escolha a classe que será controlada
(Classe de Modelo)
2 – Defina a classe de contexto, se não
estiver na lista, pressione o botão + para
criar um contexto.
3 – Escolha o layout da página
4 – forneça um nome para o controlador,
geralmente é o nome da classe modelo
no Plural.

Se não houver erro no código da classe,

o controlador será criado e serão criadas
as views para executar o CRUD.
 CRIANDO VIEWS
Escolha o método do Controller que terá
uma view associada.
Clique com o botão direito do mouse no
nome do Método e escolha Adicionar
Exibição.
Neste caso optei pelo método Index do
Controller.

ATENÇÃO: se você utilizar o método

Scaffold, as views para o controlador já
estão criadas, mas você pode continuar
criando novas views se for necessário par
ao projeto.
Mantenha o nome do modo de exibição
igual ao nome do método escolhido.
Selecione o Modelo de View que será
utilizado.
Neste exemplo utilizarei o modelo List
para exibir todos os dados
armazenados para a classe Professor.

Os modelo:
• Create – cria uma view para
entrada de dados.
• Delete – Cria uma view para
exibirmos dados que serão
excluídos.
• Details – Cria a view que apenas
exibi dados.
• Edite – Cria uma view que permite
alterar os dados que são
visualizados.
• Empty – View totalmente vazia.
• Lista – View em forma de tabela
para exibir todos os dados.
Em Classe Modelo, é necessário
indicar qual a classe que será
utilizada para a obtenção dos
atributos que serão exibidos na View.
Atenção, aqui também são
apresentados classes Controllers.

Por último escolha a página de

layout que você pretende utilizar.

As página de layout são

encontradas na pasta Views ->
Shared.
Normalmente o projeto possui o
arquivo _Layout.cshtml.
ATUALIZANDO UMA CLASSE
PARA REPRESENTAR
RELACIONAMENTO UM
PARA MUITOS.
Tomando por base o DER ao lado. As classes
Disciplinas e Professores estão relacionadas.
Onde uma disciplina pode ser atribuída para
diversos Professores e um Professor tem apenas
uma disciplina atribuída.
Não é objetivo aqui definir a viabilidade deste
Diagrama, mas apenas indicar como
representar a relação nas classes envolvidas.
A classe Disciplina possuirá uma lista de
professores atribuídos para cada disciplina.
Nesta classe deve ser inserido um atributo para
gerenciar a lista de professores.
Ex.
private ICollection<Professor> listaProfessor;

E os métodos para acessar a listaProfessor.

Ex.
public ICollection ListaProfessor { get =>
listaProfessor; set => listaProfessor = value; }

Desta forma a Classe disciplina terá as

informações necessárias para e
EntityFlameWork (EF) realizar o processamento
adequado na tabela do Banco de Dados.
 A tabela Professores precisa de uma chave
estrangeira para referenciar a tabela
Disciplinas.
Na classe Professor serão inseridos um atributo
para funcionar como chave estrangeira e um
objeto para referenciar a classe Disciplina a
qual o Professor está “atribuído”, com os
respectivos métodos.
Ex.
private Disciplina disciplinaAtribuida;
public Disciplina DisciplinaAtribuida {get =>
disciplinaAtribuida; set => disciplinaAtribuida =
value;
private int disciplinaDisciplinaID;
public int DisciplinaDisciplinaID {get => disciplinaDisciplinaID ; set => disciplinaDisciplinaID = value;}

Para facilitar o uso do EF e da migração. O atributo que representa a chave estrangeira deve
possuir o nome da Classe de referência (Disciplina) seguindo do nome do atributo que é o
identificador (DisciplinaID), por isto foi exemplificado usando o nome DisciplinaDisciplinaID.
ATUALIZANDO UMA CLASSE
PARA REPRESENTAR
RELACIONAMENTO MUITOS
PARA MUITOS.
Tomando por base o DER ao lado. As classes
Disciplinas e Alunos estão relacionadas.
Onde uma disciplina pode ser cursada por
diversos Alunos e um Aluno pode cursar
diversas disciplinas.
Não é objetivo aqui definir a viabilidade deste
Diagrama, mas apenas indicar como
representar a relação nas classes envolvidas.
Por se tratar de uma relação muitos para
muitos, uma tabela associativa é utilizada.
Utilizaremos o nome AlunosDisciplinas.
Esta tabela associativa será representada pela
classe AlunoDisciplina.
A classe Disciplina possuirá uma lista de
AlunoDisciplina atribuídos para cada disciplina.
Nesta classe deve ser inserido um atributo para
gerenciar a lista.
Ex.
private ICollection<AlunosDisciplina> listaAlunos;

E o método para acessar a listaAlunos.

Ex.
public ICollection ListaAlunos { get => listaAlunos;
set => listaAlunos = value; }

Desta forma a Classe disciplina terá as

informações necessárias para e EntityFlameWork
(EF) realizar o processamento adequado na
tabela do Banco de Dados.
A classe Alunos, simular a classe Disciplina, possuirá
uma lista de AlunoDisciplina atribuídos para cada
disciplina.
Nesta classe deve ser inserido um atributo para
gerenciar a lista.
Ex.
private ICollection<AlunosDisciplina> listaDisciplinas;

E o método para acessar a listaAlunos.

Ex.
public ICollection ListaDisciplinas { get =>
listaDisciplinas; set => listaDisciplinas = value; }

Desta forma a Classe Aluno terá as informações

necessárias para e EntityFlameWork (EF) realizar o
processamento adequado na tabela do Banco de
Dados.
A tabela associativa AlunosDisciplinas precisa
de uma chave estrangeira para referenciar a
tabela Disciplinas e outra para Alunos.
Na classe AlunoDisciplina serão inseridos
atributos para funcionar como chave
estrangeira e um objeto para referenciar a
classe Disciplina e outro para a classe Aluno,
com os respectivos métodos.
Ex.
private Disciplina disciplinaCursando;
public Disciplina DisciplinaCursando {get =>
disciplinaCursando; set => disciplinaCursando =
value;
private int disciplinaDisciplinaID;
public int DisciplinaDisciplinaID {get => disciplinaDisciplinaID ; set => disciplinaDisciplinaID = value;}

private Aluno alunoCursando;

public Aluno alunoCursando {get => alunoCursando; set => alunoCursando = value;
private int alunoAlunoID;
public int AlunoAlunoID {get => alunoAlunoID ; set => alunoAlunoID = value;}

Para facilitar o uso do EF e da migração. O atributo que representa a chave estrangeira deve
possuir o nome da Classe de referência (Disciplina) seguindo do nome do atributo que é o
identificador (DisciplinaID), por isto foi exemplificado usando o nome DisciplinaDisciplinaID.
CRIAR ÍNDICE ÚNICO E
ÍNDICE PRIMÁRIO
COMPOSTO
• Índice único e índice primário composto não estão disponíveis como
anotações em projetos .NET Core.
• Para implementá-los é necessário utilizar a API Fluente, ou seja, programar
estas características das tabelas, mas atenção, isto apenas é necessário se
for utilizar o processo de migração do EF. Em outras palavras, deixar o EF
criar o Banco de dados e as tabelas a partir das definições existentes nas
classes da aplicação. Se o banco de dados já existir, estas características
das tabelas já estão implementadas e cabe ao desenvolvedor apenas
utilizar estas características.
 • O código abaixo exemplifica os processos para criar os índices
mencionados.
protected override void OnModelCreating(ModelBuilder modelBuilder){
base.OnModelCreating(modelBuilder);
// cria um índice único
modelBuilder.Entity<[Classe que representa a tabela]>()
// a => a. pode ser substituído outro valor ( nome => nome. )
.HasIndex(a => a.[atributo]) // [atributo] = nome do campo
.HasName(“[nome do indice]");
.IsUnique();
// cria um índice primário composto (vários atributos)
modelBuilder.Entity<Aluno>()
// new {} cria um vetor com os atributos que compõem a chave.
.HasKey(a => new { a. [atributo1], a. [atributo2] })
.HasName(“[nome do indice]");
}

Este código deve ser implementado na classe que extende DBContext.

Normalmente esta classe fica na pasta DATA no projeto.
Cada projeto tem um nome para a classe, mas geralmente conte a palavra Context no nome.
 • Executando no Console do Gerenciado de pacote
NuGet
• Para inserir uma migração execute :
• add-migration [nome da migação], o nome não
pode ser repetido.
• Para eliminar uma migração execute:

MIGRAÇÃO • remove-migration, apenas a migração mais nova

pode ser excluída, desde que não tenha sido
implementada no banco de dados.
• Após realizar a migração, para atualizar um banco de
dados, execute o comando:
• update-database
• Para remover um banco de dados excute:
• drop-database