Curso Web API ASP .NET Core Essencial

		Instrutor Macoratti
	Curso Web API ASP .NET Core Essencial (C#) - Básico/Intermediário (NET 6)
Clique aqui e faça o seu pedido (Receba via Download)

84 Vídeo Aulas em 9 Módulos com Projetos Completos (11 horas)

Curso WEB API Asp Net Core Essencial - Apresentando Unit Of Work Curso WEB API Asp Net Core Essencial - Introdução ao GraphQL

Apresentação e Conteúdo do Curso

Módulo1 - Conceitos : 5 Aulas - 31 minutos

1a. Conceitos - 8:16 min.
- O que é uma API
- O que é uma Web API
- Rest e Soap - Conceitos
- ASP .NET Core Web API - Conceito

2a. Comprrendendo REST - 8:13 min.
- REST - Apresentação e conceitos
- O que é um Serviço RESTFul
- Protocolo HTTP e verbos GET, POST, PUT e DELETE
- Código de Status de resposta: StatusCode HTTP

3a. Anatomina das requisições HTTP - 5:49 min.
- Comunicação Cliente e Web API
- Request e Reponse: Status Line, Headers e Body
- Exemplos de Request e Responses

4a. Métodos HTTP : Get, Post, Put e Delete - 6:36 min.
- Métodos HTTP - conceitos
- Http GET , POST , PUT e DELETE
- Conceito de idempotente e CRUD
- Tipos de retorno, Cabeçalho e Status Code

5a. HTTPS e HSTS - 2:40 min.
- HTTPS - conceito e objetivo
- HSTS - conceito
- Usando Https e Hsts

6a. JSON - 9:46 min.
- JSON - Conceitos
- Sintaxe e Valores usados : Numero, String, Objetos, Array, Null
- Editores JSON On-line
- JSON e a plataforma .NET : HttpClient
- O pacote System.Text.Json

Módulo2 - Ambiente de trabalho : 5 Aulas - 40 minutos

1a. Ambiente de Trabalho- 3:12 min.
- Ambiente de trabalho de desenvolvimento
- Plataforma .NET Core, ASP .NET Core 3.0 Preview
- Visual Studio Code, Visual Studio 2019 Preview
- A convenção sobre configuração

2a. Ferramentas - Instalação- 7:35 min.
- .NET Core SDK 3.0 Preview - Instalação
- Ferramenta de linha de comando NET CLI
- Visual Studio Code - Plugins
- Visual Studio 2019 Preview - Instalação

3a. Criando uma WEB API no VS 2019 Preview - 10:28 min.
- Apresentando os templates de projetos do VS 2019
- Usando o template ASP .NET Core Web Application
- Templates de projetos : Empty, API e Web Application
- Projeto Web API : estrutura
- Configurações usadas no projeto
- Controlador : conceito e convenções
- Atributos : Route e ApiController
- Métodos Action e métodos Http

4a. Criando uma WEB API no VS Code - 8:45 min.
- Usando a ferramenta de linha de comando : NET CLI
- Comandos : dotnet
- Criando um projeto webapi via linha de comando
- Abrindo e editando o projeto no VS Code
- Executando o projeto na linha de comando
- Ajustando o projeto para ser aberto no VS 2019

5a. Criar Web API usando o template Empty - 11:54 min.
- Usando o Vs 2019 Preview
- Criando o projeto ASP .NET Core Web Application
- Usando o template Empty
- Ajustando o projeto criado
- Definindo o controlador e os métodos Actions

Módulo3 - ASP .NET Core WEB API - ApiCatalogo : 12 Aulas - 1 hora e 40 minutos

1a. Projeto : Criando uma Web API - 11:32 min.
- Apresentando uma visão geral das práticas adotadas
- Definição e estrutura do projeto
- Escopo da API e nomenclatura
- Definição de recursos e dos endpoints e mapeamento
- Implementação da segurança
- Persistência de dados
- Estrutura do projeto : Camadas

2a. WEB API para Produtos e Categorias - 11:04 min.
- Criando um projeto WEB API no VS 2019 Preview
- Criando um serviço RestFul na ASP .NET Core
- Fluxo de trabalho para criar APIs
- Catálogo de Produtos e Categorias : roteiro
- Definição dos Controllers : Métodos Action e Http
- Referenciando o EF Core e EF Core Tools
- Usando o provedor MySQL Pomelo
- Definindo o modelo de Entidades

3a. Configurações do EF Core Code First - 8:38 min.
- EF Core : Abordagens - DataBase First e Code First
- Relacionamento um-para-muitos : Categorias - Produtos
- Criando a classe de Contexto e mapeando as entidades
- Registrando o contexto e configurando o provedor
- Definindo a string de conexão

4a. Aplicando o Migrations - 9:38 min.
- Gerando o banco de dados e tabelas no MySql
- Instalando o MySQL e MySQL WorkBench
- Migrations - Conceitos
- Comandos : Add-Migration e Update-DataBase
- Definindo os atributos Data Annotations
- Gerando o Script de Migração
- Aplicando o Script e criando o Banco de dados
- Criando as tabelas no MySql

5a. Populando o banco de dados - 5:59 min.
- Populando as tabelas Produtos e Categorias
- Definindo uma nova migração
- Definir comando SQL para incluir dados no método Up()
- Definir comando SQL para excluir dados no método Down()
- Gerar o script de migração e aplicar a migração

6a. Criando a Web API ProdutosController - 10:41 min.
- Criando o controlador usando o VS 2019 Preview
- Criando um serviço RestFul : ProdutosController
- Expor endpoints para ler, criar, editar e excluir produtos
- Definindo os mapamentos Http: Get, Post, Put e Delete
- Opções de criação de APIs via Scaffold
- Criando uma classe C# e definindo as convenções
- Aplicando os atributos : Route e ApiController
- Definindo o método Action Get : Retornando uma lista
- Testando a Web API

7a. ProdutosController - Método Action Get(Id) - 5:35 min.
- Criando o método Action Get(int id)
- Retornando um objeto Produto
- Definindo o mapeamento HttpGet
- Definindo o parâmetro id no request
- Definindo a consulta LINQ usando FirstOrDefault
- Verificando o resultado : Retornando NotFound()
- Usando o método AsNoTracking() na consulta
- Consultas síncronas e assíncronas

8a. ProdutosController - Método Action Post - 7:37 min.
- Criando o método Action Post(Object)
- Definindo o atributo HttpPost
- Usando [FromBody] para obter dados do Request
- Validando o ModelState - ApiController: BadRequest
- Usando o método Add e SaveChanges
- Definindo o Header Location HTTP : CreateAtRouteResult

9a. Instalando e usando o Postman - 7:50 min.
- Apresentando e instalando o Postman
- Testando os métodos Get, Post, Put e Delete
- Definindo os comandos Http no Postman
- Testando o método Get e Get(id)
- Testando o método Post
- Definindo o objeto no Body do Request no formato JSON
- Verificando o resultado e o código de estado retornado
- Analisando o Response e o seu Header

10a. ProdutosController - Métodos Put e Delete - 9:34 min.
- Criando as Action Put(id,Object) e Delete(id)
- Usando os atributos HttpPut e HttpDelete
- Definindo os parãmetros no Request
- Usando o atributo [FromBody]
- Verificando o Id do Produto : BadRequest
- Alterando dados com EntityState.Modified
- Deletando dados com Remove(object)
- Persistindo as alterações com o método SaveChanges()
- Testando a alteração e exclusão no Postman

11a. Criando a Web API CategoriasController - 8:56 min.
- Criando o Controlador CategoriasController
- Definindo os métodos Action : Get, Post, Put e Delete
- Definindo os atributos: HttpGet, HttpPost, HttpPut e HttpDelete
- Testando os métodos Action no Postman
- Testando o Get, Get(id), Post, Put e Delete no Postman

12a. CategoriasController : Dados relacionados - 8:27 min.
- Obtendo dados relacionados em um método Action
- Obtendo uma Categoria e seus Produtos
- Criando um método Action para retornar Categoria e Produtos
- Definindo um novo endpoint usando HttpGet()
- Tratando o erro JsonSerializationException com Json
- Usando o método Include() do EF Core
- Retornado uma lista de produtos para categoria

Módulo4 - Fundamentos da ASP .NET Core WEB API - 16 Aulas - 2 horas e 2 minutos

1a. Roteamento - 8:10 min.
- Definindo Rotas : Conceito e aplicação
- Mapeando os request para os métodos Action
- Responsabilidades do roteamento
- Definindo o roteamento nas APIs via atributos
- Atributo Route[] - Definindo a rota
- Definindo o roteamento nos atributos: HttpGet,Post,Put e Delete
- Regras de roteamento
- Adiciionando o middleware de Roteamento e Endpoints

2a. Padrões de roteamento - 8:51 min.
- Usando padrões de roteamento
- Atributo Route[("api/Controller")]
- Definindo templates de rotas nos atributos Http
- Combinando template de rotas com rota padrão
- Definindo parâmetros e valor padrão
- Aplicando exemplos de roteamento

3a. Definindo restrições de Rotas - 8:41 min.
- Restrições de rotas - conceitos
- Aplicando restrições de rotas
- Definindo restrição para valor mínimo
- Definindo restrição para valores alfanúmericos
- Definindo restrição de tamanho
- Tabela de restrições de rotas

4a. Tipos de retorno dos métodos Action - 7:35 min.
- Tpos de retorno : Tipo específico, IActionResult, ActionResult<T>
- Retorno de tipos de dados complexo e primitivo
- Vários tipos de retorno com IActionResult
- Retorndo de tipo derivado de ActionResult
- Retorno de tipo específico com ActionResult<T>
- Comparando ActionResult<T> e IActionResult

5a. Criando métodos Action Assíncronos - 8:15 min.
- Definição de métodos Síncronos e Assíncronos
- A programação assíncrona com async e await e o tipo Task
- Exemplo de método assíncrono com async e await
- Regras e convenções da programação assíncrona
- Vale a pena usar Actions Assíncronas ?
- Criando métodos Assíncronos

6a. Apresentando o Model Binding - 10:25 min.
- Model Binding conceitos
- Como funciona o Model Binding - Exemplo
- Model Binding com fonte de dados
- Valores de formulários , Rotas e QueryString : Exemplos
- Atributos BindRequired, BindNever
- Atributos que indicam a fonte de dados dos parâmetros

7a. Data Annotations - 10:01 min.
- Data Annotations e a validação do modelo: ModelState
- Como funciona o Data Annotations
- Principais atributos Data Annotations
- [Required], [StringLength], [MaxLenght], [Range],
- [ErrorMessge], [Url], [Phone], [CreditCard]
- Exemplo de utilização de Data Annotations com Postman

8a. Validação Personalizada do modelo - 6:42 min.
- Criar atributos customizados para validar o modelo
- Validando propriedades
- Herdando de ValidationAttribute
- Sobrescrevendo o método IsValid
- Implementando a validação com atributo customizado

9a Validação Personalizada do modelo II - 4:13
- Implementar IValidateObject no modelo
- Implementando o método Validate
- Exemplo de validação personalizada
- Testando a validação

10a. Middleware - 5:35 min.
- Apresentando o conceito de Middleware
- O fluxo de atendimento : o pipeline de requisições
- A ordem de atendimento dos middlewares
- Habilitando os middlewares no método Configure

11a. Modelo de Configuração - 8:25 min.
- Apresentando o novo modelo de configuração
- Nova |API de configuração : pares chave-valor
- Provedores de Configuração : JSON, XML, INI, Texto, etc.
- Configuração Json : valores definidos no formato chave : valor
- Arquivo appsettings.json - estrutura
- Lendo dados de configuração

12a. Filtros - 4:58 min.
- Conceito de Filtros
- Atuação dos filtros : como funciona
- Tipos de filtros : ordem de execução
- Implementação síncrona de filtros
- Implementação assíncrona de filtros
- Usando os filtros da plataforma .NET
- Filtros escopo e ordem de execução

13a. Criando Filtros - 7:46 min.
- Criando filtros personalizados
- Abordagem síncrona e assíncrona
- Criando um filtro para logar registros
- Implementando a interface IActionFilter
- Implementando o método OnActionExcecuting
- Implementando o método OnActionExecuted
- Configurando serviço em ConfigureServices : AddScoped
- Aplicando o filitro à Action usando via atributo

14a. Tratamento de erros - 7:08 min.
- Tratamento de erros Global na ASP .NET Core
- Usando o middleware UseExceptionHandler
- Criando um classe para representar os erros
- Criando classe estática
- Usando o middleware UseExceptionHandler
- Habilitar o middleware no método Configure()

15a. Logging - 9:29 min.
- O que é um Log de Dados ?
- Obtendo um log de dados usando um registro de log
- API de Logging da ASP .NET Core
- Provedores de logs internos
- Console, Debug, EventLog, Trace, Event e AzureApp
- Níveis de Log : Trace, Debug, Info, Warning, Error, Critical, etc.
- Interfaces : ILoggingFactory, ILoggingProvider e ILogger
- Criando um registro de log : ILogger e método Log()
- Exemplo prático de utilização de Log com ILogger

16a. Logging Customizado - 9:36 min.
- Implementando um Log customizado
- Registrando o registro de log em um arquivo texto
- Definindo a configuração do provider
- Criando a classe do provider : CustomLoggerProvider
- Criando a classe do Logger : CustomerLogger
- Incluindo um ILoggerFactory no método Configure
- Ativando o logger no método Configure
- Implementando e testando o registro de log

Módulo5 - Repositório : 12 Aulas - 1 hora e 22 minutos

1a. O padrão Repository - 5:20 min.
- Apresentando o padrão repositório
- Forte acoplamento : Controller e EF Core
- Repositório : Centraliza o lógica de acesso a dados
- Coleção de objetos de domínio na memória
- Benefícios do padrão repositório
- Implementação : Interface - Classe Concreta

2a. Implementando o repositório - 10:31 min.
- Implementando o padrão repositório no projeto Web API
- Criando a pasta Repositorio
- Definindo as interfaces e classes do repositório
- Criando um repositório genérico
- Criando repositório para Categorias e Produtos

3a. O padrão Unit Of Work - 4:02 min.
- Apresentando o padrão Unit Of Work
- Unidade de trabalho : rastrear e salvar
- Invólucro para os repositórios
- Implementa a persistência das informações
- Implementação : Interface e Classe Concreta
- Representa uma transação
- Mantém as atualizações na memória

4a. Implementando o Unit of Work - 7:07 min.
- Mais de um repositório mantem instãncias de DbContext
- Geração de inconsistências
- UnitOfWork - transmitir instância de DbContext
- Implementando o padrão Unit of Work no projeto

5a. Ajustando os Controladores - 7:58 min.
- Ajustando os controladores para usar o Unit of Work
- Alterando os métodos Actions para métodos Síncronos
- Usando a instãncia do Unit of Work nos controladores
- Ajustando todos os métodos Actions
- Implementando os métodos específicos

6a. Testando os Controllers I - 6:34 min.
- Consumindo a API ProdutosController no Postman
- Testando os métodos Action no Postman
- Testando os métodos Get, Post, Put e Delete
- Fazendo CRUD básico

7a. Testando os Controllers II - 5:07 min.
- Consumindo a API CategoriasController no Postman
- Testando os métodos Action no Postman
- Testando os métodos Get, Post, Put e Delete
- Fazendo CRUD básico

8a. Web API : Considerações - 7:28 min.
- Considerações sobre os padrões Repositório e UnitOfWork
- Usando o EF Core já estamos usando esses padrões
- DbSet<T> e DbContext
- Criação de outra camada de abstração no EF Core
- Utilização de EF Core in Memory para Testes
- Projeto aderente ao OOP para troca de framework
- Tipos de retorno dos métodos da interface
- IQueryable ou IEnumerable

9a. Data Transfer Object - DTO e Auto Mapper - 8:15 min.
- Expor todas as informações das entidades
- Exibir apenas as informações necessárias
- DTO - Data Transfer Objects (ViewModels)
- Representar os dados que desejamos expor
- Definindo os DTOs para nossas entidades
- Benefícios em usar DTO
- Mapeamento dos objetos das entidades para os DTOs
- Usando o AutoMapper

10a. Criando DTOs e Configurando AutoMapper - 5:24 min.
- Criando os DTOs para o projeto WEB API - ApiCatalogo
- Criando os DTOs - ProdutoDTO e CategoriaDTO
- Incluindo o pacote Nuget AutoMapper no projeto
- Definindo os mapeamentos dos objetos para os DTOs : Profile
- Configurando o AutoMapper no método ConfigureServices

11a. Ajustando os Controllers para o AutoMapper- 5:30 min.
- Ajustando os métodos Actions dos controladores
- Injetando a instância do AutoMapper no construtor
- Fazendo o mapeamento dos objetos nos métodos Action

12a. Testando o mapeamento do AutoMapper - 9:32 min.
- Testando os métodos Actions dos controladores
- Usando o Postman
- Testando os métodos Get, Put, Post e Delete
- Verificando o mapeamento para os DTOs

Módulo6 - Segurança : 10 Aulas - 1 hora e 8 minutos

1a. Autenticação e Autorização - 3:55 min.
- Autenticação e Autorização : conceitos
- Implementação na ASP .NET Core : Identity
- Recursos de provedors externos
- Identity Server, OpenId e JWT - Json Web Tokens
- Esquema de autenticação : Anônimo, Basic, Tokens(Bearer)
- Autenticação baseada em Tokens - Bearer Autentication

2a. Autenticação JSON Web Token - 6:12 min.
- Apresentando JSON Web Tokens
- JWT - conceitos
- Composição : header, payload e signature
- Gerando o token de autenticação
- Vantagens da autenticação JWT
- Processo de autenticação via Json Web Tokens
- Etapas do processo de autenticação JWT

3a. JWT - Habilitando o Identity - 4:56 min.
- Implementando a autenticação JWT
- Habilitando o Identity, gerando as tabelas via Migrations
- Tabelas geradas pelo Identity
- Configurando o Identity no Projeto
- Incluindo o middleware de Autenticação e Autorização

4a. Implementando o JWT no projeto - 5:53 min.
- Alterando a classe de Contexto: Herdar de IdentityDbContext
- Usando o Microsoft.AspNetCore.Identity.EntityFrameworkCore
- Habilitando o Identity no projeto no m´teodo ConfigureServices
- Incluindo os middlewares de autenticação e autorização
- Ajustando a entidade Produto
- Aplicando o Migrations e Gerando as tabelas no MySql

5a. Criando o Controlador para Login e Registro - 11:25 min.
- Criando o controlador AutorizaController
- Definindo os métodos Action : Get, RegisterUser e Login
- Criando o método GeraToken - gerar o token Jwt
- Definindo o modelo de domínio UsuarioDTO
- Usando as classes UserManager e SignInManager
- Testando o Login e Register no Postman

6a. Gerando o Token JWT - 12:13 min.
- Gerando o token para autenticação
- Usando o pacote System.IdentityModel.Tokens.Jwt
- Definindo as configurações das Claims:
- Issuer, Audience e Expires
- Definir a chave secreta no arquivo appsettings.json
- Definindo a classe UsuarioToken
- Gerando o token e retornando: o token e data de expiração
- Definindo a validação do Token no método ConfigureServices
- Fluxo da requisição com autenticação e envio do token

7a. Testando a autenticação JWT - 7:25 min.
- Restrigindo o acesso usando o atributo Authorize
- Restrigindo o acesso ao controlador CategoriasController
- Fazendo login usando um usuário válido
- Obtendo o token gerado
- Validando o token
- Enviando o token com header das requisições
- Usando o Postman para testar a autenticação

8a. Apresentando CORS - 4:20 min.
- Entendendo CORS e politica de mesma origem
- O que a politica de mesma origem
- Definindo CORS - Cross Origen Resource Sharing
- Habilitar o CORS via Microsoft.AspNetCore.Cors no projeto
- Definir a politica CORS
- Habilitando o CORS : usando middleware ou atributos

9a. Habilitando o CORS - 4:21 min.
- Habilitando o CORS via middleware
- Adicionar serviços CORS e definir politica usando middleware
- Politicas CORS : WithOrigins, WithMethods, WithHeaders
- Habilitar o CORS via atributo
- Incluir o serviço CORS e definir a política CORS : AddPolicy
- Usar o atributo [EnableCors('nome_politica')] no Controlador

10a. Implementando o CORS no projeto API - 9:31 min.
- Verificando o problema do CORS usando : apirequest.io
- Incluindo o serviço CORS no método ConfigureServices
- Habilitando e definindo a politica CORS no método Configure
- Definindo o atributo [EnableCors] no Controller
- Testando a politica CORS usando o cliente apirequest.io

Módulo7 - Documentação e Testes : 11 Aulas - 1 hora e 42 minutos

1a. Versionamento - 7:24 min.
- Apresentando o conceito de versionamento
- Por que versionar ?
- Versionamento de Web APIs
- Versionamento na ASP .NET Core
- Pacote Nuget : Microsoft.AspNetCore.Mvc.Versioning
- Configuração do versionamento em ConfigureServices
- Documentação Swagger
- Aplicando o versionamento nos Controladores

2a. Implementando o versionamento no projeto - 18:08 min.
- Versionamento da API na versão 2.2 da ASP .NET Core
- Incluindo o pacote Microsoft.AspNetCore.Mvc.Versioning
- Definindo a configuração do Versionamento : ConfigureServices()
- Aplicando o versionamento nas Web APIs

3a. Gerando a documentação da API : Swagger - 5:54 min.
- Gerando a documentação da API com Swagger /OpenAPI
- Swagger : automatiza a documentação de uma Web API
- Permite : modelar, descrever, consumir e visualizar a API
- Usando o pacote Nuget : Swashbuckle.AspNetCore V 5.0.0-rc2
- Registrar o gerador Swagger em ConfigureServices
- Habilitar o middleware para servir o documento JSON
- Navegar para : https://localhost:xxx/swagger/v1/swagger.json
- Documentação : https://localhost:xxx/swagger

4a. Implementando o Swagger no projeto - 6:40 min.
- Implementando a documentação com Swagger no projeto
- Incluindo o pacote Swashbuckle.AspNetCore V 5.0.0-rc2
- Registrar o gerador Swagger e configurar o documento
- Habilitar o middleware do Swagger
- Acessando a documentação e consultando a API
- Acessando os endpoints da Web API via documentação

5a. Swagger - Exibindo comentários XML - 7:16 min.
- Lendo os comentários dos métodos Actions
- Marcar a opção XML Documentation File
- Incluir o método IncludeXmlComments em ConfigureServices
- Definir os comentários nos métodos Actions
- Usando as tags : <summary> e <remarks>
- Testando a documentação e verificando os comentários

6a. Ajustando o Swagger - 4:54 min.
- Removendo os alertas devido aos comentáriois
- Ajustando o arquivo de projeto .csproj
- Definindo o retorno padrão da API : Json
- Definir a anotação via atributo : [Produces("application/json")]

7a. Convenções e Analisadores - 15:42 min.
- Definindo os tipos de retornos das Actions
- Usando os analizadores da Web API
- Melhorando a documentação Swagger
- Usando o atributo [ProducesResponseType]
- Usando as convenções : ApiConventionMethod
- Usando os analizadores para identificar ações não documentadas
- Pacote Nuget : Microsoft.AspNetCore.Mvc.Api.Analyzers

8a. Swagger : Habilitando a Autenticação - 6:10 min.
- Acessando a documentação via Swagger usando autenticação
- Aplicando o recurso na versão 2.2 da ASP .NET Core
- Habilitar a autenticação via Swagger em ConfigureServices
- Fazendo a implementação no projeto
- Acessando a API protegida via Swagger usando a autenticação

9a. Testes de Software e xUnit- 12:40 min.
- Testes de Software e testes unitários : Conceitos
- Objetivos, processo de teste e plano de teste
- Principais tipos de testes
- Testes unitários - conceitos
- Ferramentas : xUnit, NUnit e MSTeste
- Usando o xUnit para realizar testes unitários com xUnit
- Conceitos : [Fact] , etapas: Arrange, Act e Assert
- Usando FluentAssertions via Nuget
- Planos de Teste para CategoriasController

10a. Testes Unitários com xUnit - I - 8:53 min.
- Realizando testes unitários para CategoriasController
- Casos de teste e documentação
- Criando um projeto de Testes Unitários com xUnit
- Referenciando o projeto ApiCatalogo
- Criando a classe para popular os dados de testes
- Preparando a classe de Testes Unitários

11a. Realizando Testes Unitários - 14:37 min.
- Definindo o código para testes unitários
- Casos de testes para testar os métodos de CategoriasController
- Casos de teste para Get, Get(id), Post(object)
- Casos de teste para Put(id,Object) e Delete(id)
- Usando o Test Explorer do Visual Studio
- Executando os testes unitários

Módulo8 - Consumindo a Web API - 5 Projetos com 11 vídeo aulas - 1 hora e 40 minutos

1a. Consumindo a Web API com Windows Forms 13:28 min.
- Consumindo a APICatalogo em uma aplicação Windows Forms
- Criar Formulário com Buttons, DataGridView e TextBox
- Acessando a Web API ProdutosController
- Realizando a autenticação e obtendo o token
- Definir o endpoint para acessar os recursos : api/produtos
- Enviando requisições para a API : GET, POST, PUT e DELETE
- Definindo as entidades Produto e AccessToken
- Aquivo App.Config : UrlBase, UserID e AccessKey
- Definindo a classe AcessaAPIService
- Usando a classe HttpClient e os métodos assíncronos

2a. Consumindo a Web API com Angular 7 - I - 18:24 min.
- Consumindo a Web API em uma aplicação Angular 7
- Angular 7.0, Angular CLI, Material, Cdk, npm, VS Code
- Criando o projeto e gerando os componentes
- ng g generate component
- Estrutura do projeto
- Criando os links para Categoria e Categoria Nova
- Executando testando a aplicação inicial

3a. Consumindo a Web API com Angular 7 - II - 7:48 min.
- Instalando o Angular Material e Cdk
- Registrar os componentes do Angular Material: app.module.ts
- Usar o Schematics e criar componentes do menu de navegação
- Inserindo o componente <app-menu> no leiaute padrão
- Incluindo os links para os itens do menu
- Definir o estilo básico em menu.component.scss
- Compilar e executar

4a. Consumindo a Web API com Angular 7 - III - 8:34 min.
- Criando o serviço para acessar a Web API na pasta src
- Criar a pasta model em src
- Definir as classes categoria e usúario
- Gerar o serviço : ng generate service services
- Criando os métodos da ApiService para acessar a API
- Definindo o método montaHeaderToken para obter o token

5a. Consumindo a Web API com Angular 7 - IV - 6:29 min.
- Definindo o código de cada componente da aplicação
- Definindo o código da lógica do componente
- Definindo o código da interface do componente
- Injetando o serviço ApiService em cada componente
- Obtendo o token e armazenando no local storage
- Definindo a navegação em cada componente

6a. Consumindo a Web API com Angular 7 - V - 8:29 min.
- Consumindo a Web API
- Habilitando a politca CORS na Web API
- Protegendo a API CategoriasController
- Iniciando o projeto Web API - ApiCatalogo
- Testando os métodos de acesso a API na aplicação Angular
- Fazendo o login e obtendo o token
- Fazendo o CRUD básico

7a. Paginação de dados na Web API - 12:39 min.
- Realizando a paginação de dados
- Apresentando a paginação de dados
- Paginando com QueryString e os métodos skip e take
- Ajustando a interface e a classe Repository
- Definindo e implementando o método LocalizaPagina
- Criando um método Action [HttpGet('paginacao')
- Passando o número da página e a quantidade de registros
- Acessando a paginação via QueryString
- Informando o total de registros e número de páginas no Header

8a. Implementando Consultas OData I - 5:01 min.
- Apresentando o OData - Open Data Protocol
- Usando o projeto na versão 2.2 da ASP .NET Core
- Convenções da URL OData - consultas flexíveis
- Url raiz , caminho do recurso e opções de consulta
- Opções de consulta: $select, $orderby, $search, $format, $count
- Usando o pacote Microsoft.AspNetCore.OData
- Registrando o serviço : services.AddOData
- Habilitar injeção de dependência e habilitar opções de consulta
- Usando o atributo [EnableQuery] no controlador

9a. Implementando Consultas OData II - 7:31 min.
- Implementando o OData no projeto APICatalogo
- Permitindo consultas flexíveis
- Instalando o pacote Microsoft.AspNetCore.OData
- Definindo as opções de consulta
- $Select, $Count, $OrderBy e Filter()
- Definindo o atributo [EnableQuery} em ProdutosController
- Realizando consultas com os recursos do OData

10a. Apresentando GraphQL - 6:15 min.
- Apresentando o conceitos básicos do GraphQL
- O que é o GraphQL
- Consultas GraphQL
- Comparando GraphQL com REST
- As vantagend do GraphQL
- Conceitos do ecosistema GraphQL
- Schema, Types, Query, Mutations e Resolver
- Integrando o GraphQL com ASP .NET Core
- Criando o endpoint graphql no projeto APICatalogo
- Usando pacote Nuget : GraphQL

11a. Implementando GraphQL - 10:53 min.
- Implementando o GraphQL no projeto APICatalogo
- Incluir o pacote GraphQL no projeto APICatalogo
- Criar a classe CategoriaType : definir entidade mapeada p/o Type
- Criar a classe CategoriaQuery : mapear campos para consultas
- Definindo a consulta para retornar todas as categorias
- Definindo a consulta para retornar a categoria pelo id
- Usando a referência ao IUnitOfWork
- Criar a classe TesteGraphQLMiddleware
- Incluindo o middleware no pipeline do request
- Processando a requisição http usando instãncia do repositório
- Testando a implementação no Postman

Módulo9 - Deploy : 2 Aulas - 24 minutos

1a. Deploy - 10:13 min.

- Implantação e hospedagem
- Publicando a aplicação no servidor
- Ambiente de produção,homologação e produção
- Opções de implantação : Debug e Release
- Opções de build : Dependente de framework e Auto-Contida
- Vatangens/Desvantagens do deploy dependente de framework
- Vantagens/Desvantagens do deploy Auto-Contido
- Fazendo a publicação da aplicação APICatalogo

2a. Deploys no IIS - 14:12 min.

- Fazendo o deploy da aplicação e hospedando no IIS
- O servidor de aplicativos IIS - Internet Information Service
- Os conceitos de out-of-process e in-process
- Configurando os serviços World Wide Web
- Configurando o Console de gerenciamento IIS
- Usando o .NET Core Windows Server Hosting
- Referenciando o IIS Integration : UseIISIntegration
- Criando o arquivo web.config na raiz do projeto
- Configurando o module Asp .NET Core
- Fazendo o Publish do projeto APICatalogo
- Usando o Gerenciador de serviços
- Adicionando o site de teste e definindo o caminho físico
- Configurando o Pool de aplicativos
- Testando o deploy no IIS