DT.

20211010
DS. Documento de anotações ao longo do estudo.
WORKTIME.

CURSO 1: NÉLIO ALVES

Aula 1. ASP.NET Core MVC

(1) Web Services Vs (2) Template Engine

1. Servidor(back) e navegador(front), SPA (Single Page Application), uso de

Frameworks e Libs JS. Devolve em JSON. Objetos javascript. Intenso uso de
javascript.

Tecnologias: React, Angular, Vue.js, jQuery.

2. Maior responsabilidade do backend, com construção das telas. O backend já

devolve o html
para montagem da tela.

Tecnologias: cada linguagem utiliza um template MVC, no caso C# trabalha com

ASP.NET Core, telas
em Razor Engine.

Aula 2. MVC

Model (Domain/DAL): estrutura dos dados e suas transformações. Composto de

entidades (objetos mapeados), serviços e
repositórios (data). Contém a regra de negócios em seus
serviços e entidades.

Controller(BLL/Business): recebe e trata os dados, meio de campo entre View e

Model. Faz as chamadas ao sistema.
View (UI): gera o html, telas de interação.

ENTITY FRAMEWORK

ORM da tecnologia .NET Core.

Provivers: SQL Server, MySQL, Oracle Database etc.

Classes pricipais: (1)DbContext e (2)DeSet<TEntity>

Sendo 1: encapsula uma sessão (conexão) com um serviço de banco de dados, permite
consultar e salver entidades no database,
define as entidades que farão parte do modelo de dados do sistema
(DbSets)
define configurações.
operações de acesso a dados.
meio de campo entre a aplicação e o banco de dados.

Sendo 2: coleção de entidades de um determinado tipo em um contexto, corresponde a

uma tabela do banco
de dados. São acessados através do DbContext.

Aula 3. Estrutura do Projeto

.cshtml > páginas razor que aceitam marcação html e código em c#.
Código c# sempre entre @{}.
Router: Controller/ação/id (opcional)
* Cada método do controlador é mapeado para uma ação.
* Todo controlador herda de Controller.
* Atenção para a fidelidade ao sistema de nomenclaturas, ex. nome da Pasta em Views
deve ser igual ao nome
do Controller ex. Departments e DepartmentsController.
* O nome da view também deve ser igual ao nome do método declarado em Controller.
* @foreach possível usar em uma coleção já construindo o html.

Natural Template: a requisição é recebida pelo controlador que carrega a view

(.cshtml).

IActionResult: interface genérica para todo resultado de alguma ação.

Aula 4: CRUD Scaffolding

Adicionar item scaffolding com MVC Controller, com views usando Entity Framework.

String de conexão com o banco apontando para SQL em appsettings.json >

ConnectionStrings
e startup métodos UseSqlServer().

Aula 5: Migration

Script para gerar e versionar a base de dados.

Code First (Objetos criam a estrutura de database).

Database First (Objetos replicam os esquemas já criados no database via ling. SQL).

Aula 6: Adaptando para MySQL:

1. Atualizar string de conexão:

"server=localhost;userid=developer;password=;database=;" - BASE

"server=localhost;userid=developer;password=07800319;database=DB_SALES_MANAGER;" -
EDITED

Em Startup.cs
-----------------------------------------------------------------------------------
-------------------------------------------------
services.AddDbContext<SalesManagerContext>(options =>

options.UseMySql(Configuration.GetConnectionString("SalesManagerContext"), builder
=> builder.MigrationsAssembly("SalesManager")));
-----------------------------------------------------------------------------------
-------------------------------------------------
Comando no Gerenciador de Pacotes nuget

Install-Package Pomelo.EntityFrameworkCore.MySql -Version 2.1.1

-----------------------------------------------------------------------------------
----------------------------------------------------------------

Verificar em Windows -> Ferramentas Administrativas -> Serviços se o MySql está em

execução.
Nesta etapa do projeto, basta realizar a migration, que consiste em gerar as
tabelas no DB com
base nos objetos C#.

-----------------------------------------------------------------------------------
-------------------------------------------------
Comando no Gerenciador de Pacotes nuget

#1 Add-Migration Initial
#2 Update-Database
-----------------------------------------------------------------------------------
----------------------------------------------------------------
* Remove-Migration to undo.

Após está ação, a tabela aparecerá no banco de dados e será possível realizar as
operações de CRUD
por meio das telas e sistema automaticamente criados.

Aula 7: Mudando tema no bootstrap.

Em http://bootswatch.com/3

Realizar download do bootstrap.css referente ao tema escolhido.

Aula 8: Inserindo novas entidades e segunda migration

a. Implementar regra de negócio

b. Adicionar DbSets nos DbContexts
c. Nova Migration

Aula 9: Serviço de Seeding

Populando base de dados.

Injetar dependência em Startup.cs

Obs: Migration deve ser usada para criar a estrutura das tabelas.

Aula 10: Novo Aba Sellers

Cria o listItem no layout.cshtml, definindo a rota para o controlador e ação.

Cria controlador na pasta Controller.
Cria a view.

Aula 11: SellerService e FindaAll síncrono

Guarda operações e regras de negócio relativas à Sellers.

Alterar configuração atual onde o controlador faz chamadas ao Entity Framework,

dependência a DbContext.
O controlador deverá apenas receber e encaminhar requisições, sem implementar
regras de negócio e acesso
a dados em Context.

As classes services sempre possuem dependência para a Context, e realizam as

operações de acesso a dados.
Os controladores então passam a chamar as classes services por meio de
dependências, e passam os dados
para view via parâmetro.
Gerar html para a view index com a tabela, laços foreach e chamadas a Html.Display,
asp actions etc.

Aula 12: Ação Create, inserindo novos vendedores.

1. Atentar para estrutura geral do programa e a relação entre as camadas baseadas

na fidelidade de nomenclatura,
além do conjunto de operações automáticas em background. Ex, ao inserir o
vendedor não é necessário montar o
objeto com base nos campos digitados, pois a view já é de Seller, e já realiza a
geração automática do objeto com
base nos campos, definidos no cshtml.

Aula 13: Integridade referencial.

Implementação de chave estrangeira não nula.

NEXT: Gerar html para visualização do departamento do Seller.

Aula 14: View Model e Select de Department

View Model > objeto composto contendo informações de duas ou mais entidades, apenas
para visualização. Pode ter
outros dados também, criados na hora.

Obs: Ao criar um novo serviço, não esquecer de adicionar ao escopo via

services.AddScope<S>()

Aula 15: Saller Details e Eager Loading

O Entity é capaz de realizar uma atualização no banco de dados, em um objeto de

mesmo Id, apenas
chamando _context.Update(), passando o objeto com as alterações no campo já
realizadas. Ele acha
o objeto ao qual este novo objeto está fazendo referência e atualiza.

Obs: Controller é usado tanto para solicitar operações em Services (com return
RedirectToAction), que diz respeito a mudança de informações
no banco de dados como também em relação a passar objetos para montagem das
telas (com return View(obj)).

Aula 16: Adicionar localização e formatação de data.

Bibliotecas definidas em startup.cs:

using System.Globalization;
using Microsoft.AspNetCore.Localization;

Configuração inserida na classe startup.cs.

Obs: Possível ADICIONAR DATA ANNOTATIONS NOS CAMPOS DOS MODELOS, para definir COMO
SERÃO EXPRESSOS OS NOMES DOS CAMPOS.
[Display(Name = "ex...")]

Aula 17: Validações

Adicionar tags específicas para validações de campos, ex. Required e StringLenght.
Necessário ainda realizar adições ao documento cshtml.

Aula 17: Conversão de operações síncronas em assíncronas.

Adicionar tags específicas para validações de campos, ex. Required e StringLenght.

Necessário ainda realizar adições ao documento cshtml.

O que deve ser assíncrono?

Operações de acesso a: disco, dados ou rede.
Assincrono não é igual a multithread.
Tasks encapsulam o processamento assíncrono.
Palavras chave: async e await
retornos ficam Task<Retorno> e void apenas Task
usar sufixo Async nos nomes dos métodos
se tiver retorno, vira return await ...
se tiver operação de acesso a dados, optar pela versão async ex. ToList ->
ToListAsync.
await em toda operação que for para esperar uma operação anterior.

* Mudança dos métodos para Async gerou problemas em algumas operações de CRUD, deve
ser feito com mais
cautela, apenas em operações de carregamento de dados para visualização.

Aula 18: Assegurando integridade referencial.

Aula 19: Novo Controller SallersRecords

Seles Record (model) => SalesRecordsController (plural + Controller) : Nomenclatura

EF

IQueryable, herda de IEnumerable mas é especializado em consultas no Db. Possível

realizar a montagem da
consulta utilizando expressões from, select, in etc. Ex.

IQueryable result = from obj in _context.SalesRecord select obj;

Conversão ex.

Síncrono

public List<Department> FindAll()

{
return _context.Department.OrderBy(x =>x.Name).ToList();
}

Assíncrono

public async Task<List<Department>> FindAllAsync()

{
return await _context.Department.OrderBy(x =>x.Name).ToListAsync();
}

+ INFO
Estrutura de Dependências

|Data (Context)| <- |Services| <- |Controller| -> |View|

Implementação HTTP:

asp-action: define qual método será chamado no controlador ao executar uma

deperminada ação a partir
do front end. Se a implementação consiste em chamar uma outra
tela, esta deve ter o nome
da ação, ex. View > Create.cshtml.

asp-route-id: define qual parâmetro será passsado para a próxima tela na rota.

+ CONTENT

NET Core(1) e Framework(2)

.Sendo 1 e 2: tecnologias para desenvolvimento utilizando a linguagem de

programação C#.
.Sendo 1 e 2: (ASP MVC, Web Forms, Windows Form. Monodeveloper, Xamarim etc).
.Sendo 1 é multiplataforma, enquanto 2 é apenas Windows.
.Sendo 1 não possui alguns componentes do anterior, "Core".

ASP.NET Core e Framework

. Sendo 1, apoiado no .NET Core, open source, multiplataforma, fácil integração com
outros frameworks
client side (Angular JS, KnockoutJS e Bootstrap), são suporta Web Forms.
Modularidade, com fácil inclusão
de pacotes via nuget, npm etc.

CURSO 2: HUGO VASCONCELOS (ASP.NET c/ MVC 5)

<MVC>

Model: data objects, entidades, comunicação com data.

View: front end.
Controller: regra de negócio, meio de campo.

Obs: Modelo MVC é orientado a database.

Obs: Projeto do curso criado com .NET Framework.

<Arquitetura de PASTAS Default>

App_Data > comunicação banco de dados

App_Start > bundle(roda scripts js e css, ex. estilo, configs, validate etc.),
filter (msg de erro) e route (endereçamento).
possível incluir arquivos js na configuração de bundle,
passando o mapeamento do diretório...
Content > arquivos css, imgs etc.
fonts
MVC pastas...
Scripts > arquivos js.
Em Global.asax > entry point da aplicação
Em Web.config > arquivo de configuração.

ROTA: controller/action/id
<Controller>

Carrega as Views.

Nomenclatura: HomeController, sendo (NomeController).

Herda de Controller
O que tem: guarda os métodos IActionResult, que retornam Views dentro do projeto.

<View>
Pasta (Nome do Controller) > cshtml (nome da ação).

<Requisições>

GET > puxar info database.

POST/SET > passar (update/insert) info database.

Obs: [HttpPost], method="GET", comunicação View -><- Controller. Funciona sem

também, quando
usado deste modo. Sendo GET, variáveis, entra na URL.
Sendo POST, + proteção, n entra na URL.

<Helpers>

Simulam tags, funções Html.

Ex.
-----------------------------------------------------------------------------------
---------
@RenderPage("cshtml path") // permite renderizar um doc html a partir de outro,
concatenando infos
e Html.Partial("cshtmlDocName") // permite chamar o trecho html e passar params
-----------------------------------------------------------------------------------
-------------
@Html.ActionLink("Voltar", "Index", "Home"); // Sendo p1 nome, p2 action, p3
controller.
-----------------------------------------------------------------------------------
-------------
@Html.LabelFor(x => x.Name) // referência ao nome dos campos em @model
-----------------------------------------------------------------------------------
-------------
<form action="Home/List" method="POST"> pode ser substituido por;

@using (Html.BeginForm("List", "Home", FormMethod.Post)) // Formulário

{
(content...)
}
-----------------------------------------------------------------------------------
-------------
<input type="text" value="@Model.Name" name="Name"/>
-----------------------------------------------------------------------------------
-------------

<Passando Valores entre as camadas>

1. ViewData, 2. ViewBag e 3.View Tipada

Sendo 1, em Controller, IActionResult Index

-----------------------------------------------------------------------------
var person = new Person() { Name = "Tarso", Age = 23, Type = "rich"};
ViewData["Name"] = person.Name;
-----------------------------------------------------------------------------

Obs: Necessário usar o mesmo nome.

Na view Index:
-----------------------------------------------------------------------------
<p>Nome Usuário: @ViewData["Name"]</p>
-----------------------------------------------------------------------------

Sendo 2, em Controller, IActionResult Index

-----------------------------------------------------------------------------------
-
var person = new Person() { Name = "Tarso", Age = 23, Type = "rich"};
ViewBag.Name = person.Name;
-----------------------------------------------------------------------------------
-
Na view Index
-----------------------------------------------------------------------------------
-
<p>Nome Usuário: @ViewBag.Name</p>
-----------------------------------------------------------------------------------
-
Obs: igual ao anterior, pequena diferença de sintaxe.

Sendo 3, em Controller, IActionResult Index

-----------------------------------------------------------------------------------
-
var person = new Person() { Name = "Tarso", Age = 23, Type = "rich"};
return View(person);
-----------------------------------------------------------------------------------
-
Na view Index
-----------------------------------------------------------------------------------
-
@model AspMvcIntro2.Models.Person
<p>Nome Usuário: @Model.Name</p>
-----------------------------------------------------------------------------------
-

<Recebendo Valores com View Tipada e FormCollection>

Na View
-----------------------------------------------------------------------------------
---------
<input type="text" value="@Model.Name" name="Name"/>
-----------------------------------------------------------------------------------
---------
Em Controller
-----------------------------------------------------------------------------------
---------
public ActionResult List(/*string Name*/FormCollection form)
{
//ViewData["Name"] = newName;
var person = new Person() { Name = form["Name"], Age = 23, Type =
"rich" };
return View(person);
}
-----------------------------------------------------------------------------------
--------------------------------
Obs: Atentar para o name do parâmetro na tag input, em View. É usado para recuperar
depois, em form[""].

Com View Tipada

-----------------------------------------------------------------------------------
-----
public ActionResult List(/*string Name*//*FormCollection form*/ Person
person)
{
//ViewData["Name"] = newName;
var person1 = new Person() { Name = person.Name, Age = 23, Type =
"rich" };
return View(person);
}
-----------------------------------------------------------------------------------
-----
Funciona apenas com View tipada.

<Validações c/ ASP>

1. Em cada propriedade.
2. No formulário.

Tratativas em Controller usando ModelState;

-----------------------------------------------------------------------------------
------------------------------------
[HttpPost]
public ActionResult Index(User user)
{
if (string.IsNullOrEmpty(user.Name))
ModelState.AddModelError("", "O campo campo é obrigatório!");
// acima, ao passar string vazia no param da propriedade, a msg é exibida no
ValidationSummary

// Validação de campos.
if (ModelState.IsValid)
{
// Caso seja válido, é chamado a View Result, conforme passado via
parâmetro,
// passando o usuário igualmente com a mensagem de erro nos campos.
return View("Result", user); // Referência em string a View Result.
}
else
return View(user);
}
-----------------------------------------------------------------------------------
-------------------------------------------
Obs: É possível inserir essas validações dentro da própria classe modelo, via
DataAnnotations, como expressões
regulares, range, campo Required, compare, remote (referência a uma função)
etc.

<Validação com Jquery e Validate>

Realiza os testes em tempo real, sem enviar requisições ao servidor, em tempo real.
ANOTAÇÕES FINAIS

Em MVC,
Model guarda entidade e serviços, coração do sistema e regra de negócio.
Controller; receber e tratar interações do usuário.
View; telas, resposta final.
Em Model -> Entidades, Serviços e DAOs

Tipos de Web App

Web Services (JS libraries) x Template Services

Em C#
C# -> Asp.NET Core -> Páginas Razor

Entity Framework ORM

resolver problema de app em POO e database relacional (tabelas).

DbContext: acesso ao banco de dados, definição dos DbSets

DbSet<T>: coleção de entidades

Código C# nas páginas Razor: @{}...

Tema do Bootstrap

Obter css em

https://bootswatch.com/#VERSAO_CSS#/

Colar em wwwroot > lib > bootstrap > dist > css

NOTES

Obs: a. Há algumas pequenas diferenças no setup do ASP.NET Framework e o Core, na

hora da criação do projeto.
b. Razor, sintaxe usada para criar páginas web dinâmicas com C#, cshtml.
c. Helpers é código C# que ajuda a montar o html, de modo mais dinâmico,
compondo o front end e
d. comunicação com os controladores.
e. ~/, acesso à pasta raiz do site.
f. _ como prefixo para docs cshtml evita que o caminho da url seja acessado
diretamente,
g. contrária a programação do site.
h. Possível separar o sistema em diversas áreas.
i. Há momentos em que é necessário adicionar novos namespaces à MapRoute.
j. FORTE ASSOCIAÇÃO por NOMES.
k. .NET Framework encontra-se na versão 5
l. .NET Core encontra-se na versão 3.1

MYSQL CONFIG
user name: developer
port: 3306
root password: 07800319