Introdução 

• Apresentação Visualizar 00:37
• A plataforma .NET 10:11
• A linguagem C# 07:26
• C# – Características 09:52
• Organização do código 08:43
• IDE – Ambiente de desenvolvimento 08:57
• Versões do .NET Visualizar 07:06
• Visual Studio – Instalação 09:40
• Visual Studio Code – Instalação 05:49
• Visual Studio – Templates de projeto Visualizar 05:26
• Estrutura do projeto 09:11
• Visual Studio Code – Projetos 10:37
• Projeto – Configurações 12:17
• Projeto Console – Análise de código 10:27
• Como escolher a versão do SDK .NET 08:47
• .NET CLI – Escolhendo a versão do .NET SDK 06:30

Fundamentos 

• Apresentação 04:19
• Tipos de dados 07:11
• Tipos numéricos integrais 11:09
• Tipos números de ponto flutuante 08:28
• Tipos não numéricos : bool e char 08:22
• Tipos de referência 07:24
• Tratamento de data e hora : DateTime 10:37
• Nullable Types Visualizar 14:06
• Nomenclatura : convenções 09:18
• Exercícios – fase 1 00:14
• Formatar a saída de dados 09:58
• Formatação – Seqüência de Escapes 08:21
• Conversão de tipos I 11:08
• Conversão de tipos II 09:01
• Entrada de dados 10:41
• Operadores aritméticos e classe Math 09:39
• Inferência de tipos 09:27
• Operadores de atribuição 10:45
• Constantes 07:54
• Operadores de incremento e decremento 10:32
• Operadores relacionais Visualizar 09:24
• Operadores Lógicos 08:44
• Precedência e associatividade de operadores 13:16
• Nullable Reference Types 10:37
• Operador Ternário 11:25
• Exercícios – fase 2 00:14
• Projetos das aulas e respostas do exercícios 00:18

Estruturas de Controle 

• Apresentação 00:59
• Instrução if Visualizar 11:33
• Instrução if-else 08:28
• Instrucao if-else-if 10:24
• Instrução switch I 12:45
• Instrução switch II 12:54
• Estrutura de repetição 06:59
• Instrução while I 09:35
• Instrução while II 09:20
• Instrução do while 10:23
• Instrução for I 12:16
• Instrução for II 08:21
• Instruções break e continue 13:11
• Lista de exercícios 07:24
• Projeto das Aulas e respostas dos exercícios 00:18

Classes e Métodos 

• Classe e Objeto Visualizar 09:46
• Alocação de Memória 07:02
• O que é um objeto 04:51
• Métodos 11:44
• Métodos com parâmetros 08:59
• Passando parâmetros 10:49
• Construtor I 11:09
• Construtor II 06:23
• Palavra this 09:54
• Exercício Prático I 00:14
• Métodos com retorno 06:34
• Exercício Pratico II 00:14
• Sobrecarga de métodos 08:36
• Exemplo prático 10:30
• Passando argumentos por valor 08:28
• Passando argumentos por referência – ref 04:42
• Exercício Prático III 00:14
• Passando argumentos por referência – out 10:00
• Exercício Prático IV 00:14
• Argumentos nomeados 09:32
• Parâmetros opcionais 07:44
• Exercício Prático V 00:14
• Métodos estáticos 07:45
• Campos estáticos I 06:35
• Exercício – Campos estáticos 07:24
• Exercício Prático VI 00:14
• Construtor estático 10:11
• Propriedades 07:10
• Exercício – Propriedades 13:29
• Exercício Prático VII 00:14
• Structs Visualizar 10:05
• Exercício Prático VIII 00:14
• Enum 06:51
• Exemplo – Enum 11:08
• Exercício Prático IX 00:14
• Modificadores de acesso 10:42
• Exercício Prático X 00:14
• Bloco try-catch 12:54
• Tipos Anônimos 08:08
• Exercícios Teóricos 00:14
• Partial Class 11:09
• Projeto das Aulas e respostas dos exercícios 00:18

Array, ArrayList e List 

• Apresentação 02:13
• Arrays I 12:44
• Arrays II 06:16
• Arrays III 06:48
• Classe Array 07:56
• Exercício – Arrays 12:37
• Modificador params Visualizar 10:38
• Arrays Multidimensionais I 12:16
• Arrays Multidimensionais II 09:02
• Exercício – Arrays Bidimensionais 09:30
• ArrayList I 13:27
• ArrayList II 09:43
• ArrayList III 07:18
• ArrayList IV 09:16
• Coleção List<T> I 10:32
• Coleção List<T> II 22:18
• List e ArrayList 10:20
• List – Métodos Find 11:42
• List – Métodos Find – Expressões Lambdas 06:15
• List e IEnumerable Visualizar 12:24
• Exercício – List<T> 20:28
• Indexadores 10:52
• Classe Random 11:01
• Exercícios Propostos 00:14
• Projeto das Aulas e Projeto com a solução dos exercícios 00:18

Programação Orientada a Objetos 

• Os pilares das Programação Orientada a Objetos Visualizar 16:28
• Herança – Conceito e Sintaxe 11:24
• Herança – Comportamentos 08:00
• Herança – Construtores 05:59
• Herança e Object 04:01
• Herança e new 04:02
• Herança – virtual e override 07:14
• Modificador sealed 07:37
• Exercício – Herança 21:57
• Tipos de Herança 13:57
• Downcasting e Upcasting 10:42
• Operador is e as Visualizar 12:29
• Classe Abstrata I 06:18
• Classe Abstrata II 07:31
• Interfaces 12:24
• Exercício – Interfaces 09:21
• Composição 08:41
• Agregação 10:31
• Exemplo – Herança e Composição 12:09
• Polimorfismo 06:53
• Exemplo – Polimorfismo 08:11
• Exercícios Propostos 00:14
• Projeto das aulas e respostas dos exercícios 00:18

Generics e Coleções Genéricas 

• Generics – Introdução Visualizar 07:00
• Generics II 09:47
• Generics III 05:56
• Exercício – Generics 10:06
• GetHashCode e Equals 09:12
• Exemplo GetHashCode 06:54
• Comparação : Coleções genéricas e não genéricas 04:48
• Coleção Dictionary<TKey,TValue> 07:38
• Dictionary II 13:28
• Exercício – Dictionary 16:51
• Coleção SortedDictionary<Tkey,TValue> 05:20
• SortedDictionary II 07:58
• Coleções Set 10:35
• HashSet<T> II 17:21
• SortedSet<T> 06:12
• Stack<T> 12:55
• Stack II – undo 05:43
• Queue<T> 16:40
• ReadOnlyCollection<T> 17:31
• Exercícios Propostos 00:14
• Projeto das Aulas e Respostas dos exercícios 00:18

Tratamento de Erros 

• Conceitos – Tratamento de exceções 09:19
• Bloco try-catch-finally 13:06
• Lançando exceções – throw 12:03
• Filtro de exceções 10:12
• Exercício – Tratamento de exceções 17:53
• Exceções personalizadas 14:10
• Exercícios Propostos 00:14
• Projeto das Aulas e respostas dos exercícios 00:18

Delegates, Expressão Lambda, Eventos e LINQ 

• Delegates Visualizar 13:20
• Delegate Multicast 08:25
• Métodos Anônimos 07:25
• Expressões lambdas 06:05
• Delegate Predicate 08:06
• Delegate Action 05:35
• Delegate Function 07:35
• Exercício – Delegate 13:56
• Eventos 10:48
• EventHandler 05:26
• EventHandler<TEventArgs> 05:42
• Métodos de extensão 09:31
• LINQ I 08:26
• LINQ II 12:20
• Consultas LINQ I 17:48
• Consultas LINQ II 11:06
• Consultas LINQ III 08:51
• Exercícios Propostos 00:14
• Projeto das aulas e respostas dos exercícios 00:18

Arquivos, Diretórios e Streams 

• Classe File 06:16
• File II 13:59
• Classe FileInfo 09:08
• Classes Directory e DirectoryInfo 13:22
• DirectoryInfo II 07:59
• Classe Path 12:41
• Streams – FileStream, StreamReader e StreamWriter Visualizar 11:51
• Exercício – FileStream, StreamReader 07:33
• Streams – bloco using 04:47
• Exercício – Streams 10:32
• Exercício – Streams II 09:24
• Exercícios Propostos 00:14
• Projeto das aulas e respostas dos exercícios 00:18

Serialização e Desserialização 

• Conceitos Visualizar 04:33
• Serialização e Desserialização binária 10:20
• Serialização XML 06:14
• Desserialização XML 03:45
• Serialização JSON 04:37
• Desserialização JSON 05:17
• Exercícios 01:10
• Projetos da seção 00:18

Programação Assíncrona 

• Programação assíncrona e paralela Visualizar 09:09
• Programação assíncrona – Task e Task<T> 11:58
• ValueTask e ValueTask<T> 08:57
• Cancelamento de tarefas 17:18
• Tratamento de exceções 08:34
• Múltiplas exceções 08:57
• Recomendações 05:23
• Exercício – Programação assíncrona 17:25
• Streams assíncronos Visualizar 09:46
• Controlando threads com semáforos 11:28
• Exercícios Propostos 00:14
• Projeto das aulas e respostas dos exercícios 00:18

CORTESIA – LINQ 

• Apresentando os fundamentos 14:15
• Consultas LINQ 20:41
• Operadores de projeção 19:40
• Operações com Conjuntos I 20:35
• Operações com Conjuntos II 18:47
• Operadores de Ordenação 16:12
• Operadores de Agregação I 18:40
• Operadores de Agregação II 19:14
• Operadores de Quantificação 22:54
• Operadores de Agrupamento 16:07
• Operações de Junção I 15:42
• Operações de Junção II 14:17
• Operadores de Elemento I 20:44
• Operadores de Elemento II 19:50
• Operadores de Conversão 21:25
• Operadores de Particionamento 27:17
• Paginação com Skip e Take 14:42
• Operadores de Geração 12:47
• Métodos Append<T>, Prepend<T> e Zip 12:09
• Operadores de Conversão 14:10

Atualizações do C# – Recursos das novas versões do C# 

• Apresentação 00:46
• C# 12 – Apresentando os novos recursos Visualizar 14:58
• C# 12 – Apresentando os construtores primários 09:19
• C# 11 – Apresentando os novos recursos – II 18:50
• C# 11 – Apresentando os novos recursos – I Visualizar 19:20
• C# 10 – Apresentando 5 novos recursos 11:44
• C# 10 – Apresentando DateOnly Visualizar 19:11
• C# 10 – Apresentando TimeOnly 19:05
• C# 10 – Novos recursos das expressões lambdas 12:20
• C# 10 – Apresentando Global Using e Implicit Using 12:12
• C# 9.0 – Apresentando Records – I Visualizar 12:32
• C# 9.0 – Apresentando Records – II 10:53
• C# 9.0 – Utilizando Records – III 07:56
• C# 9.0 – Init-Only Properties : Criando propriedades imutáveis 08:00
• C# 9.0 – Top Level Statements Visualizar 07:51

.NET 8 – Conceitos Gerais 

• Introdução Visualizar 03:20
• Conceitos: API, Web Services e Web API 08:44
• Conceitos: SOAP, REST e ASP.NET Core Web API 07:43
• REST 08:14
• HTTP 05:49
• Métodos HTTP 06:51
• Https e Hsts 02:42
• JSON 12:29
• Níveis de maturidade de Richardson Visualizar 07:11
• Injeção de dependência Visualizar 13:05
• Tempo de vida dos serviços Visualizar 11:46
• Entrevista Web API – Perguntas e Respostas 00:00

.NET 8 – Ambiente e Recursos 

• Apresentação 01:36
• Ambiente Visualizar 03:54
• .NET 8.0 – Instalação 04:15
• Visual Studio – Instalação 05:39
• VS Code – Instalação 04:04
• MySQL – Instalação 10:03
• Criando a primeira Web API Visualizar 08:51
• Primeira Web API – Estrutura 12:23
• Primeira Web API – Controlador 09:12
• Criando a primeira Minimal API 08:39
• Criando APIs com VS Code e o .NET CLI 11:49

.NET 8 – Criando uma Web API usando o Visual Studio 

• Apresentação 03:04
• Visão geral: projeto, escopo e nomenclatura Visualizar 11:31
• Criando o projeto Web API 10:19
• Criando o modelo de domínio 06:21
• Configurando o projeto para usar o EF Core 09:38
• Criando a classe de contexto do EF Core 06:09
• Registrando os serviços no container DI 06:49
• Definindo o relacionamento entre as entidades 07:09
• Apresentando o EF Core Migrations 04:46
• Aplicando o Migrations 07:54
• Apresentando o Data Annotations 07:26
• Aplicando o Data Annotations 07:37
• Populando as tabelas com dados iniciais – Conceito 05:22
• Populando a tabela Categorias 05:01
• Populando a tabela Produtos 04:49
• Criando os Controllers 11:22
• Criando o controlador ProdutosController 08:20
• ProdutosController – GET 07:10
• ProdutosController – GET por ID 04:23
• ProdutosController – POST 06:53
• ProdutosController – PUT 05:41
• ProdutosController – DELETE 04:39
• Criando o Controlador CategoriasController 09:51
• Ajustes e Otimizações – Serialização JSON 09:32
• Otimizando o código da API 04:10
• Tratamento de erros com bloco try-catch 10:57
• Apresentando o Postman 10:17

.NET 8 – Fundamentos da WEB API 

• Apresentação 01:03
• Roteamento 10:30
• Padrões de roteamento 10:19
• Restrição de rotas 08:44
• Tipos de Retorno 07:36
• Métodos Actions Assíncronos 08:16
• Model Binding 10:27
• Atributo [FromServices] 10:04
• Usando Data Annotations 10:02
• Validação Personalizada – I Visualizar 06:47
• Validação Personalizada – II 04:15
• Modelo de Configuração 08:02
• Lendo o arquivo de configurações 08:49
• Apresentando Middleware 08:23
• Middleware – Realizando o tratamento global de exceções 10:39
• Filtros – Conceito Visualizar 04:51
• Criando filtros personalizados 09:56
• Logging – Conceito 09:31
• Criando um log customizado 11:27
• Otimizando o código do projeto 11:47

.NET 8 – Padrão Repository e Unit Of Work 

• Apresentação 00:30
• Apresentando o padrão Repository Visualizar 05:54
• Implementando o repositório específico – I 12:55
• Implementando o repositório específico para Categorias 13:24
• Ajustando o código do controlador CategoriasController 08:42
• Testando o controlador CategoriasController 07:15
• Implementando o repositório para Produtos – I 10:45
• Implementação do repositório para Produtos – II 10:15
• Ajustando o código do controlador ProdutosController 08:02
• Testando o controlador ProdutosController 09:54
• Apresentando o Repositório Genérico 10:18
• Implementando o Repositório Genérico 07:43
• Implementando o Repositório Genérico – II 08:25
• Implementando o Repositório Genérico – III 08:21
• Ajustando os controladores 09:24
• Testando os Controladores 09:02
• Apresentando o padrão Unit Of Work Visualizar 09:21
• Implementando o padrão Unit Of Work 05:34
• Implementando o padrão Unit Of Work – II 08:33
• Ajustando as classes dos Repositórios 03:50
• Ajustando os Controladores 05:44
• Testando os Controladores 07:07

.NET 8 – DTO, AutoMapper e HttpPatch 

• Apresentação Visualizar 00:20
• Apresentando Data Transfer Object – DTO 12:02
• DTO – Mapeamento manual – CategoriaDTO 11:32
• DTO – Usando métodos de extensão 07:27
• DTO – Aplicando os métodos de extensão 04:29
• Apresentando o AutoMapper 05:03
• DTO – Fazendo o mapeamento usando o AutoMapper – I 08:55
• DTO – Fazendo o mapeamento usando o AutoMapper – II 06:42
• Testando os mapeamentos 04:02
• HttpPatch – Realizando a atualização parcial 10:08
• HttpPatch – Implementação 17:05

.NET 8 – Paginação, Filtro e Ordenação 

• Paginação de dados – Conceitos Visualizar 10:37
• Implementando a paginação 08:20
• Incrementando a paginação: Roteiro 09:15
• Incrementando a paginação: Implementação 07:29
• Paginação para Categorias – Roteiro 05:05
• Paginação para Categorias – Implementação 08:59
• Filtrando dados – Conceitos 07:35
• Implementando um Filtro para Produtos 08:55
• Implementando um Filtro para Categorias 08:53

.NET 8 – Programação Assíncrona: Repositório e Paginação 

• Programação Assíncrona com async e await Visualizar 09:28
• Usando a programação assíncrona 07:58
• Migrando o código Síncrono para Assíncrono – I 08:04
• Migrando o código Sincrono para Assíncrono – II 09:04
• Migrando o código Síncrono para Assíncrono – III 06:17
• Implementando a Paginação Assíncrona – I 05:19
• Implementando a Paginação Assíncrona – II 06:26

.NET 8 – Segurança: Autenticação, Autorização e Token JWT 

• Autenticação e Autorização Visualizar 03:56
• Apresentando Json Web Tokens – JWT 07:08
• Gerenciando tokens JWT no ambiente de desenvolvimento 09:50
• Roteiro para usar o Identity e gerar as tabelas 05:00
• Configurando o Identity e gerando as tabelas 11:30
• Implementando a autenticação JWT Bearer – I 12:27
• Implementando a autenticação JWT Bearer – II 05:15
• Implementando a autenticação JWT Bearer – III 03:49
• Criando o serviço para gerar o Token JWT 05:48
• Implementando a geração do Token JWT 06:22
• Implementando a geração do Refresh Token – I 03:19
• Implementando a geração do Refresh Token – II 04:32
• Criando o controlador AuthController para consumir o serviço 04:07
• AuthController – Login 10:42
• AuthController – Register 02:58
• AuthController – RefreshToken Visualizar 06:19
• AuthController – Revoke 03:08
• Testando a implementação do token JWT – I 05:48
• Testando a implementação do token JWT – II 06:36
• Autorização baseada em políticas com JWT 07:08
• Autorização baseada em políticas com JWT – criando um perfil (Role) 03:57
• Autorização baseada em políticas com JWT – Adicionando um usuário ao perfil 05:03
• Configurando e aplicando políticas de autorização com token JWT 04:55
• Configurando as políticas de autorização 09:23
• Aplicando as políticas de autorização 06:19
• Autenticação usando o manipulador Bearer Token 06:03
• Usando o manipulador Bearer Token 07:23

.NET 8 – Segurança: CORS e Rate Limiting 

• Apresentando CORS – Cross-Origin Resource Sharing Visualizar 08:15
• Habilitando e criando políticas CORS 07:04
• CORS – Opções de configuração 07:04
• Habilitando o CORS: {EnableCors] 06:07
• Testando a implementação CORS 08:41
• Apresentando Rate Limiting (Limitação de taxa) 04:14
• Algoritmos de limitação de taxa 07:48
• Configurando e aplicando Rate Limiting – I 07:26
• Configurando e aplicando Rate Limiting – II 02:51
• Configurando e aplicando Rate Limiting globalmente 04:19
• Configurando Rate Limiting usando o arquivo appsettings.json 06:20

.NET 8 – Versionamento da API 

• Versionamento – Conceitos 07:19
• Versionamento: Abordagens e Configuração 07:44
• Versionamento da API: Exemplos 05:00
• Versionamento da API usando Query String 11:02
• Versionamento da API usando URI 07:03
• Versionamento da API: Atributo MapToVersion 05:15

.NET 8 – Documentação: Swagger, Convenções e Analisadores 

• Gerando a documentação com OpenAPI – Swagger 06:57
• Explorando a documentação gerada pela OpenAPI 09:45
• Habilitar a exibição de comentários XML – I 04:48
• Habilitar a exibição de comentários XML – II 07:45
• Ajustando e melhorando a documentação do Swagger 09:26
• Usando as convenções da Web API 08:10
• Usando os analisadores de API 05:19

.NET 8 – Testes de Unidade 

• Teste de Software – Conceitos 12:42
• Criando e configurando o projeto de testes com xUnit 08:48
• Criando as classes para realizar os testes de unidade 10:20
• Testes Unitários: Testando os métodos Get 10:21
• Testes Unitários: Testando os métodos Post 06:28
• Testes Unitários: Testando os métodos Put 04:34
• Testes Unitários: Testando os métodos Delete 05:32

.NET 8 – Usando a Clean Architecture 

• Criando uma API usando a Clean Architecture Visualizar 10:42
• Criando uma API usando a Clean Architecture – Estrutura do projeto 09:20
• Criando uma API usando a Clean Architecture – Criando as pastas no projeto 07:36
• Criando uma API usando a Clean Architecture – Implementação 11:24
• Criando uma API usando a Clean Architecture – Ajustes do projeto 05:03

.NET 8 – Hospedagem e Deploy 

• Hospedagem e Deploy – Conceitos 15:36
• Deploy no IIS – Internet Information Services 14:05
• Realizando um Web Deploy 15:29

.NET 8 – Usando HttpClientFactory 

• Apresentação 00:44
• HttpClientFactory – Conceitos e utilização Visualizar 09:09
• Definindo a API e criando e configurando o projeto MVC 10:52
• Criando o serviço para consumir a API – I 08:53
• Criando o serviço para consumir a API – II 09:01
• Criando o Controlador e as Views no projeto MVC 09:28
• Consumindo a API – Criando uma nova Categoria 08:13
• Consumindo a API – Alterando uma Categoria 08:45
• Consumindo a API – Excluindo uma Categoria 09:04
• Consumindo os endpoints protegidos da API (ProdutosController) 05:38
• Implementando a autenticação no projeto MVC 10:02
• Criando o controlador AccountController 13:05
• Criando o serviço para consumir os endpoints da API 06:02
• Implementando o serviço para consumir os endpoints da API 08:52
• Criando o controlador ProdutosController e usando o serviço 09:59
• Consumindo a API – Criando um novo Produto 05:18
• Consumindo a API – Exibindo detalhes de um produto 06:13
• Consumindo a API – Alterando os dados de um produto 07:55
• Consumindo a API – Excluindo um produto 06:43

.NET 8 – Consumindo Web APIs 

• Consumindo a API usando Windows Forms 13:28
• Consumindo uma API usando Angular – I 18:24
• Consumindo uma API usando Angular – II 07:48
• Consumindo uma API usando Angular – III 08:35
• Consumindo uma API usando Angular – IV 06:31
• Consumindo uma API usando Angular – V 08:29
• Consumindo uma API usando GraphQL 21:32

.NET 8 – Criando Minimal APIs no VS 2022 

• Roteiro para criar uma Web API usando o recurso Minimal API Visualizar 04:31
• Criando a minimal API – ApiTarefas – I 06:16
• Criando a minimal API – ApiTarefas – II 09:37
• Criando a minimal API – ApiTarefas – III 06:58
• Criando a minimal API – ApiTarefas – IV 08:05
• Criando uma Minimal API usando o Dapper – I 10:13
• Criando uma Minimal API usando o Dapper – II 09:08
• Criando uma Minimal API usando o Dapper – III 08:10
• Criando uma Minimal API usando o Dapper – IV 08:58

.NET 8 – Organizando o código em uma Miminal API 

• Introdução 04:03
• Criando o projeto Web API na abordagem das Minimal APIs 08:47
• Definindo as dependências no projeto 05:58
• Definindo o modelo de domínio 03:42
• Criando a classe de Contexto 04:17
• Apresentando a Fluent API 06:00
• Usando a Fluent API para configurar as entidades 04:47
• Definindo a string de conexão e registrando o contexto 05:48
• Aplicando o Migations do EF Core 07:08
• Criando os endpoints da API 08:09
• Criando o endpoint para criar uma nova Categoria – Post 10:53
• Criando o endpoint para retornar Categorias – Get 06:04
• Criando um endpoint para atualizar uma Categoria – Put 06:33
• Criando um endpoint para excluir uma Categoria – Delete 04:59
• Criando os endpoints para Produtos 11:18
• Roteiro para Implementar a autenticação JWT 07:49
• Implementando a autenticação JWT 11:32
• Testando a implementação da autenticação JWT 11:05
• Organizando o código da Minimal API – I 09:36
• Organizando o código da Minimal API – II 06:44
• Organizando o código da Minimal API – III 07:42
• Organizando o código da Minimal API – IV 07:59

.NET 8 – Minimal APIs novos recursos 

• Novos Recursos das Minimal APIs (.NET 7) Visualizar 16:27
• Minimal APIs – .NET 8 25:15

BÔNUS – Consumindo uma API com React 18 aulas • 5h 14m

• Criando a Web API – AlunosApi – I Visualizar 20:02
• Criando a Web API – AlunosApi – II 15:58
• Criando a Web API – AlunosApi – III 30:47
• Criando a Aplicação React alunosreact – I 16:15
• Criando a Aplicação React alunosreact – II 20:29
• Criando a Aplicação React alunosreact – III 15:22
• Criando a Aplicação React alunosreact – IV 13:53
• Criando a Aplicação React alunosreact – V 14:26
• Implementando a autenticação JWT na API AlunosApi – I 19:24
• Implementando a autenticação JWT na API AlunosApi – II 16:41
• Implementando a autenticação JWT na API AlunosApi – III 18:00
• Criando a aplicação React clientereact – I 16:55
• Criando a aplicação React clientereact – II 18:40
• Criando a aplicação React clientereact – III 15:26
• Criando a aplicação React clientereact – IV 13:40
• Criando a aplicação React clientereact – V 14:06
• Criando a aplicação React clientereact – VI 17:50
• Criando a aplicação React clientereact – VII 15:58

BÔNUS – Criando uma loja virtual com Microsserviços 20 aulas • 7h 58m

• Apresentação 01:14
• Criando o projeto no Visual Studio Visualizar 23:51
• Sobrescrevendo as convenções e aplicando o Migrations 22:57
• Definindo os DTOs e os repositórios para o microsserviço ProductApi 27:21
• Criando os serviços e controllers para ProductApi 27:47
• Criando a aplicação para consumir o microsserviço ProductApi 29:02
• Iniciando a aplicação para consumir o microsserviço ProductApi 35:08
• Concluindo a aplicação para consumir o microserviço ProductApi 25:12
• Criando o projeto e implementando o IdentityServer 24:05
• Populando as tabelas do Identity e implementando a autenticação JWT 33:51
• Ajustando a geração do token JWT e o projeto Web 25:54
• Exibindo o catálogo de produtos e seus detalhes 25:01
• Criando o microsserviço CartApi – I 23:55
• Criando o microsserviço CartApi – II 25:35
• Definindo as configurações e serviços para consumir o microsserviço CartApi 30:20
• Exibindo os itens do carrinho de compras 28:12
• Criando o microsserviço para cupom de desconto – DiscountApi 21:10
• Consumir o microsserviço DiscountApi 29:19
• Conclusão: Realizando o Checkout e integrando com o microsserviço CartApi 18:13
• Código do projeto no GitHub 00:01

.NET 6 – Projeto ASP.NET Core MVC – Introdução

• Introdução Visualizar 02:00
• Apresentando o .NET 6 05:34
• Visual Studio 2022 – Apresentação e Instalação 04:49
• Visual Studio Code – Instalação e criação do projeto MVC 05:36
• Visual Studio 2022 – Template do Projeto MVC Visualizar 10:17
• Visual Studio 2022 – Hot Reload Visualizar 06:20
• SQL Server e SQL Server Management Studio 08:42

.NET 6 – Projeto ASP.NET Core MVC – Site para venda de Lanches 

• Apresentação do site de Venda de Lanches 10:14
• Ambiente e Ferramentas usadas no curso Visualizar 04:37
• Criação do projeto ASP.NET Core MVC 05:58
• Apresentando a estrutura do projeto 06:22
• Apresentando o padrão MVC – Model View Controller 13:15
• Funcionamento do projeto ASP.NET Core MVC 12:14
• Criando o Carousel no site para venda de Lanches 06:18
• Considerações sobre a arquitetura do projeto 04:11

.NET 6 – Modelo de Dominio – Entity Framework Core 

• Criando o Modelo de dominio 12:23
• Apresentando o Entity FrameworkCore 06:20
• Configurando o EF Core 09:29
• Montando a string de conexão com o SQL Server Visualizar 12:45
• Entity Framework Core 7 e a string de conexão 06:11
• Apresentando o Data Annotations 08:42
• Apresentando o Migrations do EF Core 11:39
• Aplicando os atributos Data Annotations 07:22
• Aplicando o Migrations no projeto 09:25
• Como popular as tabelas usando o Migrations 05:58
• Populando a tabela Categorias com dados iniciais 05:49
• Populando a tabela Lanches com dados iniciais 05:59
• Apresentando o padrão Repository 05:33
• Implementando o padrão Repository para Categoria 07:59
• Implementando o padrão Repository para Lanches 09:23
• Registrando o serviço dos repositórios: Injeção de Dependência 08:27

.NET 6 – Controllers e Views 

• Criando o Controller a View para exibir os lanches 09:49
• Ajustando o código da View List 05:59
• Conceitos: ViewData, ViewBag e TempData Visualizar 09:17
• Conceitos: _ViewStart e _ViewImports 04:56
• Bootstrap: Ajustando o código para exibir os lanches 06:10
• Apresentando o conceito de ViewModel 04:55
• Implementando a view model LancheListViewModel 06:40
• Apresentando Partial Views 07:12
• Criando a partial view _LanchesResumo 04:43
• Criando os itens do Carrinho de Compras: Conceitos 05:12
• Implementando os itens do carrinho de compras 06:28
• Apresentando o conceito de Session Visualizar 04:59
• Configurando Session e HttpContext 03:51
• Criando o Carrinho de Compras 09:17
• Adicionar Itens ao Carrinho de Compras 04:33
• Remover itens do Carrinho de Compras 02:48
• Concluindo o Carrinho de Compras 05:14
• Criando o Controlador para gerenciar os itens do carrinho de compras 09:56
• Criando o Controlador para gerenciar os itens do carrinho de compras – II 07:13
• Criando a View para exibir os itens do carrinho de compras 10:31
• Exibindo os lanches preferidos 07:13
• Apresentando o conceito de ViewComponent Visualizar 04:08
• Criando uma ViewComponent para exibir detalhes do carrinho 11:43
• Apresentando o conceito de TagHelpers 05:21
• Criando uma TagHelper 08:51
• Ajustando o LancheController para exibir lanches por categoria 08:06
• Apresentando os conceitos sobre Roteamento 08:12
• Múltiplas Rotas – Criando a rota para exibir lanches por categoria 11:21
• Criar View Componente para exibir as categorias no menu Lanches 09:51
• Otimizando o método Action List de LancheController 05:43
• Incluindo um link e um button na exibição dos lanches 10:20

.NET 6 – Pedidos: Ajustando o Modelo – Migrations 

• Pedidos – Expandindo o modelo de domínio 11:54
• Criando o repositório para os pedidos 08:33
• Localizando lanches por nome – Search 07:37
• Criando o controlador PedidoController 08:13
• Criando a view Checkout 06:39
• Criando o método Action Checkout (HttpPost) 08:39
• Criando a view CheckoutCompleto – Exibindo um resumo do pedido 09:30
• Criando um layout alternativo para o site de lanches Visualizar 05:26

.NET 6 – Identity: Autenticação e Autorização 

• Autenticação e Autorização 14:36
• Configurando o Identity no projeto 10:53
• Implementando o Login – I 06:42
• Implementando o Login – II 06:56
• Criando a View Login 08:11
• Implementando o Registro – I 07:35
• Criando a View Register 09:50
• Implementando o Logout 09:45
• Implementando a autorização – Authorize 11:03

.NET 6 – Área de Administração 

• Apresentando o conceito de Areas – Criando a área Admin 09:16
• Area Admin – Configuração e criação do AdminController 08:29
• Roteiro para implementar o perfil para o usuário Admin 06:51
• Definindo o perfil para o usuário Admin 10:57
• Testando a implementação do perfil Admin 05:55
• Criando a view AccessDenied e o menu para o usuário Admin 06:01
• Criar os controladores e views para gerenciar lanches, categorias e pedidos – I 10:55
• Criar os controladores e views para gerenciar lanches, categorias e pedidos – II 07:46

.NET 6 – Novas Funcionalidades – Paginação, Filtro de dados, Detalhes do Pedido 

• Roteiro implementar a paginação, filtro de dados e demais ajustes 09:46
• Implementando a paginação e filtro de dados 11:41
• Implementando a paginação para Lanches 10:49
• Roteiro e implementação dos detalhes do pedido na área Admin 10:20
• Implementação dos detalhes do pedido – Explicação detalhada 13:51
• Criando o relatório de pedidos por período 13:18

.NET 6 – Gerenciamento de Imagens 

• Gerenciamento de Imagens – Conceitos, abordagem e roteiro de configuração 11:03
• Implementação – Configuração e criação dos arquivos da infraestrutura 06:09
• Implementação – Exibindo as opções para Upload e Consulta de imagens Visualizar 12:17
• Implementação – Enviando arquivos 11:37
• Implementação – Exibindo e Deletando imagens 09:39

.NET 6 – Gerando gráficos com o GoogleChart 

• Gerando gráficos usando a biblioteca GoogleChart – Criando o modelo de dominio 04:56
• Criando o serviço para gerar os dados para os gráficos 10:15
• Criando o controlador e os métodos Actions 04:16
• Criando o menu com as opções dos gráficos 04:05
• Criando a view Index para gerar o gráfico de barras Visualizar 08:51
• Criando a view VendasMensal par gerar o gráfico de coluna 09:03
• Criando a View VendasSemanal para gerar o gráfico de linha 08:19
• Criando um rodapé e inserindo uma imagem ao título do site 05:29

.NET 6 – Migrando o código da classe Startup para a classe Program 

• Registrando os serviços e configurando os middlewares na classe Program 06:21
• Implementando a configuração na classe Program e removendo a classe Startup 09:27

.NET 6 – Deploy do projeto no IIS 

• Fazendo o Deploy no IIS remoto (Host Azul) 13:06

.NET 6 – Gerando Relatórios e PDF usando o FastReport OpenSource 

• Configurando o projeto para usar o FastReport 07:15
• Criando o leiaute do relatório usando o Designer 09:16
• Criando os serviços para obter os dados 06:49
• Criando o Controller e a View para gerar o relatório 11:23
• Gerando o relatório no formato PDF 07:09

Migrações para o .NET 6.0, .NET 7.0 e .NET 8.0 

• Migração do Projeto Venda de Lanches do .NET 5 para o .NET 6 12:05
• Migração do Projeto Venda de Lanches do .NET 6 para o .NET 7 12:49
• Migração do projeto do .NET 7.0 para o .NET 8.0 10:28

Introdução 

• Como acompanhar o curso Visualizar 05:50
• Como executar a aplicação 03:59
• Como reportar dúvidas e erros 07:50

Aplicação Back-end – API ASP.NET Core 

• Apresentando o objetivo e a aplicação backend – I Visualizar 06:30
• Apresentando a aplicação backend – II 14:41
• Testando os endpoints do backend – I Visualizar 12:17
• Testando os endpoints do backend – II 12:20
• Criar aplicação web no Azure Visualizar 05:31
• Criar o banco de dados SQL Server no Azure 03:50
• Publicar a API no Azure 05:31

Aplicação Front-end – .NET MAUI 

• Criando a aplicação .NET MAUI Visualizar 12:04
• Criando o modelo de dados e o serviço para consumir a API Visualizar 11:01
• Criando o Registro e o Login do usuário – I 11:35
• Criando o Registro e o Login do usuário – II 14:33
• Criando a página AppShell e iniciando a validação 13:16
• Registrando a validação, criando um Dev Tunnels e testando a validação 10:40
• Exibindo Categorias e Produtos – I Visualizar 16:54
• Exibindo Categorias e Produtos – II 15:56
• Exibindo produtos de uma categoria – I 08:23
• Exibindo produtos de uma categoria – II 09:08
• Exibindo os detalhes de um produto – I Visualizar 08:35
• Exibindo os detalhes de um produto – II 11:34
• Gerenciando os detalhes do produto – I 07:48
• Gerenciando os detalhes do produto – II Visualizar 07:37
• Exibindo os itens do carrinho de compras – I 14:20
• Exibindo os itens do carrinho de compras – II 13:05
• Incrementa/Decrementa quantidade, exclui item e exibe endereço – I 12:13
• Incrementa/Decrementa quantidade, exclui item e exibe endereço – II 10:56
• Confirmar Pedido e outros ajustes – I 11:39
• Confirmar Pedido e outros ajustes – II 11:38
• Marcando/Desmarcando e exibindo produtos como favoritos – I 11:57
• Marcando/Desmarcando e exibindo produtos como favoritos – II 11:01
• Criando a página de perfil – I 10:49
• Criando a página de perfil – II 09:43
• Criando a página de Perfil – III 14:08
• Perfil – Meus Pedidos e seus detalhes – I 11:56
• Perfil – Meus Pedidos e seus detalhes – II 10:51
• Perfil – Minha Conta e Perguntas Frequentes – I 08:41
• Perfil – Minha Conta, Perguntas Frequentes e Logout Visualizar 07:23
• Otimizando o código do projeto – I 10:06
• Otimizando o código do projeto – II 08:51
• Executando o app Android no Celular e Espelhando a tela no PC 11:38
• Publicação e Distribuição – Gerando o APK e o AAB assinados para Android – I 11:46
• Publicação e Distribuição – Gerando o APK e o AAB assinados para Android – II 10:29
• Acessando a API no Azure a partir do emulador Android 02:38

Bônus – .NET MAUI – Apresentando os conceitos básicos 

• Iniciando com MAUI Visualizar 18:44
• XAML language e Pages 18:15
• Layouts – FlyoutPage e TabbedPage 16:33
• Layouts – StackLayout 18:47
• Layouts – Grid 22:26
• Layouts – FlexLayout Visualizar 18:25
• Layouts – AbsoluteLayout 15:46
• Controles de Apresentação 17:57
• Controles que iniciam comandos 21:30
• Controles que definem valores 19:39
• Controles de edição e atividade 21:11
• Controles que exibem coleções 23:02
• DataBinding – I 19:05
• DataBinding – II 20:37
• Imagens, Fontes, ícones e outros arquivos 27:45
• MVVM – Model-View-ViewModel – I Visualizar 20:32
• MVVM – Model-View-ViewModel – II 29:09
• MVVM – Model-View-ViewModel – III 17:27
• Usando o MVVM Community Toolkit 21:37
• Conversores de valores 23:35
• Navegação Hierárquica 28:55
• Navegação Shell 26:09
• Usando Estilos 25:38
• Apresentando Estilos 19:12
• Apresentando CollectionView – I 24:52
• Apresentando CollectionView – II 16:50
• Apresentando CollectionView – III 27:00
• Consumindo um serviço REST Visualizar 33:05
• Acessando o SQLite 30:28
• App Meus Livros com SQLite 19:01

Introdução 

• Apresentação Visualizar 03:50
• Ambiente 06:08
• Ambiente do Visual Studio 2019 05:19
• Apresentando a IDE do Visual Studio 2019 05:25
• .NET Core SDK – Instalação 04:06
• Instalação do Visual Studio Code 07:55
• Apresentação da ferramenta NET CLI 10:54
• Usando a ferramenta NET CLI 05:32

Conceitos e fundamentos 

• Modelo Anêmico 10:19
• Separação dos Conceitos 04:27
• Dependency Inversion Visualizar 09:05
• Padrão Repository 06:22
• Padrão MVC 06:42
• Padrão CQRS 07:28
• Arquitetura Monolítica 05:59
• Arquitetura em Camadas 06:57
• Arquitetura Cebola Visualizar 11:54
• DDD – Domain Drive Design 08:15
• Clean Architecture 11:46
• Testes de Unidade – xUnit 08:28

Apresentando o problema, o projeto e a solução 

• Apresentando o problema Visualizar 06:02
• Apresentando o projeto: objetivo e escopo geral 07:57
• Apresentando a solução 09:00
• Criação da solução e dos projetos no VS 2019 07:09
• Criação da solução e dos projetos usando a ferramenta NET CLI 11:23
• Criando as dependências entre os projetos no VS 2019 03:27
• Criando as dependências entre os projetos usando a NET CLI 04:13

Implementando a camada Domain 

• Criando as entidades do modelo domínio Visualizar 08:09
• Enriquecendo o modelo de domínio criado – I 09:19
• Enriquecendo o modelo de domínio criado – II 08:44
• Criando as interfaces dos repositórios 06:05
• Implementando os testes de unidade para o projeto Domain 04:44
• Testes de unidade para a entidade Category 13:43
• Testes de unidade para a entidade Product 05:44
• Fazendo ajustes no modelo de domínio Product 06:31

Implementando a camada Infrastructure 

• Criando a estrutura do projeto, incluindo as referências e criando o contexto 10:06
• Configurando as entidades usando a Fluent API 13:27
• Implementação dos Repositórios – Conceitos Visualizar 04:43
• Implementando o Repositório – CategoryRepository 06:33
• Implementando o repositório – ProductRepository 06:08
• Apresentando o contêiner de injeção de dependência 08:04
• Projeto Infra.IoC – Registrando os serviços do contexto e do repositório 07:24
• Migrations – Conceitos e recursos usados 07:29
• Aplicando o Migrations do EF Core 09:44
• Migrations Erros – Alternativa 08:44

Implementando a camada Application 

• Mapeamento de objetos – Data Transfer Objects e AutoMapper Visualizar 10:43
• Criando os DTOs e os mapeamentos com AutoMapper 06:09
• Definição dos Serviços para Category e Product 06:28
• Implementando o serviço para Category – CategoryService 08:53
• Implementando o serviço para Product – ProductService 07:18
• Testando os serviços e o repositórios implementados – Roteiro 07:59
• Teste – Registrando os serviços e criando o Controller e View para Category 09:15
• Teste – Criando o Controller e View para Product 06:06
• Padrão CQRS – Roteiro de implementação Visualizar 09:35
• CQRS – Implementando os Commands e as Queries para Product 09:58
• CQRS – Apresentando os Handlers – Conceitos e roteiro de implementação 07:09
• CQRS – Implementando os Handlers para Commands e Queries 10:04
• CQRS – Testando a implementação – I 08:18
• CQRS – Testando a implementação – II 05:28
• CQRS – Ajustando a classe ProductService: usando o Mediator 06:35
• Considerações sobre a implementação do CQRS 07:52

Implementando a camada WebUI 

• Camada de Apresentação – HomeController, roteamento, view Index e Layout 09:49
• Controladores, Views, Tag Helpers, Bootstrap – Conceitos e recursos Visualizar 08:47
• Criando uma nova categoria 09:01
• Editar uma categoria 08:09
• Deletar uma categoria 07:08
• Exibir detalhes de uma categoria 03:50
• Cria um novo produto 10:26
• Editar um produto 04:51
• Deletar um produto 03:43
• Exibir detalhes de um produto 08:36
• Concluindo a implementação de produtos e categorias 05:25

Implementando a Segurança 

• Considerações e Proposta para implementar a segurança Visualizar 03:32
• Apresentando conceitos da ASP.NET Core Identity 06:43
• Incluindo as referências, alterando o contexto e aplicando o Migrations 05:56
• Criando as interfaces na camada Domain 05:18
• Implementando a interface IAutenticate 04:46
• Implementando a interface ISeedUserRoleInitial 07:25
• Incluindo os serviços do Identity e registrando os serviços no projeto Infra.IoC 04:05
• Criando o controlador AccountController e as ViewModels na camada WebUI 06:02
• Implementando o Login, Register e Logout em AccountController 04:19
• Criando as Views Login, Register e a partial view _LoginPartial 07:32
• Criando os usuários iniciais e testando a implementação Visualizar 07:58

Clean Architecture – Conclusão 

• Conclusão do curso 09:24
• Extensão do curso: Projeto Web API e segurança com JWT 01:10

Incluindo a camada Web API 

• Criação do projeto ASP.NET Core Web API – CleanArchMvc.API Visualizar 09:47
• Configurando o projeto CleanArchMvc.API 05:20
• API, REST e RESTFul – Conceitos básicos 07:03
• Criando o controlador CategoriesController 06:09
• HettpGet – Retornando todas as Categorias 05:14
• HttpGet{id} – Retornando uma Categoria pelo seu Id 04:11
• HttpPost – Criando uma nova Categoria 05:02
• HttpPut – Alterando uma Categoria existente 03:56
• HttpDelete – Excluindo uma Categoria pelo seu Id 03:48
• Implementando o controlador ProductsController 05:46
• Conclusão – Testando o controlador ProductsController 09:43

API – Implementando a Autenticação JWT 

• JSON Web Tokens – Conceitos Visualizar 06:49
• ASP.NET Core – Autenticação JWT: recursos usados 07:02
• Configurando as informações do token e os DTOs usados 05:29
• Criando o controlador TokenController 07:15
• Criando o método para gerar o Token JWT 12:50
• Criando o endpoint para criar o usuário 05:59
• Ativando a autenticação e validando o token JWT 11:33
• Configurando o Swagger para usar o token JWT 10:28
• Testando a implementação da autenticação e geração do token JWT Visualizar 08:29

Migração para o .NET 6.0 

• Migração dos projetos para o .NET 6.0 09:14

Criação do projeto no NET 6 com VS 2022 

• Criando a solução e os projetos e as dependências entre os projetos 09:01
• Ajustando o projeto Domain 07:04
• Ajustando o projeto Infra.Data e Application 08:23
• Ajustando o projeto Infra.IoC e WebUI 07:50
• Ajustando o projeto API e testando o projeto 12:02

Migração do .NET 6.0 para o .NET 7.0 

• Migrando para o .NET 7 12:27

Migração do .NET 7.0 para o .NET 8.0

• Migrando para o .NET 8.0 08:33

Apresentação e Introdução 

• Apresentação Visualizar 05:59
• Contextualizando o Docker 06:17
• Apresentando o Docker Visualizar 06:54

O Ambiente de execução 

• Instalando o Ubuntu Visualizar 08:26
• Instalando o Docker Visualizar 06:16
• Instalando o .NET Core SDK Visualizar 04:59
• Instalando o VS Code 05:11
• Instalando o Docker for Windows 05:48
• Usando o Docker no Windows 05:33

Contêineres 

• Criando Contêineres – I Visualizar 08:18
• Criando Contêineres – II 09:52
• Comandos Docker: Nova Sintaxe 03:05
• Contêiner: Mapeando portas 07:42
• Contêiner: Mapeando pastas 08:14
• Contêiner Docker com .Net Core 11:48
• Contêineres – Exercícios 00:07

Imagens 

• Apresentando Imagens do Docker 07:33
• Criando imagens usando Dockerfile 14:18
• Gerenciando Imagens 05:56
• Criando uma aplicação ASP .NET Core MVC 14:46
• Aplicação ASP.NET Core MVC – Atualização .NET 6 11:17
• Criar Imagem para a Aplicação ASP .NET Core MVC 11:12
• Criar Imagem ASP.NET Core MVC – Ajuste .NET 6 07:40
• Publicando Imagens 05:26
• Imagens – Exercícios 00:13

Volumes 

• Apresentando Volumes 07:55
• Criando Volumes: DataBase MySQL 12:16
• Ajustar Aplicação MVC com EF Core e acessar MySql 16:05
• Ajustar Aplicação MVC-MySql EF Core – Atualização .NET 6 08:47
• Criar Contêiner MySQL usando imagem base 05:26
• Atualizar imagem da aplicação MVC 07:33
• Conectando dois contêineres: MVC e MySQL 09:38
• Volumes – Exercícios 00:06

Networks 

• Apresentando Redes no Docker 05:45
• Usando redes virtuais Visualizar 05:05
• Criando redes Customizadas no Docker 07:50
• Escalando a aplicação MVC usando redes 05:45
• Usando redes customizadas 12:21
• Usando um balanceador de carga e escalando a aplicação MVC 05:27
• Networks – Exercícios 00:06
• Projeto mvc1 00:02

Docker Compose 

• Introdução ao Docker-Compose 07:33
• Usando o Docker Compose 07:32
• Criando o arquivo de composição 09:03
• Ajustando a aplicação MVC: Usando script SQL 10:32
• Criando o serviço para o contêiner MVC 11:44
• Docker Compose – Exercícios 00:06
• Projeto – mvc1 00:01

Desenvolvimento na plataforma .NET 

• Fazendo o Deploy no Contêiner 13:36
• Otimizando o arquivo Dockerfile 06:59
• Aplicando o recurso: multi-stage build 07:36
• Usando a extensão Docker no VS Code 08:18

Docker Desktop for Windows 

• Introdução 02:22
• Instalação do Docker Desktop for Windows Visualizar 07:43
• Testando a instalação 05:39
• Suporte ao Docker no Visual Studio 02:51
• Habilitando o suporte ao Docker em um novo projeto 10:57
• Criando uma ASP .NET Web API e um contêiner MongoDB Visualizar 10:12
• Testando a WEB API acessando o contêiner do MongoDB localmente 09:13
• Orquestrando os contêineres: Configurando os arquivos docker-compose do projeto 09:03
• Orquestrando os contêineres da API e do MongoDB: acessando dados no mongo 07:37
• Acessando o SQL Server com uma Web API Visualizar 04:40
• Configurando o projeto ASP .NET Core Web API 06:45
• Criando a API ProductsController 04:39
• Gerando o Dockerfile e o arquivo docker-compose.yml e fazendo a orquestração 10:39
• Fazendo o CRUD básico no SQL Server via API usando o Postman 07:37
• Acessando o contêiner do SQL Server e inspecionando os dados 05:22

Docker Desktop for Windows – II 

• Criando uma Web API e acessando o MySQL Visualizar 09:09
• Definindo a string de conexão e criando o Controlador 08:02
• Testando a Web API usando o MySQL Local 05:43
• Gerando o arquivo Dockerfile e docker-compose 05:36
• Definindo o serviço para a API no arquivo docker-compose 05:12
• Definindo o serviço para criar o contêiner do MySQL 07:19
• Realizando a orquestração dos contêineres e testando a API 10:09

Docker – Containerizando aplicações Blazor (.NET 8) 

• Blazor Server Visualizar 21:47
• Blazor Server e SQL Server 29:13
• Blazor WebAssembly 16:31

BÔNUS – Criando Microsserviços com Docker e Visual Studio 

• Apresentação 01:13
• NET – Criando Microsserviços fluxo básico 19:17
• NET – Criando Microsserviços API Catalogo com MongoDB – I Visualizar 14:00
• NET – Criando Microsserviços API Catalogo com MongoDB – II 11:38
• NET – Criando Microsserviços API Catalogo com MongoDB – IV 12:29
• NET – Criando Microsserviços API Catalogo com MongoDB – V 16:05
• NET – Criando Microsserviços API Catalogo com MongoDB – VI 16:37
• NET – Criando Microsserviços API Basket com Redis – VI Visualizar 13:56
• NET – Criando Microsserviços API Basket com Redis – VII 14:41
• NET – Criando Microsserviços API Basket com Redis – VIII 15:26
• NET – Criando Microsserviços API Discount com PostgreSQL – IX Visualizar 17:52
• NET – Criando Microsserviços API Discount com PostgreSQL – X 22:18
• NET – Criando Microsserviços API Discount com gRPC – XI Visualizar 13:20
• NET – Criando Microsserviços API Discount com gRPC – XII 12:32
• NET – Criando Microsserviços API Discount com gRPC – XIII 15:21
• NET – Criando Microsserviços Consumindo a API Discount.Grpc – XIV 10:03
• NET – Criando Microsserviços Consumindo a API Discount.Grpc – XV 12:08
• 18_Criando Microsserviços Conteinerizando a API Discount.Grpc – XVI 11:11

BÔNUS – Kubernetes: Conceitos básicos 

• Apresentando Kubernetes: conceitos Visualizar 16:51
• Prática: Definindo o ambiente, Minikube, arquivos YAML, criando um Pod 18:37
• Kubernetes – Apresentando o objeto Replicaset 17:09
• Kubernetes – Apresentando objeto Deployment 19:32
• Kubernetes – Apresentando Services 18:25
• Prática – Deploy de aplicação ASP .NET Core no cluster Kubernetes com minikube 20:34
• Pratica – Deploy de Microsserviço no cluster Kubernetes com minikube 24:26
• Kubernetes – Gerenciamento de aplicações Visualizar 23:11
• Apresentando e usando o Ingress 17:44
• Apresentando Volumes 20:04
• Apresentando Persistent Volumes 24:10
• Persistent Volumes com ASP.NET Core e SQL Server 21:10
• Apresentando Secrets 25:33
• Apresentando Helm 18:06
• Helm: Prática – Deploy, Upgrade e Rollback 13:58

Introdução 

• Introdução: Padrões de projetos Estruturais Gof Visualizar 04:07
• Ambiente Visualizar 06:46
• Visual Studio Code 06:53
• Visual Studio 2019 04:59

Fundamentos 

• Introdução 00:47
• Classes e Objetos 08:40
• Acoplamento Visualizar 03:39
• Interfaces 13:51
• Encapsulamento 10:36
• Abstração 06:36
• Herança Visualizar 05:51
• Classe Abstrata 08:57
• Polimorfismo 08:54
• UML 09:16

Padrão Adapter 

• Conceitos 06:48
• Exemplo de Implementação 10:50
• Exercício 01:26
• Solução 05:42

Padrão Bridge 

• Conceitos Visualizar 07:02
• Exemplo de implementação 04:08
• Exercício 01:41
• Solução 12:37

Padrão Composite 

• Conceitos 08:58
• Exemplo de implementação 13:32
• Exercício 02:44
• Solução – Parte 1 Visualizar 02:50
• Solução – Parte 2 13:29

Padrão Decorator 

• Conceitos 08:30
• Exemplo de implementação 13:57
• Exercício 03:46
• Solução – Parte 1 12:33
• Solução – Parte 2 04:29

Padrão Facade 

• Conceitos 05:58
• Exemplo de implementação 14:54
• Exercício 04:49
• Solução 12:57

Padrão Flyweight 

• Conceitos 07:48
• Exemplo de implementação – I 04:39
• Exemplo de implementação – II 13:11
• Exercício 02:12
• Solução – Parte 1 Visualizar 02:48
• Solução – Parte 2 09:27

Padrão Proxy 

• Conceitos 06:18
• Exemplo de implementação – I 03:59
• Exemplo de implementação – II 09:25
• Exercício 02:16
• Solução 10:15

Exercícios sobre Padrões de Projeto 

• Identifique o padrão de projeto – Exercícios e Resolução 10:39

Conclusão do Curso 

• Palavras finais 00:50

BÔNUS – Padrões de Projetos Comportamentais – Gof 

• Padrão Chain of Responsibility 15:32
• Padrão Command 12:52
• Padrão Interpreter 14:35
• Padrão Iterator 14:14
• Padrão Mediator 14:48
• Padrão Memento 15:08
• Padrão Observer 15:14
• Padrão State 13:58
• Padrão Strategy 12:56
• Padrão Template Method 11:24
• Padrão Visitor 12:44

Introdução 

• Apresentação Visualizar 02:41
• Ambiente Visualizar 08:57
• Padrões de Projeto Visualizar 04:57

Fundamentos da Programação Orientada a Objetos 

• Introdução – Conceitos básicos da POO Visualizar 00:28
• Classe 08:40
• Acoplamento 03:39
• Interfaces 13:51
• Encapsulamento 10:36
• Abstração 06:36
• Herança 05:51
• Classe Abstrata 08:57
• Polimorfismo 08:54
• UML 09:16

Padrões de Projeto Criacionais 

• Introdução – Padrões Criacionais 02:19
• Simple Factory 12:02
• Factory Method 15:32
• Factory Method – Evitando o uso do bloco de código if/else ou switch/case 09:28
• Abstract Factory 12:58
• Abstract Factory – Implementação do padrão com classes abstratas Visualizar 10:48
• Builder 10:58
• Fluent Builder 08:41
• Comparação entre os padrões Factory 08:06
• Prototype 15:08
• Prototype – Exemplo 07:59
• Singleton Visualizar 10:33
• Singleton – Thread Safety 07:34
• Singleton Static 08:47
• Singleton Eager e Lazy Loading 05:55
• Singleton : Comparação com classe estática 06:18
• Singleton – Exemplo 05:42

Exercícios sobre padrões de projetos Criacionais 

• Exercicio1 02:17
• Exercicio1 – Resolução 05:34
• Exercicio2 01:37
• Exercício2 – Resolução 11:22
• Exercicio3 02:10
• Exercício3 – Resolução 07:06
• Exercicio4 01:53
• Exercício4 – Resolução 07:45
• Exercicio5 01:08
• Exercício5 – Resolução 09:09
• Exercicio6 01:13
• Exercício6 – Resolução 11:35