1a. Introdução ao Blazor -  4:55 min.
- Apresentação dos conceitos
- Navegadores
- Wasm - WebAssembly

2a. Vantagens do Blazor - 3:47 min.
- Principais vantagens do Blazor
- Criar UIs interativas usando C#
- Compartilhar lógica do aplicativo
- Aproveitar o ecossistema .NET
- Trabalhar com Componentes
- Interagir com JavaScript

3a. Modelo de Hospedagem WebAssembly -  2:42  min.
- Aplicações são executadas no Navegador
- Necessita runtime .NET e DLLs necessárias
- Blazor Client e Blazor Cliente + Asp.Net Core
- Vantagens e desvantagens

4a. Modelo de Hospedagem Blazor Server -  1:53 min.
- Aplicações são executadas no servidor
- Utiliza conexão SignalR
- Não precisa do runtime .NET
- Vantagens e desvantagens
 
5a. Preparando e Configurando o Ambiente - 4:59 min.
-  Instalar .NET Core 3.0 SDK
-  VS Community 2019
-  VS Code e extensões
-  Instalar template Blazor WebAssembly

6a. Projeto WebAssembley no VS 2019 -  5:44 min.
- Criando um projeto no modelo WebAssembly no VS 2019
- Uma solução com 1 projeto Client

7a. Projeto WebAssembly com ASP .NET Core - 3:50 min.
- Criando um projeto no modelo WebAssembly no VS 2019
- Usando a hospedagem ASP .NET Core
- Compartilhar código front-end e back-end
- Uma solução com 3 projetos: Client, Server e Shared

8a. Projeto WebAssembley no VS Code -  4:15 min.
- Criando um projeto WebAssembly no Visual Studio Code

9a. Projeto Server no VS Code -  4:45 min.
- Criando um projeto Blazo Server no Visual Studio Code

10a. Comparando os modelos de Hospedagem -  3:30 min.
- Comparando os modelos de Hospedagem : WebAssembly e Blazor Server
 

1a. Apresentando o Razor - 12: 14 min.
- A sintaxe Razor
- Conceitos básicos sobre a sintaxe Razor
- Exemplo prático - projeto

2a. Classes - 9: 39 min.
- Razor - Como criar e usar classes
- Parte prática  -  Projeto

3a. Usando Laços - 8:27 min.
- Razor : Usando laços for e foreach
- Parte prática  -  Projeto

4a. Usando Condicionais - 8:53 min.
- Usando condicionais : if, if-else, if-else-if, switch
- Parte prática  -  Projeto

5a. Apresentando o DataBinding - 8:44 min.
- Data Binding - Conceito
- One-way DataBinding
- Two-way DataBinding
- Parte prática  -  Projeto

6a. DataBinding e Atributos Condicionais HTML - 4:44 min.
- DataBinding aplicado a atributos condicionais
- Atributos HTML :  disabled, readonly, checked
- Parte prática  -  Projeto

7a. Diretivas - 2:20 min.
- Principais diretivas usadas no Blazor
- Sintaxe usada nas diretivas
- Principais Atributos

8a. Processo de Inicialização - 3:53 min.
- Processo de inicialização do projeto Blazor
- Substituindo o texto 'Loading...'

9a. Criando projeto Tarefas - 4:36 min.
- Criando projeto WebAssembly - Tarefas
- Apresentando um resumo dos recursos usados no projeto

10a. Criando projeto Tarefas - 12:26 min.
- Criando projeto WebAssembly - Tarefas , no VS 2019
- Parte prática  -  Projeto
 

1a. Componentes : Introdução - 9: 48 min.
- Apresentando o conceito de componente no Blazor
- Processo de compilação
- A extensão .razor e a extensão .cshtml
- Exemplo prático : Criando componentes

2a. Componentes  - II - 10:57 min.
- Criando e usando Componentes
- Parâmetros, diretivas e eventos usados :
- Criando componente para exibir informações

3a. Componentes : DataBinding - 5:20 min
- One-way databinding e Two-way databinding em componentes
- A diretiva @bind , @bind-value, @bind-value :  event
- Exemplo prático - projeto

4a. Eventos -  6:51 min.
- O suporte aos eventos
- Principais eventos
- Exemplos práticos - projeto

5a. EventCallBack -  4:38 min.
- Passando métodos como parâmetros em Componentes
- Usando EventCallBack - sintaxe
- Projeto prático - exemplo

6a. RenderFragment e  ChildContent -   7:15 min.
- Passando informações com conteúdo diverso
- Conceito e sintaxe do RenderFragment
- Renderizando com ChildContent
- Exemplo prático - projeto

7a. RenderFragment  - II -   4:29 min.
- Renderizando mais de uma seção  de conteúdo
- Criando parâmetros do tipo RenderFragment
- Exemplo prático - projeto

8a. RenderFragment Genérico -   9:22 min.
- Passando dados para usando RenderFragment<T>
- Exemplo prático - projeto

9a. Ciclo de vida dos Componentes -   6:10 min.
- Apresentando o ciclo de vida dos componentes
- Inicialização, Recepção parâmetros, Término de renderização
- Descontrução do componente
- O método StateHasChanged
- Sintaxe de cada método do ciclo de vida

10a. Ciclo de vida dos Componentes - II -   5:55 min.
- Execução dos métodos do ciclo de vida dos componentes
- Exemplo prático - projeto

11a. Injeção de Dependência (DI) -   6:26 min.
- Conceito de Injeção de dependência
- Definindo a configuração dos serviços
- Vantagens em usar e modo de implementação
- Diretiva @inject, propriedade, construtor
- DI nativos :  HttpClient, IJSRuntime e NavigationManager
- Tempo de vida de um serviço

12a.  Injeção de Dependência - Prática -  7:15 min.
- Implementando a injeção de dependência (DI)
- Exemplo prático - projeto

13a. Injeção de Dependência - Repositório -   6:14 min.
- Usando a DI para desacoplar a lógica de acesso a dados
- Implementando um repositório
- Interface IRepositorio e Repositorio
- Exemplo prático - projeto

14a. Code-Behind -   7:09 min.
- Obtendo a experiência Code-Behind
- Como criar o code-behind
- Exemplo prático - projeto

15a. Layouts -   5:21 min.
- Apresentando o recurso Layout
- MainLayout e NavMenu
- Arquivo App.razor
- Layouts específicos : @layout
- Exemplo prático - projeto

16a. Layouts Aninhados -   6:45 min.
- Como criar arquivos de Layout
- Definir layout específico de componente
- Usando Layouts aninhados
- Exemplo prático - projeto

17a. Parâmetros em Cascata -   13:48 min.
- Passando valores em cascata entre componentes
- Usando o componente CascadingValue
- Usando o atributo CascadingParameter
- Exemplo prático - projeto

18a. Parâmetros em Cascata - Atualização  - 5:45 min.
- Atualização de valores passados em Cascata
- Atualizando valores via data binding
- Exemplo prático - projeto

19a. Usando referência de componentes  - 14:50 min.
- Usando referêcia de componentes e emitindo comandos
- Usando o atributo @ref
- Exemplo prático - projeto

20a. Invocando métodos JavaScript via C# - 11:17 min.
- Usando a interoperabilidade JavaScript
- Injetando IJSRuntime e criando uma instância
- Métodos :  InvokeAsync<T> e InvokeVoidAsync
- Usando a forma assíncrona e síncrona
- Exemplo prático - projeto

21a. Invocando código C# via JavaScript - 7:26 min.
- Chamando código estático
- Definir função JavaScript
- Usar os métodos :  dotnet.InvokeMethodAsycn e
dotnet.InvokeMethod
- Exemplo prático - projeto

22a. Usando LocalStorage - 10:50 min.
- Usando o LocalStorage do navegador
- LocalStorage e SessionStorage
- Usando pacotes Nuget :  Blazored.LocalStorage
- Exemplo prático - projeto

23a. Debug - 6:42 min.
- Debugando aplicações Blazor
- Debugando no Google Chrome
- Fluxo de operações para iniciar sessão de Debug
- Exemplo prático - projeto

24a. Razor Class Library - RCL - 13:31 min.
- Apresentando Razor Class Library
- Roteiro para Criar e Consumir uma RCL
- Radzen Blazor Components
- Exemplo prático - projeto

1a. Roteamento e Navegação -  5:30 min.
-  Navegação tradicional 
-  A navegação nas aplicação SPA
-  Aplicações Blazor SPA com código C#
-  Roteador Blazor e diretiva @page

2a. Usando a diretiva @page -  3:05 min.
- Definindo rotas
- A diretiva @page para definir rotas
- Definindo mais de rota com a diretiva @page

3a. Mecanismo de roteamento - 4:46  min.
- Componentes roteáveis.  A pasta Pages
- A pasta Shared : componentes não roteáveis
- Definindo o roteamento no arquivo App.razor
- O padrão Found e NotFound

4a. Usando parâmetros de rotas-  8:05 min.
- Passando parâmetros para rotas
- Definindo parâmetros de rotas : {nome:tipo}
- Recebendo os valores dos parâmetros de rotas
- Usando o atributo [Parameter]

5a. Restrições de rotas - 2:00 min.
- Definindo restrições de rotas
- Restrições de parâmetros de rotas

6a. Definindos rotas com Links e NavLink - 7:41 min.
- Definindo uma rota usando um hiperlink HTML :  href
- Usando o componente NavLink para criar links de navegação
- Exemplo prático

6a. NavigationManager com C#  8:38 min.
- Usando código C# para navegação
- Usando o serviço NavigationManager
- @inject NavigationManager
- Navegando e direcionando o usuário
- Membros do NavigationManager
- Navegando usando o método NavigateTo
 

1a. Apresentando Formulários -  10:04 min.
- Criando formulários usando o componente EditForm
- Eventos de EditForm
- OnSubmit, OnValidSubmit e OnInvalidSubmit
- Criando  um formulário com EditForm
- Exemplo prático

2a.  Componentes de Entrada : Input<T> -  3:59 min.
- Apresentando os componentes para entrada de dados
- Componentes de entrada padrão do EditForm
- InputText, InptuNumber, InputCheckBox, InputDate, InputSelect
- Sintaxe dos componentes de entrada Input

3a. Validação de dados em Formulários -9:06 min.
- Validando dados em formulários
- Usando Data Annotations para validação
- Principais atribuos de validação
- Exemplo prático - projeto

4a. ValidationSummary -  6:56 min.
- Exibindo mensagens de erro de validação agrupadas
- Usando ValidationSummary
- Exemplo prático - projeto

5a. ValidationMessage - 4:34 min.
- Exibindo mensagens de erro de validação específicas
- Usando ValidationMessage
- Exibindo mensagens de erros de validação para cada campo
- Sintaxe :  ValidationMessage For = "@ () => ..."
- Exemplo prático - projeto

6a. Tratando a submissão de Formulários  -  8:26 min.
-  Eventos no componente EditForm para envio de formulários
- OnSubmit, OnValidSubmit e OnInvalidSubmit
- Usando EditContext para determinar o status da entrada
- Exemplo de utilização e sintaxe
- Exemplo prático - projeto
 

1a. Fazendo o tratamento do Backend -  10:00 min.
- Fazendo o tratamento do Backend
- Usando o protocolo HTTP, EF Core e banco de dados
- Usando HttpClient para comunicação
- Enviando requisições HTTP : GET , PUT, POST e DELETE

2a. Criando o Catálogo de Categorias e Produtos  -10:42  min.
- Criando o Catálogo de produtos
- Criando o projeto WebAssembly c/hospedagem ASP .NET Core
- Definindo o modelo de dados : Categoria e Produto
- Usando o EF Core , definindo o relacionamento
- Aplicando o Migrations

3a.  Configurando o EF Core- 8:53 min.
- Configurando o Entity Framework Core no projeto Server
- Criando a classe de Contexto
- Definindo a string de conexão
- Configurando o contexto como um serviço

4a. Aplicando o Migrations -  8:32 min.
- Aplicando o Migrations
- Add-Migration <nome> e gerando o Script
- Atualizando o banco de dados :  update-database
- Ajustando o modelo com Data Annotations

5a. Criando a Web API : CategoriaController -  12:48 min.
- Criando o controlador CategoriaController no projeto Server
- Definindo os métodos Action para fazer o CRUD
- HttpGet, HttpPost, HttpPut e HttpDelete

6a. Criando a aplicação Blazor para Categorias  - 9:54 min
- Criando os componentes para gerenciar Categorias
- Criando a pasta Categoria dentro de Pages
- Criando o componente Index.razor para exibir Categorias
- Definir o comando Http GetJsonAsync para obter Categorias

7a. Criando o Componente p/Incluir Categoria - 12:40 min
- Criando o componente Create
- Criando o formulário no Componente
- Definindo os Data Annotations para validação dos dados
- Definir o comando Http PostJsonAsync para incluir categoria

8a. Criando o Componente p/Editar Categoria -  8:31 min
- Criando o componente Edit
- Usando parâmetros na rota do componente
- Selecionando a categoria pelo seu ID e exibindo no formulário
- Criando o comando Http PutJonAsync para alterar Categoria

9a. Criando o componente CategoriaForm  - 5:46 min
- Criando o componente CategoriaForm p/incluir e editar dados
- Reutilizando código com componentes
- Usando CategoriaForm para incluir e alterar categorias

10a. Criando o componente p/Excluir Categoria  - 10:12 min
- Criando o componente Delete
- Selecionando a categoria pelo seu ID e exibindo no formulário
- Criando o comando Http DeleteJonAsync p/excluir a Categoria
- Confirmando a exclusão da Categoria
- Criando o componente para Confirmar a exclusão
- Usando referência de componentes : @ref

11a. Implementando a paginação de dados  - 13:22 min
- Implementando a paginação de dados
- Definindo a paginação no projeto Blazor Server c/ASP .NET Core
- Criar classe de Paginação e métodos de extensão
- Ajustar o controlador CategoriaController

12a. Implementando a paginação de dados - II - 18:53 min
- Criando o componente de paginação no projeto Blazor Client
- Criando um paginador com links e botões usando o BootStrap
- Usando o componente de paginação para paginar categorias

13a. Filtrando dados - 8:54 min
- Criando um filtro de dados
- Filtrando as categorias pelo nome
- Criar formulário para filtro de dados
- Definir o databinding e criar os métodos para filtrar e limpar
- Ajustar o controlador para receber o nome como parâmetro
 

14a. Gerenciando Produtos -  5:36 min.
- Ajustando o modelo para exibir a imagem do produto
- Aplicando o Migrations
- Add-Migration
- Update-database

15a. Criando o controlado ProdutoController -4:48  min.
- Criando o controlador ProdutoController
- Definindo os métodos Action para realizar o CRUD

16a.  Criando o componente para Exibir Produtos - 8:53 min.
- Criando a pasta Produto na pasta Pages
- Criando o componente Index
- Definir o comando Http GetJsonAsync para obter Produtos

17a. Criando o Componente p/Incluir Produto - 11:19 min
- Criando o componente Create
- Criando o componente ProdutoForm para criar e editar
- Exibindo a relação de Categorias para produtos
- Definir o comando Http PostJsonAsync para incluir produto

18a. Ajustando a carga de Categorias -  4:13 min
- Retornar todas as categorias do controlador CategoriaController
- Criando o método HttpGet("todas")

19a. Criando um componente para Imagens -11:56 min
- Criando componente para selecionar e exibir imagens
- Usando o pacote W8lesslabs.Blazor.LocalFiles
- Selecionando imagens
- Salvando imagens no formato base64 e imagens remotas

20a. Criando o Componente p/Editar Produto -  7:20 min
- Criando o componente Edit
- Usando parâmetros na rota do componente
- Selecionando o produto pelo seu ID e exibindo no formulário
- Criando o comando Http PutJonAsync para alterar Produto

21a. Criando o componente p/Excluir Produto  - 5:29 min
- Criando o componente Delete
- Selecionando a categoria pelo seu ID e exibindo no formulário
- Criando o comando Http DeleteJonAsync p/excluiro  produto
- Confirmando a exclusão do Produto
- Criando o componente para Confirmar a exclusão
- Usando referência de componentes : @ref

22a. Criando o Catálogo de Produtos  - 11:50 min
- Criando a pasta Catalogo dentro da pasta Pages
- Criando o componente Index para exibir os produtos
- Ajustando o controlador ProdutoController
- Criando o método Action para retornar os produtos p/categoria
- Exibindo a relação de categorias
- Retornando os produtos pela categoria

23a. Exibindo os detalhes de um Produto  - 9:32 min
- Criando o componente Detalhe
- Selecionando o produto pelo seu ID
- Exibindo a relação de categorias
- Retornando os produtos pela categoria
- Exibindo o detalhe do produto

 24a. Implementando a paginação de dados  - 4:32 min
- Implementando a paginação de dados nos produtos
- Criando o componente de paginação no projeto Blazor Client
- Criando um paginador com links e botões usando o BootStrap
- Usando o componente de paginação para paginar produtos

1a. Gerenciando a autenticação e autorização - 7:55 min.
- Autenticação e Autorização
- A segurança nos projetos Blazor Server - template padrão
- A segurança nos projetos WebAssembly
- Implementando um AuthenticationStateProvider customizado
- Usando os componenet AuthorizeView e CascadingAuthenticationState

2a. Implementando um AuthenticationStateProvider demo - 8:46 min.
- Incluir os pacotes  Microsoft.AspNetCore. Components.Authorization
- Incluir o serviço no arquivo Startup: Add.AuthorizationCore()
- Criar classe customizada que herda de AuthenticationStateProvider
- Implementando o método GetAuthenticationStateAsync
- Alterando o RouteView para AuthorizeRouteView no App.razor

3a. Usando o componente AuthorizeView - 11:30 min.
- Usando o componente AuthorizeView para ocultar/exibir informações
- Definindo o atributo Authorized
- Definindo o atributo NotAuthorized

4a. Usando o atributo Authorize - 6:24 min.
- Usando o atributo Authorize em componentes roteados
- Permitindo o acesso somente a usuários autenticados
- @attribute [Authorize]
-  @attribute [Authorize(Roles='Admin']
-  @attribute [Authorize(Policy='Teste']

5a. Verificando o estado de autenticação via C# - 6:29 min.
- Usando o parâmetro [CascadingParameter] via código C#
- Exemplo prático - projeto

6a. Roteiro p/implementar autenticação c/Identity - 3:42 min.
- Definir o Identity no projeto Server
- Criar o controlador AccountController
- Definir os métodos Action para Login e Register
- Configurar o JWT e chave secreta
- Configura autenticação e autorização
- Criar componentes para Login, Logout e Register

7a. Implementando o Identity - 8:38 min.
- Incluir pacote Microsoft.AspNetCore.Identity.EntityFrameworkCore
- Ajustar o arquivo de contexto para herdar de IdentityDbContext
- Configurar o Identity no Startup
- Aplicar o Migrations para criar tabelas do Identity no SQL Server
- Configurando o JWT no Startup
- Criando a chave secreta no appsettings.json

8a. Criando o controlador AccountController - 10:15 min.
- Criando o controlador AccountController no projeto Server
- Criando os métodos Action para Login e Register
- Criando o método para gerar o token de autenticação JWT

9a. Testando a implementação com o Postman - 5:17 min.
- Testando a implementação via Postam
- Enviando um request Post para registrar um usuário
- Definindo o comanto http:// localhost:30081/api/account/register
- Passar as credenciais do usuário no formato JSON no body
- Obter o token de autenticação e verificar no banco de dados

10a. Criando o provedor de autenticação p/JWT - 13:11 min.
- Criando um AuthenticationStateProvider para JWT
- Definir os métodos de extensão para gerenciar o LocalStorage
- Usar os recursos do InteropJS via IJSRuntime
- Criando usuários não autenticado e autenticado com JWT
- Extraindo as claims do token

11a. Criando os métodos para Login e Logout- 7:02 min.
- Incluindo e excluindo o token do LocalStorage
- Criando a interface IAuthService e a classe AuthService
- Registrando o serviço no Startup
- Implementando o Login : Persistindo o token o LocalStorage
- Implementando o Logout : Removendo o token o LocalStorage

12a. Criando o componente para exibir os links p/Login e
Logout- 5:13 min.
- Criando o componente MenuAuthentication
- Definir os links para Login e Logout usando AuthorizeView
- Usar o componente no componente MainLayout

13a. Criando o componente para Login -  13:38 min.
- Criando a pasta Autentica dentro da pasta Pages
- Criando o componente para Login
- Definindo o comando http:  http.PostAsync("api/account/login", ..)
- Verificando o status do request e registrando o token no
LocalStorage

14a. Criando o componente para Logout -  5:09 min.
- Criando o componente de Logout
- Fazendo o Logout e navegando para o raiz

15a. Criando o componente para Register -  5:13 min.
- Criando o componente para registrar um novo usuário
- Criar o componente Register
- Definindo o comando http.PostAsync("api/account/register", ..)
- Verificando o status do request e removendo o token no
LocalStorage

16a. Definindo uma politica de segurança -  10:38 min.
- Revisão dos conceitos
- Definindo uma politica de segurança
- Testando a politica de segurança para usuários autenticados e não
autenticados

17a. Criando uma Role Admin e atribuindo usuários - 10:10 min.
- Implementando a autenticação baseada em Roles
- Criando os perfis User e Admin
- Criando usuários com perfil Admin
- Incluindo o serviço para Roles
- Criando os perfis Admin e User no método OnModelCreating
- Aplicando o Migrations
- Alterando o método Action Register do Controlador
AccountController
- Incluindo usuários com email 'admin' no perfil user e admin
- Ajustando a geração do token para o suporte aos perfils ou roles

1a. Características das aplicações Blazor Server -11:46 min.
- Modelo de hospedagem Blazor Server
- Características das aplicações Blazor Server
- Vantagens e Desvantagens
- Como funciona uma aplicação Blazor Server
- O uso do Debug,  dos recursos do JavaScript
- Tratamento de exceções

2a. Roteiro da aplicação p/ gerenciar Users e Roles - 5:28 min.
- Roteiro da aplicação Blazor Server para gerenciar Users e Roles com ADO .NET
- Apresentando as tabelas da aplicação CatalogoBlazor envolvidas
- Definindo as entidades : Role, User e UserRole
- Etapas definidas para criação do projeto

3a. Criando a aplicação p/ gerenciar Users e Roles - 6:56 min.
- Criando a aplicação Blazor Server no VS 2019 com NET Core 3.1
- Criando a aplicação com Autenticação
- Definindo a string de conexão e o registro do serviço
- Aplicando a migração Inicial
- Registrando um usuário

4a. Definindo a infraestrutura da aplicação - 8:40 min.
- Definindo os recurso usados no projeto
- Definindo as imagens em wwwroot/images
- Criando as entidades User
- Criando o componente Users.razor
- Criando a classe para obter a string de conexão
- Registrando o serviço no arquivo Startup

5a. Gerenciando Users - 7:39 min.
- Criando a interface e classe para implementar o serviço para acesso aos dados
- Usando o mecanismo nativo de injeção de dependência da ASP .NET Core
- Usando código ADO .NET e os objetos: SqlConnection, SqlCommand, SqlDataReader

6a. Criando o serviço para gerenciar Usuários - 14:58 min.
- Incluindo a referência ao System.Data.SqlClient
- Criando a interface IUserService e a classe UserService
- Definindo os métodos e suas implementações
- Registrando o serviço e definindo seu tempo de vida

7a. Considerações s/o Serviço : ADO .NET x EF Core - 8:21 min.
- Comparando sobre o serviço usando ADO .NET
- O acesso aos dados nas tabelas:  relacionamentos
- Chaves primárias , a deleção em cascata
- Comparando o código usado com o código do EF Core

8a. Listando os usuários existentes - 14:24 min.
- Listando os usuários da tabela AspNetUsers
- Criando o componente Users.razor
- Criando o componente para exibir avisos : Alerta.razor

 

9a. Deletando usuários - 11:13 min.
- Definindo o fluxo envolvido na exclusão de um usuário
- Criando o componente DeleteUser.razor
- Excluindo um usuário selecionado
- Confirmando a exclusão

10a. Atribuindo um Perfil a um usuário : Fluxo - 3:56 min.
- Fluxo das operações envolvidas na atribuição de um perfil

11a. Atribuindo um Perfil a um usuário   - 12:07 min.
- Criando o componente AddRoleUser.razor
- Criando a entidade Role
- Criando o serviço para obter os Perfis
- Implementando o código no componente

12a. Exibindo a lista de Perfis - 4:46 min.
- Criando o componente Roles.razor
- Definindo o código do componente
- Usando o serviço para obter e listar as roles

13a. Adicionando um novo Perfil -  11:57 min.
- Criando o componente AddRole.razor
- Criando o método para verificar se o perfil já existe
- Definindo o código para incluir um novo perfil

14a. Alterando um perfil existente: Fluxo -  3:43 min.
- Fluxo de operações para alterar um perfil

15a. Alterando um perfil existente -  9:05 min.
- Criando o método GetRole(id) para retornar um perfil
- Criar o método EditRole(id, role) para atualizar o perfil
- Criando o componente EditRole.razor
- Implementando o código no componente

16a. Excluindo um perfil existente -  8:32 min.
- Fluxo das operações para excluir um perfil
- Criando o método DeleteRole no serviço
- Criando o componente DeleteRole.razor
- Definindo o formulário de confirmação da exclusão

17a. Testando as funcionalidades implementadas -  9:21 min.
- Testando a aplicação Blazor_Admin com autenticação
- Listando os perfis dos usuários
- Atribuindo um perfil a um usuário
- Criando um novo perfil
- Testando a aplicação Blazor_Catalogo
- Testando o acesso do usuário e do perfil atribuído
- Criando um usuário em Blazor_Catalogo
- Atribuindo um perfil ao usuário na aplicação Blazor_Admin
- Testando o usuário com o perfil na aplicação Blazor_Catalogo

1a. Migrar o projeto Blazor Catalogo p/a versão 3.2.0 8:35 min
- Migrando a aplicação Blazor Catálogo criada no Curso
- Para a versão Blazor WebAssembly 3.2.0

2a. Apresentando PWA 6:11 min
- O que é PWA e como funciona
- Apresentação e conceitos
- Arquivos Manifest.json e server-worker.js
- O funcionamento Offline

3a. Criando uma aplicação Blazor PWA 12:43 min
- Criando um projeto Blazor WebAssembley 3.2.0
- Usando a opção PWA - Progressive Web apps
- Entendendendo como funciona o PWA
 

4a. Analisando a estrutura do projeto Blazor PWA 8:38 min
- Analisando a estrutura do projeto na pasta wwwroot
- Os arquivos Manifest.json, server-worker.js 
- Os arquivos server-worker.published.js, favicon.ico
- O funcionamento offline em desenvolvimento

5a. Convertendo uma aplicação Blazor para PWA 8:35 min
- Convertendo a aplicação Blazor Catalogo para PWA
- Copiando os arquivos da pasta wwwroot do projeto PWA
- O arquivo server-worker.published.js e seu papel

6a. Armazenando o Request GET no cache  8:04 min
- Aplicação Blazor Catalogo
- Criando um novo cache
- Armazenando os request GET no cache
- O funcionamento Offline

1a. Projeto Editor de Texto : RichText -  8:00 min.
- Criando o projeto Blazor Server
- Usando os recursos da Interoperabilidade do Blazor
- Usando os recurso da API do Quill
- Implementando as funcionalidades do Editor

2a.  Blazor Upload - Enviando arquivos 7:29  min.
- Criando o Projeto Blazor Server
- Referenciar o componente BlazorInputFile
- Configurando o projeto
- Enviando um e mais arquivos

3a. Blazor  Alunos :  Separar o Modelo de dados -  10:08min.
- Criando o Projeto Class Library (.NET Standard)
- Criando Projeto Blazor Server
- Referenciando os projetos e definindo o Model

4a. Blazor :  Acesso a dados com Dapper -4:48  min.
- Criando o  banco de dados
- Criando o projeto Blazor Server
- Referenciando o Dapper e definindo a camada de Dados
- Criando o serviço para consumir os dados

5a. Blazor  Clean Architecture   7:51 min.
- Apresentando os conceitos da Clean Architecture

6a. Blazor  Clean Architecture  - Criação dos projetos  6:58 min.
- Criando a solução e os projetos e relacionamentos
- Projeto Core, Data, UseCases e Blazor

7a. Blazor  Clean Architecture  - Roteiro  5:05 min.
- Roteiro da implementação dos recursos dos projetos

8a. Blazor  Clean Architecture  - Criando os recursos 10:51 min.
- Implmentando os recursos dos projetos
- Projeto Core, Data e UseCases

9a. Blazor  Clean Architecture  - Projeto Blazor 8:21 min.
- Implementando os recursos do projeto Blazor
- Ajustar o projeto e Configurar os Serviços
- Criar componentes : ProcuraProduto e ProcuraProdutoComponent

10a. Blazor  Clean Architecture  - Projeto Blazor 7:14 min.
- Implementando os recursos do projeto Blazor
- Criar componentes : ExibeProduto e ProdutoItemComponent